Gestione Personalizzata Effetti Alterati

[Secuter96]

Gestione Personalizzata di Stati, Buff e Debuff

Descrizione

Questo è il primo script che posto, perdonatemi e correggetemi se le istruzioni o il post sono fatti male. xD

Tornando allo script è pensato per giochi strategici in cui sapere quanti turni mancano prima che scada un effetto è importate! Soprattutto se voglio aumentare il livello del potenziamento fino a 4, invece che i normali 2. E se invece sono stufo dei curatori che si prendono tutta la scena? Bene, dopo due volte che ti curano gli effetti di ricarica saranno la metà!

Autore

Secuter

Funzioni dello script

- aumentare il livello massimo dei buff/debuff (di base sono 2)

- si può impostare di quanto un parametro viene modificato, differenziando fra le diverse statistiche e se buff o debuff, es. imposto che un

buff sull'attacco aumenta del 30% mentre il debuff riduce del 20% mentre per la difesa magari è il 50% ecc.

- visualizzare il numero dei turni, e i passi dal menù, rimanenti di uno stato/potenziamento

- aumentare il numero delle icone visualizzabili, mostrandole su più righe

- applicare un debuff alle cure consecutive che ne riduce l'efficacia

- aggiunta possibilità di rendere una skill immune al debuff cure, con il tag <reduction immune>

- aggiunto il parametro PermitConvecutiveStun che se settato a false impedisce gli stun consecutivi, dopo che è terminato uno stato che

blocca il personaggio per un turno ne si è immuni, sia eroi che nemici

Istruzioni

Istruzioni per la configurazione all'interno dello script, ci sono vari parametri da configurare ma niente di complicato.

Allegati

Icone per il debuff delle cure e per 2 livelli extra di buff.

http://i.imgur.com/qMzMvxD.png

http://i.imgur.com/GOH374P.png

Bugs e Conflitti Noti

Lo script fa l'override dei metodi item_effect_recover_hp e item_effect_recover_mp, questo può dare problemi con alcuni battle system, ad esempio con il sistema dei Popup di Yanfly non mi andava perchè faceva l'alias dello stesso metodo, ma basta mettere questo script sopra agli altri e non dovrebbe più dare problemi.

Script

$imported = {} if $imported.nil?
$imported["Secuter-GestioneBuff"] = true
#==============================================================================
# ** Gestione Personalizzata di Stati e Potenziamenti **
#------------------------------------------------------------------------------
# Autore: Secuter
# Versione: 1.2
#==============================================================================
# Funzioni principali
# - aumento dei possibili livelli di buff/debuff oltre i canonici 2.
# - possibilità di differenziare la modifica delle statistiche a seconda del
#   parametro che viene modificato, ad es. 20% per l'attacco, 50% per difesa,
#   con i valori insetiti in un vettore.
# - mostra il numero dei turni rimanenti ad uno stato/buff insieme all'icona.
# - aggiunge un parametro per ridurre gli effetti di ricarica della vita se usati
#   di seguito in una battaglia, è un nuovo debuff con più livelli che aumenta
#   se applicato più volte.
#   Mentre se usati dalla mappa pozioni e cure avranno l'effetto normale.
# - possibilità di mostrare le icone degli stati su più righe in modo che ce ne
#   stiano di più, ma questo dipende da come è fatto il vostro menù e sistema
#   di battaglia, potrebbero anche non starci e dai gusti personali, avere una
#   sfilza di icone potrebbe non piacere a tutti.
# - aggiunta possibilità di impostare abilità immuni alla riduzione cure
#   scrivendo nelle note "<reduction_immune>".
#------------------------------------------------------------------------------
# ** Configurazione **
#------------------------------------------------------------------------------
module Default
# Metti il valore a true se vuoi abilitare il sistema di debuff per effetti
# curativi consecutivi, false per eliminarlo.
  DEBUFF_CURE = true
# Numero di turni che dura il debuff.
  DEBUFF_CURE_DURATA = 3
# Nome del debuff alle cure che viene mostrato nei messaggi.
  DEBUFF_HEAL_NAME = "Cure"
