RPGXP Scripts Standard | Traduzione

[Lomax_Iced]

Scusate l'assenza ma tra il lavoro e le altre cose da fare, ho trascurato un po questa iniziativa. Ma rieccomi qui, continuiamo seguendo l'ordine dello script editor:
Game_SelfSwitches

 

# ==============================================================================
# ** Game_SelfSwitches
# ------------------------------------------------------------------------------
# Questa classe gestisce gli interruttori automatici. 
# È una sezione che incorpora la classe " Hash ". 
# ------------------------------------------------------------------------------
# la variabile di riferimento è " $ game_self_switches ".
# ==============================================================================

class Game_SelfSwitches
  #--------------------------------------------------------------------------
  # * Inizializzazione oggetti
  #--------------------------------------------------------------------------
  def initialize
    @data = {}
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere l'interruttore automatico
  #     chiave : key  
  #--------------------------------------------------------------------------
  def [](key)
    return @data[key] == true ? true : false
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare l'interruttore automatico e conferirgli un valore
  #     chiave  : key  
  #     valore  : ON (true) / OFF (false)
  #--------------------------------------------------------------------------
  def []=(key, value)
    @data[key] = value
  end
end

 

Adesso proveremo ad analizzare questa classe:

Cos'è un Interruttore Automatico?
Un interruttore, in rpg maker, è un qualcosa che permette di attivare o disattivare alcuni blocchi di azioni che noi intendiamo far eseguire al nostro personaggio oppure agli eventi presenti in mappa.
Io penso che questo script sia molto intuitivo da comprendere e non necessita di molte spiegazioni.
Ma se desiderate conoscere di preciso, l'utilizzo che può avere uno switch, consiglio, se siete neofiti, di impostarli tramite evento.
Ecco un tutorial apposito (è per Vx-Ace, ma la spiegazione è valida anche per rmxp)

Spero vi sia tutto ben chiaro :)
Ora continuiamo con le nostre traduzioni
Ecco la volta di Game_Screen:

#==============================================================================
# ** Game_Screen
#------------------------------------------------------------------------------
#  Questa classe gestisce dati di manutenzione schermo, come il cambiamento 
#  della tonalità dEL colore, l'effetto bagliore, ecc 
#------------------------------------------------------------------------------
# la variabile di riferimento è  "$ game_screen".
#==============================================================================

