Skill Delay 2

[Holy87]

Skill Delay

Autore
Holy87

Difficoltà
Principiante

Descrizione
Questo script permette di creare abilità che, dopo essere usate, hanno bisogno di certi requisiti per essere ricaricate, come turni in battaglia, vittorie o passi su mappa. Nei primi due casi, compariranno delle "tacchette" sotto il nome dell'abilità che rappresenta il numero di turni o battaglie necessari per ricaricarsi, nel terzo caso, una barra indicherà quanti passi ancora occorrono prima che l'abilità possa essere ri-utilizzata.
Nel caso sia installato anche lo script "Popup Generale", un popup verrà mostrato nel caso un'abilità torni pronta durante le esplorazioni in mappa.

Screenshot

Spoiler

Script

Spoiler

$imported = {} if $imported == nil
$imported["H87_SkillDelay"] = true
#===============================================================================
# ** SKILL DELAY DI HOLY87 **
# 03/02/2013 -> Versione 1.1 (bugfix e maggiori opzioni)
# 12/10/2012 -> Versione 1.0
#===============================================================================
# DESCRIZIONE:
# Questo script fa in modo che un potere abbia bisogno di un tempo di "ricarica"
# una volta usato. Il tempo può essere calcolato per:
# ●Turni: quanti turni occorrono al personaggio che ha utilizzato l'abilità per
#  renderla di nuovo disponibile
# ●Battaglie: quante battaglie deve vincere il personaggio per poter rendere di
#  nuovo l'abilità utilizzabile
# ●Passi: quanti passi deve fare il giocatore sulla mappa per ricaricare il
#  potere.
# Quando si seleziona l'abilità, compariranno delle "tacche" di un numero uguale
# ai turni o alle battaglie necessari per ricaricare le abilità, al di sotto del
# nome del potere. Nel caso si tratti di un'abilità che si ricarica camminando,
# allora comparirà una barra.
#===============================================================================
# UTILIZZO:
# Installare lo script sotto Materials e prima del Main, al di sotto del Costo
# Poteri Alternativo, se installato.
# Inserire nel blocco delle note dell'abilità desiderata, le seguenti etichette:
# <ricarica turni: x> per fare in modo che l'abilità si ricarichi dopo x turni
# <ricarica battaglie: x>, per fare in modo che l'abilità si ricarichi dopo x
# battaglie; oppure
# <ricarica passi: x>, per fare in modo che l'abilità si ricarichi dopo x passi.
#===============================================================================
# COMPATIBILITA':
# Compatibile con Tankentai SBS, con o senza ATB. Non dovrebbe creare conflitti.
# Compatibile con il sistma di popup generale (v1.1 in poi), in questo caso,
# verrà mostrato un popup quando si ricarica un'abilità tramite passi.
#===============================================================================
# NOTE:
# Non è possibile inserire più tipi di ricarica, nel caso se ne inserissero di
# più, viene preso solo un tipo.
# Nel caso dell'ATB, il numero di turni è un pò ambiguo, quindi le abilità si
# ricaricano ogni volta che quel personaggio agisce.
#===============================================================================

module H87_Delay
#===============================================================================
# ** CONFIGURAZIONE **
#===============================================================================
  #Inserisci i colori delle barre (il numero si riferisce al colore del testo.
  #Colore tacche piene per abilità turni
  ColorTurn = 3
  #colore tacche vuote per abilità turni
  ColorBack = 7
  #colore tacche piene per abilità battaglie
  ColorBatt = 10
  #colore tacche vuote per abilità battaglie
  ColorBac2 = 7
  #colore barra per abilità che si ricaricano per passi
  ColorStep = 17
  #colore barra vuota per abilità che si ricaricano per passi
  ColorBac3 = 7
  
  #Altezza della barra e delle tacche, in pixel
  Lgzz = 1
  
  # Vuoi che le abilità che si ricaricano con i turni si ricarichino completamente
  # alla fine di una battaglia?
  RICARICA = true
  
  # Vuoi che quando c'è un ricovero totale o una locanda, si ricarichino tutte
  # le abilità?
  RICOVERO = true
  
  # Vuoi che le abilità che si ricaricano con i turni siano visibili anche su
  # menu, o solo in battaglia? (true se si, false altrimenti)
  MAP_VIS = true
  
