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.
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
Modificato da Secuter96, 25 March 2017 - 20:27 PM.