class Game_Screen
  #--------------------------------------------------------------------------
  # * Variabili d'istanza pubblica
  #--------------------------------------------------------------------------
  attr_reader   :tone                     # effetto tonalità del colore
  attr_reader   :flash_color              # effetto bagliore del colore
  attr_reader   :shake                    # effetto tremolo
  attr_reader   :pictures                 # immagini
  attr_reader   :weather_type             # tipo di clima meteorologico
  attr_reader   :weather_max              # numero massimo di immagini meteo
  #--------------------------------------------------------------------------
  # * Metodo di inizializzazione
  #--------------------------------------------------------------------------
  # Conferisce i valori di partenza alle variabili d'istanza appena create. 
  #--------------------------------------------------------------------------
  def initialize
    @tone = Tone.new(0, 0, 0, 0)
    @tone_target = Tone.new(0, 0, 0, 0)
    @tone_duration = 0
    @flash_color = Color.new(0, 0, 0, 0)
    @flash_duration = 0
    @shake_power = 0
    @shake_speed = 0
    @shake_duration = 0
    @shake_direction = 1
    @shake = 0
    @pictures = [nil]
    for i in 1..100
      @pictures.push(Game_Picture.new(i))
    end
    @weather_type = 0
    @weather_max = 0.0
    @weather_type_target = 0
    @weather_max_target = 0.0
    @weather_duration = 0
  end
  #--------------------------------------------------------------------------
  # * Metodo per definire l'inizio del cambio di tonalità del colore
  #     tone : effetto tonalità colore
  #     duration : tempo di durata del cambiamento di tonalità
  #--------------------------------------------------------------------------
  def start_tone_change(tone, duration)
    @tone_target = tone.clone
    @tone_duration = duration
    if @tone_duration == 0
      @tone = @tone_target.clone
    end
  end
  #--------------------------------------------------------------------------
  # * Metodo per definire l'inizio del inscenare il bagliore del colore
  #     color : colore del bagliore
  #     duration : durata dell'avvenimento
  #--------------------------------------------------------------------------
  def start_flash(color, duration)
    @flash_color = color.clone
    @flash_duration = duration
  end
  #--------------------------------------------------------------------------
  # * Metodo per definire l'effetto tremolio dello schermo
  #     power : Intensità dell'effeto tremolo
  #     speed : velocità
  #     duration : tempo di durata dell'effetto
  #--------------------------------------------------------------------------
  def start_shake(power, speed, duration)
    @shake_power = power
    @shake_speed = speed
    @shake_duration = duration
  end
  #--------------------------------------------------------------------------
  # * Seleziona il tipo di condizione meteorologica
  #     type : tipo
  #     power : intensità
  #     duration : tempo di durata della condizione meteorologica
  #--------------------------------------------------------------------------
  def weather(type, power, duration)
    @weather_type_target = type
    if @weather_type_target != 0
      @weather_type = @weather_type_target
    end
    if @weather_type_target == 0
      @weather_max_target = 0.0
    else
      @weather_max_target = (power + 1) * 4.0
    end
    @weather_duration = duration
    if @weather_duration == 0
      @weather_type = @weather_type_target
      @weather_max = @weather_max_target
    end
  end
  #--------------------------------------------------------------------------
  # * Aggiornamento dei singoli Frame
  #--------------------------------------------------------------------------
  def update
    if @tone_duration >= 1
      d = @tone_duration
      @tone.red = (@tone.red * (d - 1) + @tone_target.red) / d
      @tone.green = (@tone.green * (d - 1) + @tone_target.green) / d
      @tone.blue = (@tone.blue * (d - 1) + @tone_target.blue) / d
      @tone.gray = (@tone.gray * (d - 1) + @tone_target.gray) / d
      @tone_duration -= 1
    end
    if @flash_duration >= 1
      d = @flash_duration
      @flash_color.alpha = @flash_color.alpha * (d - 1) / d
      @flash_duration -= 1
    end
    if @shake_duration >= 1 or @shake != 0
      delta = (@shake_power * @shake_speed * @shake_direction) / 10.0
      if @shake_duration <= 1 and @shake * (@shake + delta) < 0
        @shake = 0
      else
        @shake += delta
      end
      if @shake > @shake_power * 2
        @shake_direction = -1
      end
      if @shake < - @shake_power * 2
        @shake_direction = 1
      end
      if @shake_duration >= 1
        @shake_duration -= 1
      end
    end
    if @weather_duration >= 1
      d = @weather_duration
      @weather_max = (@weather_max * (d - 1) + @weather_max_target) / d
      @weather_duration -= 1
      if @weather_duration == 0
        @weather_type = @weather_type_target
      end
    end
    if $game_temp.in_battle
      for i in 51..100
        @pictures[i].update
      end
    else
      for i in 1..50
        @pictures[i].update
      end
    end
  end
end

 

Continuiamo..
Game_Picture

#==============================================================================
# ** Game_Picture
#------------------------------------------------------------------------------
#  Questa classe gestisce l'immagine. 
#  E 'utilizzato all'interno della classe Game_Screen
#  ($game_screen).
#==============================================================================