#-------------------------------------------------------------------------------
# * Solo con Popup:
#-------------------------------------------------------------------------------
  #Vuoi usare un popup nel caso un'abilità che si ricarica per passi torni
  #disponibile? true: si, false: no
  UsePopup = true
  
  #Colore del popup
               #R  G    B    S
  PopupColor = [0, 100, 150, 20]
  #SE che viene eseguito quando un potere è carico.
  SE = "Skill"
  #Testo che viene mostrato nel popup:
  TXT = "%s di %s pronto!"
  
#===============================================================================
# ** FINE CONFIGURAZIONE **
# Attenzione: Non modificare ciò che c'è oltre, a meno che tu non sappia ciò che
# fai!
#===============================================================================



#===============================================================================
  #stringhe
  DelayTurn    = /<(?:RICARICA TURNI|ricarica turni):[ ]*(\d+)>/i
  DelayBattle  = /<(?:RICARICA BATTAGLIE|ricarica battaglie):[ ]*(\d+)>/i
  DelayStep    = /<(?:RICARICA PASSI|ricarica passi):[ ]*(\d+)>/i
  
  #-----------------------------------------------------------------------------
  # *Restituisce true se è possibile mostrare i popup
  #-----------------------------------------------------------------------------
  def self.allow_popup?
    return false unless $imported["H87_Popup"]
    return false unless UsePopup
    return true
  end
  
end #modulo

#===============================================================================
# ** Classe Game_Battler
#===============================================================================
class Game_Battler
  attr_accessor :turn_skills    #attributo per caricamento turni
  attr_accessor :battle_skills  #attributo per caricamento battaglie
  attr_accessor :step_skills    #attributo per caricamento passi
  
  #-----------------------------------------------------------------------------
  # *Alias metodo initialize
  #-----------------------------------------------------------------------------
  alias inizializza_turni initialize unless $@
  def initialize
    inizializza_turni
    @turn_skills = {}
    @battle_skills = {}
    @step_skills = {}
  end
  
  #-----------------------------------------------------------------------------
  # *Restituisce un hash con tutti i poteri che ha in carica (turni)
  #-----------------------------------------------------------------------------
  def turn_skills
    @turn_skills = {} if @turn_skills == nil
    return @turn_skills
  end
  
  #-----------------------------------------------------------------------------
  # *Restituisce un hash con tutti i poteri che ha in carica (battaglie)
  #-----------------------------------------------------------------------------
  def battle_skills
    @battle_skills = {} if @battle_skills == nil
    return @battle_skills
  end
  
  #-----------------------------------------------------------------------------
  # *Restituisce un hash con tutti i poteri che ha in carica (passi)
  #-----------------------------------------------------------------------------
  def step_skills
    @step_skills = {} if @step_skills == nil
    return @step_skills
  end
  
  #-----------------------------------------------------------------------------
  # *Aggiunge un nuovo potere al caricamento dei turni
  #-----------------------------------------------------------------------------
  def add_turn_skill(skill)
    @turn_skills[skill.id] = skill.turn_delay
  end
  
  #-----------------------------------------------------------------------------
  # *Resetta tutte le skill che hanno un caricamento turni (dopo ogni battaglia)
  #-----------------------------------------------------------------------------
  def flush_turn_skills
    @turn_skills = {} if @turn_skills == nil
    @turn_skills.clear
  end
  
  #-----------------------------------------------------------------------------
  # *Aggiunge un nuovo potere al caricamento delle battaglie
  #-----------------------------------------------------------------------------
  def add_battle_skill(skill)
    @battle_skills[skill.id] = skill.battle_delay
  end
  
  #-----------------------------------------------------------------------------
  # *Aggiunge un nuovo potere al caricamento dei passi
  #-----------------------------------------------------------------------------
  def add_step_skill(skill)
    @step_skills[skill.id] = skill.step_delay
  end
  
  #-----------------------------------------------------------------------------
  # *Abbassa di 1 unità i turni dei poteri
  #-----------------------------------------------------------------------------
  def scale_turn
    @turn_skills.each_key { |delay|
      @turn_skills[delay] -= 1
      @turn_skills.delete(delay) if @turn_skills[delay] == 0
    }
  end
  
  #-----------------------------------------------------------------------------
  # *Abbassa di 1 unità le battaglie dei poteri
  #-----------------------------------------------------------------------------
  def scale_battle
    @battle_skills = {} if @battle_skills == nil
    @battle_skills.each_key { |delay|
      @battle_skills[delay] -= 1
      @battle_skills.delete(delay) if @battle_skills[delay] == 0
    }
  end
  
  #-----------------------------------------------------------------------------
  # *Abbassa di 1 unità i passi dei poteri
  #-----------------------------------------------------------------------------
  def scale_step
    @step_skills = {} if @step_skills == nil
    @step_skills.each_key do |delay|
      @step_skills[delay] -= 1
      if @step_skills[delay] <= 0
        @step_skills.delete(delay)
        show_popup($data_skills[delay]) if H87_Delay.allow_popup?
      end
    end
  end
  
  #-----------------------------------------------------------------------------
  # *Mostra il popup
  #-----------------------------------------------------------------------------
  def show_popup(delay)
    RPG::SE.new(H87_Delay::SE).play
    text = sprintf(H87_Delay::TXT,delay.name,name)
    Popup.show(text,delay.icon_index,H87_Delay::PopupColor)
  end
  
  #-----------------------------------------------------------------------------
  # *Alias metodo skill_can_use?
  #-----------------------------------------------------------------------------
  alias usabile_da_delay skill_can_use? unless $@
  def skill_can_use?(skill)
    return false if no_charged(skill)
    return usabile_da_delay(skill)
  end
  
  #-----------------------------------------------------------------------------
  # *Restituisce true se il potere non è ancora caricato
  #-----------------------------------------------------------------------------
  def no_charged(skill)
    return true if skill.turn_delay > 0 and turn_skills.include?(skill.id)
    return true if skill.battle_delay > 0 and battle_skills.include?(skill.id)
    return true if skill.step_delay > 0 and step_skills.include?(skill.id)
  end
  
  def recharge_all
    flush_turn_skills
    @battle_skills = {} if @battle_skills == nil
    @battle_skills.clear
    @step_skills = {} if @step_skills == nil
    @step_skills.clear
  end
  
  alias rec_skill_all recover_all unless $@
  def recover_all
    rec_skill_all
    recharge_all if H87_Delay::RICOVERO
  end
  
  