#------------------------------------------------------------------------------
  BUFF_VALUE = [
  [0.25,   # Valore del buff dell'attacco
  0.125],   # Valore del debuff dell'attacco
  [0.3125, 0.3125], # Difesa buff e debuff
  [0.25, 0.125],    # Attacco Magico
  [0.3125, 0.3125], # Difesa Magica
  [0.25, 0.25],     #  Fortuna
  [0.25, 0.25],     # Agilità
  [0.25, 0.20]]     # Cure}
# Impostano il livello massimo di buff e debuff. (Default 2 e 2)
  MAX_BUFFS   = 4
  MAX_DEBUFFS = -2  #da mettere negativo
# Colore del testo che indica il numero dei turni rimanenti per uno stato.
# Mettete quello che si vede meglio con le icone che usate.
  REMAINING_TURNS_COLOR = 18 # 18 => rosso
  REMAINING_STEPS_COLOR = 9 # 9 => blu
#------------------------------------------------------------------------------
# Impostato a false rende immuni a stun/confusione se ci si è appena liberati
# da uno stato simile l'ultimo turno, evita stun a catena in pratica.
  PermitConsecutiveStuns = false
#------------------------------------------------------------------------------
# Modificato il metodo draw_actor_icons per gestire anche il numero di righe.
# draw_actor_icons(actor, x, y, width, rows)
# I valori indicano il numero di righe riservato per varie finestre, tutte
# quelle che normalmente mostrano gli stati alterati.
  STATE_ICON_ROWS        = 2  # default
  STATE_ICON_ROWS_BATTLE = 2  # in battaglia
  STATE_ICON_ROWS_STATUS = 1  # nella finestra delle statistiche
  STATE_ICON_ROWS_MENU   = 2  # nel menù
  STATE_ICON_ROWS_SKILL  = 2  # nella finestra delle abilità
# La larghezza di default dello spazio riservato alle icone, usato solo come
# valore di default il metodo draw_actor_icons di solito la sovrascrive.
  STATE_ICONS_WIDTH = 96
end

class Game_BattlerBase
  # Indica l'ID dell'icona del debuff di livello uno.
  ICON_RECOVERY_DEBUFF_START = 598
  # Indica l'ID dell'icona con cui iniziano i buff oltre il livello 2.
  # ATTENZIONE tutte le icone devono essere in ordine!
  # Se non uso più di 2 buff posso anche scrivere pirippippò! che tanto non
  # verrano usate!
  ICON_BUFF_2_START          = 608
  # Idem per i debuff.
  ICON_DEBUFF_2_START        = 0
#==============================================================================
end
#==============================================================================
# ** INIZIO DEL CODICE NON MODIFICARE !!! **
#==============================================================================

module Vocab
  #----------------------------------------------------------------------------
  # Aggiunta del nome del parametro.
  #----------------------------------------------------------------------------
  def self.param(param_id)
    $data_system.terms.params.push(Default::DEBUFF_HEAL_NAME) if param_id <= $data_system.terms.params.size
    $data_system.terms.params[param_id]
  end
end
  