class Game_Picture
  #--------------------------------------------------------------------------
  # * Vengono create le corrispettive variabili d'istanza pubblica
  #--------------------------------------------------------------------------
  attr_reader   :number                   # numero di immagini
  attr_reader   :name                     # nome del file
  attr_reader   :origin                   # Punto di origine
  attr_reader   :x                        # coordinata-x
  attr_reader   :y                        # coordinata-y
  attr_reader   :zoom_x                   # livello di zoom in direzione-x
  attr_reader   :zoom_y                   # livello di zoom in direzione-y
  attr_reader   :opacity                  # livello di opacità
  attr_reader   :blend_type               # metodo di fusione
  attr_reader   :tone                     # tonalità del colore
  attr_reader   :angle                    # angolo di rotazione
  #--------------------------------------------------------------------------
  # * Metodo per assegnare i valori iniziali alle variabili appena create
  #     number : numero di immagini
  #--------------------------------------------------------------------------
  def initialize(number)
    @number = number
    @name = ""
    @origin = 0
    @x = 0.0
    @y = 0.0
    @zoom_x = 100.0
    @zoom_y = 100.0
    @opacity = 255.0
    @blend_type = 1
    @duration = 0
    @target_x = @x
    @target_y = @y
    @target_zoom_x = @zoom_x
    @target_zoom_y = @zoom_y
    @target_opacity = @opacity
    @tone = Tone.new(0, 0, 0, 0)
    @tone_target = Tone.new(0, 0, 0, 0)
    @tone_duration = 0
    @angle = 0
    @rotate_speed = 0
  end
  #--------------------------------------------------------------------------
  # * Metodo che permette di mostrare la figura
  #     name       : nome del file
  #     origin     : punto di inizio
  #     x          : coordinata-x
  #     y          : coordinata-y
  #     zoom_x     : livello di zoom in direzione-x
  #     zoom_y     : livello di zoom in direzione-y
  #     opacity    : livello di opacità
  #     blend_type : metodo  di fusione
  #--------------------------------------------------------------------------
  def show(name, origin, x, y, zoom_x, zoom_y, opacity, blend_type)
    @name = name
    @origin = origin
    @x = x.to_f
    @y = y.to_f
    @zoom_x = zoom_x.to_f
    @zoom_y = zoom_y.to_f
    @opacity = opacity.to_f
    @blend_type = blend_type
    @duration = 0
    @target_x = @x
    @target_y = @y
    @target_zoom_x = @zoom_x
    @target_zoom_y = @zoom_y
    @target_opacity = @opacity
    @tone = Tone.new(0, 0, 0, 0)
    @tone_target = Tone.new(0, 0, 0, 0)
    @tone_duration = 0
    @angle = 0
    @rotate_speed = 0
  end
  #--------------------------------------------------------------------------
  # * Metodo che permette all'immagine di spostarsi in mappa
  #     duration   : tempo di durata 
  #     origin     : punto di inizio
  #     x          : coordinata-x
  #     y          : coordinata-y
  #     zoom_x     : livello di zoom in direzione-x
  #     zoom_y     : livello di zoom in direzione-y
  #     opacity    : livello di opacità
  #     blend_type : metodo  di fusione
  #--------------------------------------------------------------------------
  def move(duration, origin, x, y, zoom_x, zoom_y, opacity, blend_type)
    @duration = duration
    @origin = origin
    @target_x = x.to_f
    @target_y = y.to_f
    @target_zoom_x = zoom_x.to_f
    @target_zoom_y = zoom_y.to_f
    @target_opacity = opacity.to_f
    @blend_type = blend_type
  end
  #--------------------------------------------------------------------------
  # * Metodo che permette di cambiare la velocità di rotazione dell'immagine
  #     speed : velocità di rotazione
  #--------------------------------------------------------------------------
  def rotate(speed)
    @rotate_speed = speed
  end
  #--------------------------------------------------------------------------
  # * Metodo che definisce l'inizio del cambio di tonalità
  #     tone     : color tone
  #     duration : time
  #--------------------------------------------------------------------------
  def start_tone_change(tone, duration)
    @tone_target = tone.clone
    @tone_duration = duration
    if @tone_duration == 0
      @tone = @tone_target.clone
    end
  end
  #--------------------------------------------------------------------------
  # * Cancella l'immagine
  #--------------------------------------------------------------------------
  def erase
    @name = ""
  end
  #--------------------------------------------------------------------------
  # * Aggiornamento di ogni singolo frame
  #--------------------------------------------------------------------------
  def update
    if @duration >= 1
      d = @duration
      @x = (@x * (d - 1) + @target_x) / d
      @y = (@y * (d - 1) + @target_y) / d
      @zoom_x = (@zoom_x * (d - 1) + @target_zoom_x) / d
      @zoom_y = (@zoom_y * (d - 1) + @target_zoom_y) / d
      @opacity = (@opacity * (d - 1) + @target_opacity) / d
      @duration -= 1
    end
    if @tone_duration >= 1
      d = @tone_duration
      @tone.red = (@tone.red * (d - 1) + @tone_target.red) / d
      @tone.green = (@tone.green * (d - 1) + @tone_target.green) / d
      @tone.blue = (@tone.blue * (d - 1) + @tone_target.blue) / d
      @tone.gray = (@tone.gray * (d - 1) + @tone_target.gray) / d
      @tone_duration -= 1
    end
    if @rotate_speed != 0
      @angle += @rotate_speed / 2.0
      while @angle < 0
        @angle += 360
      end
      @angle %= 360
    end
  end
end

 

E finalmente eccomi arrivato ai fantastici Game_Battler.
Andiamo subito ad analizzarne il primo:
1.