end #game_battler

#===============================================================================
# ** Classe Skill
#===============================================================================
class RPG::Skill
  attr_accessor :turn_delay   #attributo per tempo turni
  attr_accessor :battle_delay #attributo per tempo battaglie
  attr_accessor :step_delay   #attributo per tempo passi
  
  #-----------------------------------------------------------------------------
  # *caricamento poteri
  #-----------------------------------------------------------------------------
  def carica_cache_personale3
    return if @cache_caricata3
    @cache_caricata3 = true
    @turn_delay = 0
    @battle_delay = 0
    @step_delay = 0
    self.note.split(/[\r\n]+/).each { |riga|
      case riga
      #---
      when H87_Delay::DelayTurn
        @turn_delay = $1.to_i
      when H87_Delay::DelayBattle
        @battle_delay = $1.to_i
        @turn_delay = 0
      when H87_Delay::DelayStep
        @step_delay = $1.to_i
        @battle_delay = 0
        @turn_delay = 0
      end
    }
  end
  
  def turn_delay;   return @turn_delay;   end
  def battle_delay; return @battle_delay; end
  def step_delay;   return @step_delay;   end
end #RPG::Skill

#===============================================================================
# ** Classe Scene_Title
#===============================================================================
class Scene_Title < Scene_Base
  
  #-----------------------------------------------------------------------------
  # *Alias metodo load_bt_database
  #-----------------------------------------------------------------------------
  alias carica_db3 load_bt_database unless $@
  def load_bt_database
    carica_db3
    carica_skills3
  end
  
  #-----------------------------------------------------------------------------
  # *Alias metodo load_database
  #-----------------------------------------------------------------------------
  alias carica_db_23 load_database unless $@
  def load_database
    carica_db_23
    carica_skills3
  end
  
  #-----------------------------------------------------------------------------
  # Inizializza nel caricamento
  #-----------------------------------------------------------------------------
  def carica_skills3
    for skill in $data_skills
      next if skill == nil
      skill.carica_cache_personale3
    end
  end
  