class Game_Battler < Game_BattlerBase
  #----------------------------------------------------------------------------
  # * Inizializza i buff ad inizio battaglia
  #----------------------------------------------------------------------------
  alias on_battle_start_buf on_battle_start
  def on_battle_start
    on_battle_start_buf
    clear_buffs
  end
  
  #----------------------------------------------------------------------------
  # * Override di buff_max? e debuff_max?.
  #----------------------------------------------------------------------------
  def buff_max?(param_id)
    @buffs[param_id] == Default::MAX_BUFFS
  end
  
  def debuff_max?(param_id)
    @buffs[param_id] == Default::MAX_DEBUFFS
  end
  
  #----------------------------------------------------------------------------
  # * Restituisce l'icona del rispettivo livello di potenziamento.
  #----------------------------------------------------------------------------
  def buff_icon_index(buff_level, param_id)
    if buff_level > 0
      return 0 if param_id == 8
      if buff_level > 2
        return ICON_BUFF_2_START + (buff_level - 3) * 8 + param_id
      else
        return ICON_BUFF_START + (buff_level - 1) * 8 + param_id
      end
    elsif buff_level < 0
      return ICON_RECOVERY_DEBUFF_START + (-buff_level - 1) if param_id == 8
      if buff_level < -2
        return ICON_DEBUFF_2_START + (-buff_level + 3) * 8 + param_id
      else
        return ICON_DEBUFF_START + (-buff_level - 1) * 8 + param_id
      end
    else
      return 0
    end
  end
  
  #----------------------------------------------------------------------------
  # * Metodo che restituisce la resistenza alle cure e la aggiorna in automatico,
  # il tutto solo se in battaglia.
  #----------------------------------------------------------------------------
  def rec
    if SceneManager.scene.is_a?(Scene_Battle)
      return 1 if !Default::DEBUFF_CURE
      @buffs.push(0) if @buffs.size < 9
      rec = sparam(2) * (@item.reduction_immune ? 1 : param_buff_rate(8))
      add_debuff(8, Default::DEBUFF_CURE_DURATA)  #aggiunge il nuovo debuff
      rec
    else
      sparam(2)
    end
  end
  
  #----------------------------------------------------------------------------
  # * Alias di add_debuff per non resettare il numero di turni se il buff rimane positivo
  #----------------------------------------------------------------------------
  alias add_debuff_buf add_debuff
  def add_debuff(param_id, turns)
    return unless alive?
    if @buffs[param_id] > 0
      old_turns =  @buff_turns[param_id]
      add_debuff_buf(param_id, turns)
      @buff_turns[param_id] = old_turns
      refresh
    else
      add_debuff_buf(param_id, turns)
    end
  end
  
  #----------------------------------------------------------------------------
  # * Alias di item_apply per memorizzare l'oggetto usato
  #----------------------------------------------------------------------------
  alias item_apply_buf item_apply
  def item_apply(user, item)
    @item = item
    item_apply_buf(user, item)
    @item = nil
  end
  
  #----------------------------------------------------------------------------
  # * Aggiorna i turni dopo l'azione per chi salta il turno
  #----------------------------------------------------------------------------
  alias on_action_end_st on_action_end
  def on_action_end
    update_turn_count if @last_action.nil? or @last_action.item.nil?
    on_action_end_st
    @last_action = nil
  end
  
  #----------------------------------------------------------------------------
  # * Aggiorna il numero di turni prima dell'azione per gli stati che lo richiedono
  #----------------------------------------------------------------------------
  def update_turn_count
    update_buff_turns(true)
    update_state_turns(true)
  end
  
  #----------------------------------------------------------------------------
  # * Imposta a 0 il numero dei turni se lo stato non si rimuove con il tempo.
  # Imposta i passi per gli stati che non li usano a 0 (di suo era 100 lol)
  # Mette a 0 il numero degli stati che durano un turno, per nasconderlo
  #----------------------------------------------------------------------------
  alias reset_state_counts_st reset_state_counts
  def reset_state_counts(state_id)
    reset_state_counts_st(state_id)
    state = $data_states[state_id]
    @state_turns[state_id] = 0 if state.auto_removal_timing == 0
    @state_turns[state_id] = 0 if state.auto_removal_timing == 2 and @state_turns[state_id] == 1
    @state_steps[state_id] = 0 if not $data_states[state_id].remove_by_walking
  end
  
  #--------------------------------------------------------------------------
  # * Update State Turns
  # Differenzia se si aggiornano dopo azione o turno
  #--------------------------------------------------------------------------
  def update_state_turns(action =false)
    states.each do |state|
      @state_turns[state.id] -= 1 if @state_turns[state.id] > 0 and action == (state.auto_removal_timing==1)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Update Buff/Debuff Turns
  # Aggiorna i turni dei buff/debuff dopo l'azione e non alla fine del turno
  #--------------------------------------------------------------------------
  def update_buff_turns(action =false)
    return if !action
    @buff_turns.keys.each do |param_id|
      @buff_turns[param_id] -= 1 if @buff_turns[param_id] > 0
    end
  end
  
  #--------------------------------------------------------------------------
  # * Memorizza l'ultima azione eseguita
  #--------------------------------------------------------------------------
  alias remove_current_action_st remove_current_action
  def remove_current_action
    @last_action = current_action
    remove_current_action_st
  end
  
  #--------------------------------------------------------------------------
  # * Alias state_addable?
  #--------------------------------------------------------------------------
  alias state_addable_buf? state_addable?
  def state_addable?(state_id)
    state_addable_buf?(state_id) && state_consecutive_stun?(state_id)
  end
  
  #--------------------------------------------------------------------------
  # * Aggiunge il controllo 
  #--------------------------------------------------------------------------
  def state_consecutive_stun?(state_id)
    return true if state_id == death_state_id
    return true if Default::PermitConsecutiveStuns
    return true if $data_states[state_id].restriction  == 0
    return $game_troop.turn_count > @last_stun + 1
  end