#==============================================================================
# ** Game_Battler (part 1)
#------------------------------------------------------------------------------
#  Questa classe si occupa dei combattenti di gioco.   E' figa! xD
#  E' considerata come una superclasse per le classi Game_Actor e Game_Enemy
#  a cui fanno riferimento.
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # * Variabili di istanza pubblica
  #--------------------------------------------------------------------------
  attr_reader   :battler_name             # Nome del file battler  #guerriero
  attr_reader   :battler_hue              # tonalità del  battler  #guerriero
  attr_reader   :hp                       # HP #capacità vitale
  attr_reader   :sp                       # SP #capacità magica
  attr_reader   :states                   # stati 
  attr_accessor :hidden                   # mostra stato "nascosto"
  attr_accessor :immortal                 # mostra stato "immortale"
  attr_accessor :damage_pop               # mostra a video il danno subito
  attr_accessor :damage                   # valore del danno
  attr_accessor :critical                 # mostra "condizione critica"
  attr_accessor :animation_id             # Codice dell'animazione
  attr_accessor :animation_hit            # mostra l'animazione del colpo
  attr_accessor :white_flash              # mostra bagliore bianco
  attr_accessor :blink                    # mostra stato "accecato"
  #--------------------------------------------------------------------------
  # * Metodo per associare i parametri di base alle variabili appena create
  #--------------------------------------------------------------------------
  def initialize
    @battler_name = ""
    @battler_hue = 0
    @hp = 0
    @sp = 0
    @states = []
    @states_turn = {}
    @maxhp_plus = 0
    @maxsp_plus = 0
    @str_plus = 0
    @dex_plus = 0
    @agi_plus = 0
    @int_plus = 0
    @hidden = false
    @immortal = false
    @damage_pop = false
    @damage = nil
    @critical = false
    @animation_id = 0
    @animation_hit = false
    @white_flash = false
    @blink = false
    @current_action = Game_BattleAction.new
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere gli HP massimi
  #--------------------------------------------------------------------------
  def maxhp
    n = [[base_maxhp + @maxhp_plus, 1].max, 999999].min
    for i in @states
      n *= $data_states[i].maxhp_rate / 100.0
    end
    n = [[Integer(n), 1].max, 999999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere gli SP massimi
  #--------------------------------------------------------------------------
  def maxsp
    n = [[base_maxsp + @maxsp_plus, 0].max, 9999].min
    for i in @states
      n *= $data_states[i].maxsp_rate / 100.0
    end
    n = [[Integer(n), 0].max, 9999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la Forza (STR)
  #--------------------------------------------------------------------------
  def str
    n = [[base_str + @str_plus, 1].max, 999].min
    for i in @states
      n *= $data_states[i].str_rate / 100.0
    end
    n = [[Integer(n), 1].max, 999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la Destrezza (DEX)
  #--------------------------------------------------------------------------
  def dex
    n = [[base_dex + @dex_plus, 1].max, 999].min
    for i in @states
      n *= $data_states[i].dex_rate / 100.0
    end
    n = [[Integer(n), 1].max, 999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere l'Agilità (AGI)
  #--------------------------------------------------------------------------
  def agi
    n = [[base_agi + @agi_plus, 1].max, 999].min
    for i in @states
      n *= $data_states[i].agi_rate / 100.0
    end
    n = [[Integer(n), 1].max, 999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere l'intelligenza (INT)
  #--------------------------------------------------------------------------
  def int
    n = [[base_int + @int_plus, 1].max, 999].min
    for i in @states
      n *= $data_states[i].int_rate / 100.0
    end
    n = [[Integer(n), 1].max, 999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare gli HP massimi
  #     maxhp : nuovi HP massimi
  #--------------------------------------------------------------------------
  def maxhp=(maxhp)
    @maxhp_plus += maxhp - self.maxhp
    @maxhp_plus = [[@maxhp_plus, -9999].max, 9999].min
    @hp = [@hp, self.maxhp].min
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare gli SP massimi
  #     maxsp : nuovi SP massimi
  #--------------------------------------------------------------------------
  def maxsp=(maxsp)
    @maxsp_plus += maxsp - self.maxsp
    @maxsp_plus = [[@maxsp_plus, -9999].max, 9999].min
    @sp = [@sp, self.maxsp].min
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare la Forza (STR)
  #     str : nuova Forza (STR)
  #--------------------------------------------------------------------------
  def str=(str)
    @str_plus += str - self.str
    @str_plus = [[@str_plus, -999].max, 999].min
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare la Destrezza (DEX)
  #     dex : nuova Destrezza (DEX)
  #--------------------------------------------------------------------------
  def dex=(dex)
    @dex_plus += dex - self.dex
    @dex_plus = [[@dex_plus, -999].max, 999].min
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare l'Agilità (AGI)
  #     agi : nuova Agilità (AGI)
  #--------------------------------------------------------------------------
  def agi=(agi)
    @agi_plus += agi - self.agi
    @agi_plus = [[@agi_plus, -999].max, 999].min
  end
  #--------------------------------------------------------------------------
  # * Metodo per selezionare l'intelligenza (INT)
  #     int : nuova intelligenza (INT)
  #--------------------------------------------------------------------------
  def int=(int)
    @int_plus += int - self.int
    @int_plus = [[@int_plus, -999].max, 999].min
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la percentuale del colpo (Hit)
  #--------------------------------------------------------------------------
  def hit
    n = 100
    for i in @states
      n *= $data_states[i].hit_rate / 100.0
    end
    return Integer(n)
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la potenza d'attacco
  #--------------------------------------------------------------------------
  def atk
    n = base_atk
    for i in @states
      n *= $data_states[i].atk_rate / 100.0
    end
    return Integer(n)
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la potenza espressa in difesa fisica
  #--------------------------------------------------------------------------
  def pdef
    n = base_pdef
    for i in @states
      n *= $data_states[i].pdef_rate / 100.0
    end
    return Integer(n)
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la potenza espressa in difesa magica
  #--------------------------------------------------------------------------
  def mdef
    n = base_mdef
    for i in @states
      n *= $data_states[i].mdef_rate / 100.0
    end
    return Integer(n)
  end
  #--------------------------------------------------------------------------
  # * Metodo per ottenere la possibilità di fuggire da una battaglia
  #--------------------------------------------------------------------------
  def eva
    n = base_eva
    for i in @states
      n += $data_states[i].eva
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Metodo per cambiare HP
  #     hp : nuovi HP
  #--------------------------------------------------------------------------
  def hp=(hp)
    @hp = [[hp, maxhp].min, 0].max
    # aggiunge o esclude l'inabilità
    for i in 1...$data_states.size
      if $data_states[i].zero_hp
        if self.dead?
          add_state(i)
        else
          remove_state(i)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Metodo per cambiare SP
  #     sp : nuovi SP
  #--------------------------------------------------------------------------
  def sp=(sp)
    @sp = [[sp, maxsp].min, 0].max
  end
  #--------------------------------------------------------------------------
  # * Metodo che permette di curare tutti i membri del party
  #--------------------------------------------------------------------------
  def recover_all
    @hp = maxhp
    @sp = maxsp
    for i in @states.clone
      remove_state(i)
    end
  end
  #--------------------------------------------------------------------------
  # * Metodo che permette di ottenere l'azione corrente
  #--------------------------------------------------------------------------
  def current_action
    return @current_action
  end
  #--------------------------------------------------------------------------
  # * Metodo per determinare la velocità d'azione
  #--------------------------------------------------------------------------
  def make_action_speed
    @current_action.speed = agi + rand(10 + agi / 4)
  end
  #--------------------------------------------------------------------------
  # * Metodo che serve per definire la Morte  (incapacità di agire)
  #--------------------------------------------------------------------------
  def dead?
    return (@hp == 0 and not @immortal)
  end
  #--------------------------------------------------------------------------
  # * Metodo che serve per definire l'esistenza (capacità di agire)
  #--------------------------------------------------------------------------
  def exist?
    return (not @hidden and (@hp > 0 or @immortal))
  end
  #--------------------------------------------------------------------------
  # * Metodo che serve per definire HP 0
  #--------------------------------------------------------------------------
  def hp0?
    return (not @hidden and @hp == 0)
  end
  #--------------------------------------------------------------------------
  # * Metodo che definisce se un comando può essere eseguito
  #--------------------------------------------------------------------------
  def inputable?
    return (not @hidden and restriction <= 1)
  end
  #--------------------------------------------------------------------------
  # * Metodo che definisce se un'azione può essere possibile
  #--------------------------------------------------------------------------
  def movable?
    return (not @hidden and restriction < 4)
  end
  #--------------------------------------------------------------------------
  # * Metodo che definisce se si è in guardia
  #--------------------------------------------------------------------------
  def guarding?
    return (@current_action.kind == 0 and @current_action.basic == 1)
  end
  #--------------------------------------------------------------------------
  # * Metodo che definisce se si è capaci di resistere
  #--------------------------------------------------------------------------
  def resting?
    return (@current_action.kind == 0 and @current_action.basic == 3)
  end
end

 

2.

Edited September 15, 2015 by Lomax_Iced

[Guardian of Irael]

Bentornato in questo utile topic allora!

 

Non hai intenzione di aggiungere anche dettagli, descrizioni e simili alla fine dello script, nel messaggio, come facevi prima? ^ ^