end # scene_title

#===============================================================================
# ** Classe Scene_Battle
#===============================================================================
class Scene_Battle < Scene_Base
  #-----------------------------------------------------------------------------
  # *Alias metodo Start
  #-----------------------------------------------------------------------------
  alias h87starter start unless $@
  def start
    h87starter
    reset_turni if H87_Delay::RICARICA
  end
  
  #-----------------------------------------------------------------------------
  # *Alias metodo terminate
  #-----------------------------------------------------------------------------
  alias terminater3 terminate unless $@
  def terminate
    terminater3
    reset_turni if H87_Delay::RICARICA
  end
  
  #-----------------------------------------------------------------------------
  # *riazzera le ricariche dei poteri (turni)
  #-----------------------------------------------------------------------------
  def reset_turni
    $game_party.members.each do |member|
      member.flush_turn_skills
    end
  end
  
  #-----------------------------------------------------------------------------
  # *fine del turno, aumenta la carica delle skill a turni (solo se non ATB)
  #-----------------------------------------------------------------------------
  alias h87te turn_end unless $@
  def turn_end(member = nil)
    h87te(member)
    scale_all unless $imported["TankentaiATB"]
  end
  
  def scale_all
    $game_party.members.each {|member|member.scale_turn}
  end
  
    
  
  #-----------------------------------------------------------------------------
  # *Alias metodo execute_action_skill
  #-----------------------------------------------------------------------------
  alias h87eas execute_action_skill unless $@
  def execute_action_skill
    h87eas
    skill = @active_battler.action.skill
    return if @active_battler == nil
    return if skill == nil
    @active_battler.add_turn_skill(skill) if skill.turn_delay > 0
    @active_battler.add_battle_skill(skill) if skill.battle_delay > 0
    @active_battler.add_step_skill(skill) if skill.step_delay > 0
  end
  
  #-----------------------------------------------------------------------------
  # *Alias metodo execute_action
  #-----------------------------------------------------------------------------
  alias h87ea execute_action unless$@
  def execute_action
    h87ea
    @active_battler.scale_turn if $imported["TankentaiATB"] and @active_battler != nil
  end
  
  #-----------------------------------------------------------------------------
  # *Alias metodo process_victory
  #-----------------------------------------------------------------------------
  alias h87pv process_victory unless $@
  def process_victory
    h87pv
    $game_party.members.each {|member|
      member.scale_battle
    }
  end
end #scene_battle

#===============================================================================
# ** Classe Window_Skill
#===============================================================================
class Window_Skill < Window_Selectable
  #-----------------------------------------------------------------------------
  # *Alias metodo draw_item
  #-----------------------------------------------------------------------------
  alias h87di draw_item unless $@
  def draw_item(index)
    h87di(index)
    rect = item_rect(index)
    skill = @data[index]
    x = rect.x + 24
    y = rect.y + rect.height - H87_Delay::Lgzz
    lenght = rect.width - 24
    if skill.turn_delay > 0 and ($scene.is_a?(Scene_Battle) or H87_Delay::MAP_VIS)
      lb = lenght/skill.turn_delay - 3
      caricato = 0
      caricato = @actor.turn_skills[skill.id] if @actor.turn_skills.include?(skill.id)
      caricato = skill.turn_delay - caricato
      for i in 0..skill.turn_delay-1
        caricato > i ? colore = text_color(H87_Delay::ColorTurn) : colore = text_color(H87_Delay::ColorBack)
        self.contents.fill_rect(x+((lb+3)*i),y,lb,H87_Delay::Lgzz,colore)
      end
    elsif skill.battle_delay > 0
      lb = lenght/skill.battle_delay - 3
      caricato = 0
      caricato = @actor.battle_skills[skill.id] if @actor.battle_skills.include?(skill.id)
      caricato = skill.battle_delay - caricato
      for i in 0..skill.battle_delay-1
        caricato > i ? colore = text_color(H87_Delay::ColorBatt) : colore = text_color(H87_Delay::ColorBac2)
        self.contents.fill_rect(x+((lb+3)*i),y,lb,H87_Delay::Lgzz,colore)
      end
    elsif skill.step_delay > 0
      lb = lenght - 3
      caricato = 0
      caricato = @actor.step_skills[skill.id] if @actor.step_skills.include?(skill.id)
      caricato = skill.step_delay - caricato
      self.contents.fill_rect(x,y,lb,H87_Delay::Lgzz,text_color(H87_Delay::ColorBac3))
      lung = lb.to_f*(caricato.to_f/skill.step_delay.to_f)
      self.contents.fill_rect(x,y,lung,H87_Delay::Lgzz,text_color(H87_Delay::ColorStep))
    end
  end