end

class Game_BattlerBase
  #----------------------------------------------------------------------------
  def clear_buffs
    @buffs = Array.new(9) { 0 }
    @buff_turns = {}
    @last_stun = -1
  end
  #----------------------------------------------------------------------------
  # * Calcola i buff/debuff a seconda del parametro e dei valori impostati.
  #----------------------------------------------------------------------------
  alias param_buff_rate_alias param_buff_rate
  def param_buff_rate(param_id)
    if param_id > 1
      if @buffs[param_id] > 0
        @buffs[param_id] * Default::BUFF_VALUE[param_id-2][0] + 1.0 if Default::BUFF_VALUE[param_id-2][0]
      else
        @buffs[param_id] * Default::BUFF_VALUE[param_id-2][1] + 1.0 if Default::BUFF_VALUE[param_id-2][1]
      end
    end
    param_buff_rate_alias(param_id)
  end
  #----------------------------------------------------------------------------
  # * Ritorna un vettore con gli stati del battler e i turni rimanenti.
  #----------------------------------------------------------------------------
  def states_and_remainings
    states = []
    @states.each do|id|
      states.push([$data_states[id], remainings($data_states[id].id)])
    end
    states
  end
  #----------------------------------------------------------------------------
  # Restituisce il numero dei turni rimanenti dello stato X.
  #----------------------------------------------------------------------------
  def remainings(id)
    if SceneManager.scene.is_a?(Scene_Battle)
      return @state_turns[id] if @state_turns[id]
    else  #se non è in battaglia restituisce i passi come negativi x distinguerli
      return -@state_steps[id] if @state_steps[id] > 0
      return @state_turns[id] if @state_turns[id]
    end
    return 0
  end
  #----------------------------------------------------------------------------
  # Override del metodo state_icons per restituire anche i turni rimanenti.
  #----------------------------------------------------------------------------
  def state_icons
    icons = []
    states_and_remainings.each do |state|
      next if not state[0].icon_index > 0
      icons.push([state[0].icon_index, state[1]])
    end 
    icons
  end
  #----------------------------------------------------------------------------
  # Override del metodo buff_icons per restituire anche i turni rimanenti.
  #----------------------------------------------------------------------------
  def buff_icons
    icons = []
    @buffs.each_with_index do |lvl, id|
      next if lvl == 0
      icons.push([buff_icon_index(lvl, id), @buff_turns[id].to_i])
    end
    icons
  end
  
  alias erase_state_buf erase_state
  def erase_state(state_id)
    erase_state_buf(state_id)
    @last_stun = $game_troop.turn_count if $data_states[state_id].restriction > 0
  end
end