end #window_skill

#===============================================================================
# ** Classe Scene_Skill
#===============================================================================
class Scene_Skill < Scene_Base
  #-----------------------------------------------------------------------------
  # *Alias metodo use_skill_nontarget
  #-----------------------------------------------------------------------------
  alias h87usn use_skill_nontarget unless $@
  def use_skill_nontarget
    h87usn
    if @skill.battle_delay > 0
      @actor.add_battle_skill(@skill) 
      @skill_window.refresh
    elsif @skill.step_delay > 0
      @actor.add_step_skill(@skill) 
      @skill_window.refresh
    end
  end
end #scene_skill

#===============================================================================
# ** Classe Game_Party
#===============================================================================
class Game_Party < Game_Unit
  #-----------------------------------------------------------------------------
  # *Alias metodo increase_steps
  #-----------------------------------------------------------------------------
  alias h87is increase_steps unless $@
  def increase_steps
    h87is
    $game_party.members.each {|member|
      member.scale_step
    }
  end
end #game_party

 

Istruzioni
Installare lo script sotto Materials, prima del Main e sotto lo script Costo Poteri Alternativo, se è installato. dopodichè, inserire nel blocco note delle skill le etichette:

<ricarica turni: x>
<ricarica battaglie: x>
<ricarica passi: x>

a seconda di quale tipo di ricarica si sceglie per l'abilità.

Compatibilità
Non ci dovrebbero essere problemi.

Modificato da Holy87, 23 March 2013 - 15:51 PM.

[Guardian of Irael]

Che fai spammi script tutti insieme? XD

come turni in battaglia, vittorie o passi su mappa

Come piace a me! E:3 Tante varie opzioni per ricaricarle! ^ ^

Non sarebbero male delle miniicone/icone ad hoc per indicare i tipi di abilità! ^ ^
Vediamo se mi viene in mente qualcosina di particolare per trovare altri tipi di ricarica! Mi piacciono 'ste cose! XDX

[Holy87]

Eh, se ti vengono altre idee proponi :D
Comunque dal colore si deduce il tipo di ricarica, al massimo si mette nella descrizione.

[Guardian of Irael]

Numeri di uso di attacco, difesa, oggetti speciali che recuperano (anche per altre tecniche con le altre richieste), soldini spesi o donati, hp persi...
^ ^

[Holy87]

Per i soldi c'è il costo poteri, per il resto... non so .-.

[Guardian of Irael]

Eh va bene hai fatto tanto, meriti riposo! XD
^ ^

[Holy87]

Eh va bene hai fatto tanto, meriti riposo! XD
^ ^

Eh forse hai ragione...
*va ad appoggiarsi sulla base di ricarica e preme il tasto Stand-By.

[Guardian of Irael]

No, oh! Che fai! Vai ad appoggiarti sul mouse e continua Overdrive che il contest finisce! XD

Ok, basta OT per me! XD

[NoxChibi]

MMM buono script,devo ammetterlo,voglio essere bravo come te

[Holy87]

Script aggiornato.

[Guardian of Irael]

Che hai aggiunto poi? :3

[Holy87]

Bugfix per la maggior parte. Ora si può scegliere se le skill che richiedono un certo numero di turni per ricaricarsi siano utilizzabili ad ogni battaglia oppure no.

[Spirito Kamikaze]

Ma una versione senza

1.

2.

3.

ecc.. no??

[Holy87]

Cioè? O.o

[BuddyTroller]

Si riferisca alla numerazione delle linee di codice, che per la cronaca se fai copia incolla vengono ignorati!

[Guardian of Irael]

In effetti dovrebbero essere ignorati! XD

@Spirito: di copia ed incolla pure quelli? ^ ^