class Window_Base
  #----------------------------------------------------------------------------
  # Override del metodo draw_actor_icons per consentire di mettere le icone
  # degli stati su più righe.
  #----------------------------------------------------------------------------
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS)
    icons = (actor.state_icons + actor.buff_icons)[0, width * rows / 24]
    return if icons.size == 0
    max_icons = width / 24
    row = 0
    pos = 0
    icons.each do |icon|
      draw_icon_and_turns(icon[0], icon[1], x + pos * 24, y + row * 24)
      pos += 1
      if pos >= max_icons
        pos = 0
        row += 1
      end
    end
  end
  
  def draw_icon_and_turns(n, turns, x, y)
    draw_icon(n, x, y)
    draw_remaining_turns(turns, x, y)
  end
  
  #----------------------------------------------------------------------------
  # Metodo che scrive il numero di turni rimanenti sopra l'icona.
  #----------------------------------------------------------------------------
  def draw_remaining_turns(turns, x, y)
    return if turns == 0
    if turns > 0
      change_color(text_color(Default::REMAINING_TURNS_COLOR))
      draw_text(x+2, y-2, 20, 20, turns, 0)
    else  #se è negativo vuol dire che sono passi
      change_color(text_color(Default::REMAINING_STEPS_COLOR))
      draw_text(x+2, y-2, 20, 20, -turns, 0)
    end
  end
end

#------------------------------------------------------------------------------
# Metodi per la formattazione dello spazio dedicato alle icone.
# Se utilizzi le icone anche in altre finestre con un numero di righe diverso
# da quello di default aggiungi qui i metodi.
#------------------------------------------------------------------------------
class Window_BattleStatus < Window_Selectable
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_BATTLE)
    super(actor, x, y, width, rows)
  end
end

class Window_MenuStatus < Window_Selectable
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_MENU)
    super(actor, x, y, width, rows)
  end
end

class Window_Status < Window_Selectable
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_STATUS)
    super(actor, x, y, width, rows)
  end
end

class Window_SkillStatus < Window_Base
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_SKILL)
    super(actor, x, y, width, rows)
  end
end

#------------------------------------------------------------------------------
# * Lettura del parametro reduction_immune.
#------------------------------------------------------------------------------
class RPG::BaseItem
  def reduction_immune
    return @reduction_immune if @reduction_immune
    @reduction_immune = false
    self.note.split(/[\r\n]+/).each { |row|
      case row
      when /<reduction_immune>/i
        @reduction_immune = true
        return @reduction_immune        
      end
    }
    return @reduction_immune
  end
end

class Scene_Battle < Scene_Base
  #----------------------------------------------------------------------------
  # * Aggiorna i turni prima dell'azione
  #----------------------------------------------------------------------------
  alias execute_action_st execute_action
  def execute_action
    @subject.update_turn_count
    execute_action_st
  end
end

 

Screen Esempio

http://i.imgur.com/joOdUm6.pnghttp://i.imgur.com/kS6j1HI.png

 

Edited March 25, 2017 by Secuter96

[Guardian of Irael]

E' ben presentato con descrizioni, dettaglio per i possibili conflitti, screen di esempio e pure risorse personalizzate, va benissimo! ^ ^

 

Anche lo script stesso ha la parte iniziale ben commentata e comprensibile. Bel lavoro per dare quel qualcosa di più agli status! ^ ^

[Holy87]

È raro vedere uno script fatto come si deve, bravo!

[Secuter96]

Script aggiornato

Corretto un errore stupididissimo, avevo messo il max debuff a 2 mentre deve essere un numero negativo visto che i debuff sono negativi.

Non riscrive più i metodi recover_hp/mp ma fa tutto nel metodo rec.

Fuori dalla battaglia mostra il numero dei passi per gli stati che scadono dopo un tot numero di passi.

Controllo degli stati solo alla fine del turno, se sono impostati per scadere dopo l'azione i turni aumentano di 1 per mantenere i turni effettivi uguali.

Se un debuff riduce una statistica ma questa rimane comunque positiva i turni non si resettano, es. ho +3 su attacco magico applico il debuff che riduce di 1 ma rimane comunque un potenziamento (+2) quindi evita di prolungare i turni.

Aggiunto tag <reduction_immune> per rendere una skill/oggetto immune alla riduzione delle cure.

Edited February 13, 2017 by Secuter96

[Secuter96]

Versione 1.2

Nessun cambiamento nelle funzioni ma ora aggiorna i turni mancanti di uno stato all'azione se è uno stato che si aggiorna ad ogni azione, in pratica cambia il momento in cui il numerino del turno si aggiorna.

Ed è stato un casino farlo anche per chi era bloccato xD

Edited March 21, 2017 by Secuter96