RPGXP Scripts Standard | Traduzione

[marigno]

RPGXP Traduzione Scripts Standard (ottimizzata per la versione 1.02*)

Traduzione in Italiano.

Descrizione

Premetto che quasi tutto il lavoro fatto lo dovete a Drago Verde, noi ci siamo limitati a prendere la sua vecchia traduzione per correggerla, ampliarla ed ottimizzarla per la versione 1.02* di RPG Maker XP. Difatti, usando la versione di Drago Verde su RPGXP 1.02* - 1.03 si riscontrano non pochi problemi, come ad esempio il problema legato all'impossibile modifica dei font. Con questa nostra versione, come ho già detto corretta, non avrete più problemi. Chi ha la versione 1.03 del programma, sarebbe pregato di fare un beta test per controllare eventuali errori di versione.

Con questo terzo lavoro ufficiale speriamo di darvi campo libero sull'utilizzo e sulla modifica degli scripts standard. ^^

 

Autore

R²S Resources Team ©;

Drago Verde;

 

Allegati

Screenshot:

 

Video:

Traduzione_Scripts_Standard_Ita_Video.rar

 

 

Stato del progetto

Percentuale di completamento:

[

||||

||||||

]

Parti completate:

• Game_Temp;
  
• Game_System;
  
• Game_Switches;
  
• Game_Variables;
  
• Game_SelfSwitches;
  
• Game_Screen;
  
• Game_Picture;
  
• Game_Battler 1;
  
• Game_Battler 2;
  
• Game_Battler 3;
  
• Main;
  

Parti da completare:

• I mancanti Scripts
  
• Revisione completa
  

Si accettano commenti, consigli e critiche. :)

Edited November 22, 2007 by Marigno

[Tio]

Ottima idea ;)

Tempo fa ce l'avevo pure io la traduzione di DragoVerde, solo che l'ho persa e ora mi rifarebbe comodo.. ^^

[marigno]

La vecchia traduzione di Drago Verde la puoi reperire da questo stesso forum, ma ti avverto che avrai parecchi problemi! :P

 

Scripts.zip

Edited November 17, 2007 by Marigno

[DaD]

Per i font perchè non provate a mettere di defualt il mio main modificato?

[Guest Dryve]

Ottima idea! mi sarà molto utile se voglio modificare qualkosa nell'RGSS dato che i commenti in inglese nn li mastico molto...

[marigno]

Grazie. ^^

[marigno]

Stato del progetto aggiornato.

[Guest Dryve]

continua così Marigno nn vedo l'ora di vedere il mio script editor italianizzato... Edited November 20, 2007 by Dryve

[marigno]

Grande News! ^^

La traduzione degli scripts standard verrà rilasciata in versione 1.0 domani alle ore 22:00, purtroppo, per mancanza di tempo non verranno aggiunte le guide su come modificare piccole parti degli scripts, nonostante ciò, le classi saranno completamente tradotte in italiano, con alcune brevi spiegazioni.

E in più, nel reparto "Allegati" ho aggiunto un video (Qualità media) per un piccolo anteprima sulla traduzione.

 

[Rilascio annullato, leggi il secondo post sottostante per chiarimenti].

Edited December 15, 2007 by Marigno

[Tio]

L'avete finita per caso?

Devo iniziare a lavorare con l'rgss editor del mio progetto e con le traduzioni in italiano mi esce più semplice..

[marigno]

Purtroppo ancora no, per via di serie complicazioni:

 

Io sono in una nuova scuola, nuova città, nuova casa. Ho molto da fare.

Soul è incasinato con i compiti perché non studia mai (xD).

 

Però promettiamo solennemente, per il potere conferitomi da giurin giurello, che alla release di RST ci saranno nuovissimi aggiornamenti nel team, e manca poco. ^^

 

Stay tuned. (O come si scrive).

[Guest Dryve]

Bene xkè una volta finita sarà una cosa molto utile a chi si vuole cimentare nell'RGSS...

[D-Tino]

sarà compatibile con xp 1.1?

[marigno]

Per la versione 1.01 consigliamo quella rilasciata al terzo Post, di Drago Verde.

[§Illidan§]

Continuate così ^^

[Manic]

Come procede la traduzione? O è stata abbandonata?

[Lomax_Iced]

Salve gente! :D
Riapro questo topic sperando possa esservi utile. Ho scoperto che traducendo i commenti verdi presenti negli script rgss si possono imparare un mucchio di cose. Posto qui perché non mi va di riaprire un altro topic e perché penso che questa sia la sezione più adatta.
Ma dunque iniziamo con il mostrarvi la prima classe presente sul nostro script_editor targato rmxp:

Game_Temp

 

 

#==============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
#  Questa classe memorizza i dati temporanei non inclusi nei giochi salvati.
#  Call " $ game_temp " per accedere alle variabili globali incluse in questa 
#  classe .
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # * Variabili Globali
  #--------------------------------------------------------------------------
  attr_accessor :map_bgm                  # Musica Mappa ( restituita alla fine della battaglia )
  attr_accessor :message_text             # Testo del messaggio
  attr_accessor :message_proc             # Chiama Messaggio ( Processo )
  attr_accessor :choice_start             # Elezioni : Inizio riga
  attr_accessor :choice_max               # Elezioni : Numero di opzioni
  attr_accessor :choice_cancel_type       # Elezioni : Aggiungi Branch a Annulla
  attr_accessor :choice_proc              # Elezioni : Call ( Processo )
  attr_accessor :num_input_start          # Cifre : Inizio di linea
  attr_accessor :num_input_variable_id    # Cifre : Variabile che viene salvata
  attr_accessor :num_input_digits_max     # numero di ingresso : importo cifre
  attr_accessor :message_window_showing   # Esecuzione finestra dei messaggi
  attr_accessor :common_event_id          # Common Event ID
  attr_accessor :in_battle                # Indica se si è in battaglia
  attr_accessor :battle_calling           # Richiama la Battaglia
  attr_accessor :battle_troop_id          # ID Nemici di Gruppo
  attr_accessor :battle_can_escape        # Possibilità di scappare
  attr_accessor :battle_can_lose          # Possibilità di perdere la battaglia
  attr_accessor :battle_proc              # Richiama la battaglia ( Processo )
  attr_accessor :battle_turn              # Numero dei turni in battaglia
  attr_accessor :battle_event_flags       # Flags di battaglia evento : completati
  attr_accessor :battle_abort             # Chiamata per terminare la battaglia
  attr_accessor :battle_main_phase        # Flag di battaglia: Fase Principale
  attr_accessor :battleback_name          # Nome dello sfondo di battaglia
  attr_accessor :forcing_battler          # Azione forzata del combattente
  attr_accessor :shop_calling             # Richiama un negozio (shop)
  attr_accessor :shop_goods               # Lista degli oggetti del negozio
  attr_accessor :name_calling             # Scrivere il nome di ciò che si vuole richiamare
  attr_accessor :name_actor_id            # Scrivi il nome dell'ID eroe
  attr_accessor :name_max_char            # Numero massimo di caratteri da usare per scrivere il nome
  attr_accessor :menu_calling             # Richiama il Menu
  attr_accessor :menu_beep                # Riproduci i suoni del Menu
  attr_accessor :save_calling             # Richiama la schermata di salvataggio
  attr_accessor :debug_calling            # Richiama la schermata di debug
  attr_accessor :player_transferring      # Richiama un punto di teletrasporto eroe
  attr_accessor :player_new_map_id        # Destinazione eroe: ID Mappa
  attr_accessor :player_new_x             # Destinazione eroe: Cordinata X
  attr_accessor :player_new_y             # Destinazione eroe: Cordinata Y
  attr_accessor :player_new_direction     # Destinazione eroe: direzione
  attr_accessor :transition_processing    # Richiama il processo di transizone
  attr_accessor :transition_name          # Nome dell'archivio di transizione
  attr_accessor :gameover                 # Richiama GameOver
  attr_accessor :to_title                 # Richiama al menu iniziale
  attr_accessor :last_file_index          # Numero dell'ultima partita salvata
  attr_accessor :debug_top_row            # Schermata di debug : Riga selezionata
  attr_accessor :debug_index              # Schermata di debug : opzione selezionata
  #--------------------------------------------------------------------------
  # * Inizializzazione Oggetti 
  #  (Qui viene aggiunto a ciascuna variabile il valore iniziale)
  #--------------------------------------------------------------------------
  def initialize
    @map_bgm = nil
    @message_text = nil
    @message_proc = nil
    @choice_start = 99
    @choice_max = 0
    @choice_cancel_type = 0
    @choice_proc = nil
    @num_input_start = 99
    @num_input_variable_id = 0
    @num_input_digits_max = 0
    @message_window_showing = false
    @common_event_id = 0
    @in_battle = false
    @battle_calling = false
    @battle_troop_id = 0
    @battle_can_escape = false
    @battle_can_lose = false
    @battle_proc = nil
    @battle_turn = 0
    @battle_event_flags = {}
    @battle_abort = false
    @battle_main_phase = false
    @battleback_name = ''
    @forcing_battler = nil
    @shop_calling = false
    @shop_id = 0
    @name_calling = false
    @name_actor_id = 0
    @name_max_char = 0
    @menu_calling = false
    @menu_beep = false
    @save_calling = false
    @debug_calling = false
    @player_transferring = false
    @player_new_map_id = 0
    @player_new_x = 0
    @player_new_y = 0
    @player_new_direction = 0
    @transition_processing = false
    @transition_name = ""
    @gameover = false
    @to_title = false
    @last_file_index = 0
    @debug_top_row = 0
    @debug_index = 0
  end
end

Vengono "Nominati" e "Indicizzati" alcuni oggetti che poi troveremo nei metodi, nei cicli e nelle condizioni delle classi a seguire.

Per "Nominare" intendo letteralmente assegnargli un nome identificativo, associato ad un attributo che può essere di lettura, scrittura o entrambe le cose.

 

Per "Indicizzare" intendo definire che tipo di oggetto sono, anteponendo loro un suffisso (in questo caso @) per indicare la tipologia degli oggetti ed infine sempre dentro il metodo "Initialize" associargli un valore. Che esso sia testuale, numerico o logico.

Da quest'analisi posso benissimo dirvi che in questa classe abbiamo in gioco: 16 pulsanti (switch) e 28 variabili. per un totale di 44 oggetti.

Cosa sono le switch?

una switch è un interruttore e può essere associato ad esso solo il valore di acceso (true) o spento (false). Si riconoscono fondamentalmente da questo.

 

 

 

Cosa sono le variabili?

 

 

le variabili sono degli oggetti capaci di assumere più valori, al contrario delle switch che ne possono assumere solo uno per volta.
Come dicevo prima possono essere di valore numerico o testuale. Posso associare ad esse altre variabili e facilitano di molto, anzi
direi che sono l'essenziale per l'attuazione di molti processi logici.
(P.S: ne esistono di vari tipi, fuori trovate una miriade di guide che ne parlano.)

 

 

 

 

Prossima classe:

Game_System

 

 

#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  Questa classe memorizza le variabili di dati e comandi di sistema , 
#  come ad esempio la Riproduzione di musica e del suono , windowskin , timer , etc. Chiamare 
#  $ game_system per accedere alle variabili incluse in questa classe.
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # * Variabili Globali
  #--------------------------------------------------------------------------
  attr_reader   :map_interpreter          # Interprete degli eventi in mappa
  attr_reader   :battle_interpreter       # Interprete degli eventi in battaglia
  attr_accessor :timer                    # Tempo
  attr_accessor :timer_working            # Esecuzione Tempo
  attr_accessor :save_disabled            # Richiama il salvataggio disabilitato
  attr_accessor :menu_disabled            # Richiama il menu disabilitato
  attr_accessor :encounter_disabled       # Incontri dei nemici: disabilitato
  attr_accessor :message_position         # Opzione messaggio : posizione della finestra
  attr_accessor :message_frame            # Opzione messaggio : struttura
  attr_accessor :save_count               # Contatore delle partite salvate
  attr_accessor :magic_number             # Numero Magico
  #--------------------------------------------------------------------------
  # * Inizializzazione Oggetti 
  #  (Qui viene aggiunto a ciascuna variabile il valore iniziale)
  #--------------------------------------------------------------------------
  def initialize
    @map_interpreter = Interpreter.new(0, true)
    @battle_interpreter = Interpreter.new(0, false)
    @timer = 0
    @timer_working = false
    @save_disabled = false
    @menu_disabled = false
    @encounter_disabled = false
    @message_position = 2
    @message_frame = 0
    @save_count = 0
    @magic_number = 0
  end
  #--------------------------------------------------------------------------
  # * Riproduci Suoni
  # Questi metodi utilizzati qui di seguito si occupano di gestire i suoni di sistema
  # quali: (la musica , effetti d'ambiente , effetti sonori , ecc )
  # Il modulo che gestisce le variabili presenti in questi metodi è definito 
  # "::AudioFile"
  # E contiene nel suo metodo di avvio ( nome , volume, tono )
  # Dove è possibile chiamare questa classe con il seguente metodo :
  # RPG :: AudioFile.new ( nome , volume, tono )
  # I valori di default sono ( " " , 100 , 100)
  #--------------------------------------------------------------------------
  # * Riprodurre Musica
  #     "bgm" è la variabile che viene associata all'azione o all'archivio
  #     in cui viene riposta e gestita la musica di ambientazione del gioco
  #--------------------------------------------------------------------------
  def bgm_play(bgm)
    @playing_bgm = bgm
    if bgm != nil and bgm.name != ""
      Audio.bgm_play("Audio/BGM/" + bgm.name, bgm.volume, bgm.pitch)
    else
      Audio.bgm_stop
    end
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # * Fermare l'esecuzione della musica
  #--------------------------------------------------------------------------
  def bgm_stop
    Audio.bgm_stop
  end
  #--------------------------------------------------------------------------
  # * Far cessare la musica con un effetto sfumato(tipo dissolvenza del suono)
  #     "time" è la variabile che permette tale processo.
  #--------------------------------------------------------------------------
  def bgm_fade(time)
    @playing_bgm = nil
    Audio.bgm_fade(time * 1000)
  end
  #--------------------------------------------------------------------------
  # * Memorizzare la musica
  #  Utilizzando questo comando viene memorizzato BGM attualmente in esecuzione 
  #  e la variabile globale che permette l'esecuzione di tale operazione è definita:
  #  "memorized_bgm" all'interno della stessa classe.
  #--------------------------------------------------------------------------
  def bgm_memorize
    @memorized_bgm = @playing_bgm
  end
  #--------------------------------------------------------------------------
  # * Riproduzione della musica memorizzata
  #   Utilizzando questo comando, si riproduce il BGM incluso nella
  #   variabile locale "memorized_bgm"
  #--------------------------------------------------------------------------
  def bgm_restore
    bgm_play(@memorized_bgm)
  end
  #--------------------------------------------------------------------------
  # * Reiprodurre effetti sonori di ambientazione
  #     "bgs" è la variabile associata a tale operazione.
  #--------------------------------------------------------------------------
  def bgs_play(bgs)
    @playing_bgs = bgs
    if bgs != nil and bgs.name != ""
      Audio.bgs_play("Audio/BGS/" + bgs.name, bgs.volume, bgs.pitch)
    else
      Audio.bgs_stop
    end
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # * Fermare effetti sonori di ambientazione con un effetto sfumato 
  #   (tipo dissolvenza del suono)
  #     "time" è la variabile che determina tale processo.
  #--------------------------------------------------------------------------
  def bgs_fade(time)
    @playing_bgs = nil
    Audio.bgs_fade(time * 1000)
  end
  #--------------------------------------------------------------------------
  # * Memorizzare gli effetti sonori di ambientazione
  #  Utilizzando questo comando viene memorizzato BGS attualmente in esecuzione 
  #  e la variabile globale che permette l'esecuzione di tale operazione è definita:
  #  "memorized_bgs" all'interno della stessa classe.
  #--------------------------------------------------------------------------
  def bgs_memorize
    @memorized_bgs = @playing_bgs
  end
  #--------------------------------------------------------------------------
  # * Riprodurre suono di ambientazione memorizzato
  #   Utilizzando questo comando, si riproduce il BGS incluso nella
  #   variabile locale "memorized_bgs"
  #--------------------------------------------------------------------------
  def bgs_restore
    bgs_play(@memorized_bgs)
  end
  #--------------------------------------------------------------------------
  # * Riproduci effetto musicale
  #     "me" è la variabile che è associata a questa operazione
  #--------------------------------------------------------------------------
  def me_play(me)
    if me != nil and me.name != ""
      Audio.me_play("Audio/ME/" + me.name, me.volume, me.pitch)
    else
      Audio.me_stop
    end
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # * Riproduce effetto sonoro
  #     "se" è il file da riprodurre
  #--------------------------------------------------------------------------
  def se_play(se)
    if se != nil and se.name != ""
      Audio.se_play("Audio/SE/" + se.name, se.volume, se.pitch)
    end
  end
  #--------------------------------------------------------------------------
  # * Arresto Effetti sonori
  #--------------------------------------------------------------------------
  def se_stop
    Audio.se_stop
  end
  # Riproduzione di suoni
  # I due metodi seguenti vengono utilizzati per estrarre i suoni che sono
  # Attualmente riprodotti. Utilizzate questi metodi solo per determinare
  # La riproduzione di file audio. 
  # Il comando per permettere questo è (variabile = $game_system.playing_bgm).
  #--------------------------------------------------------------------------
  # * Far eseguire la musica
  # Utilizzando questo metodo , si fa riprodurre la musica scelta.
  #--------------------------------------------------------------------------
  def playing_bgm
    return @playing_bgm
  end
  #--------------------------------------------------------------------------
  # * Far eseguire gli effetti d'ambientazione
  # Utilizzando questo metodo, si riproducono gli effetti d'ambientazione scelti
  #--------------------------------------------------------------------------
  def playing_bgs
    return @playing_bgs
  end
  #--------------------------------------------------------------------------
  # * Archivio delle windowskin attuali
  #   Usa questo metodo per determinare quale windowskin hai scelto di 
  #   utilizzare, estrapolandola dall'archivio che la ospita.
  #--------------------------------------------------------------------------
  def windowskin_name
    if @windowskin_name == nil
      return $data_system.windowskin_name
    else
      return @windowskin_name
    end
  end
  #--------------------------------------------------------------------------
  # * Cambiare Windowskin
  #    Per permettere di scegliere una nuova windowskin da utilizzare in gioco
  #    si usa la variabile "windowskin_name" che sta ad indicare e spesso, in
  #    operazione, viene sostituita, dal nome del file immagine che rappresenta
  #    la windowskin che si vuole utilizzare. 
  #--------------------------------------------------------------------------
  def windowskin_name=(windowskin_name)
    @windowskin_name = windowskin_name
  end
  #--------------------------------------------------------------------------
  # * Musica di battaglia
  # Con questo metodo, si sceglie la musica che si vuole utilizzare, durante
  # lo svolgimento delle nostre battaglie presenti nel nostro gioco. 
  #--------------------------------------------------------------------------
  def battle_bgm
    if @battle_bgm == nil
      return $data_system.battle_bgm
    else
      return @battle_bgm
    end
  end
  #--------------------------------------------------------------------------
  # * Cambiare Musica di battaglia
  #     Questo metodo si utilizza per permettere al programmatore di cambiare
  #     la musica che si svolge durante la battaglia
  #     La variabile che permette tale operazione è "battle_bgm".
  #--------------------------------------------------------------------------
  def battle_bgm=(battle_bgm)
    @battle_bgm = battle_bgm
  end
  #--------------------------------------------------------------------------
  # * Musica di Fine Battaglia
  # Usando questo metodo, si aggiunge una breve musichetta che indica la fine
  # della battaglia, per intenderci (come la sigla di vittoria quando si ha 
  # vinto uno scontro), per esempio. 
  #--------------------------------------------------------------------------
  def battle_end_me
    if @battle_end_me == nil
      return $data_system.battle_end_me
    else
      return @battle_end_me
    end
  end
  #--------------------------------------------------------------------------
  # * Cambiare Musica di Fine Battaglia
  #     Per cambiare musica di fine battaglia, spesso si usa questo metodo e
  #     la variabile interessata è la seguente: "battle_end_me". 
  #--------------------------------------------------------------------------
  def battle_end_me=(battle_end_me)
    @battle_end_me = battle_end_me
  end
  #--------------------------------------------------------------------------
  # * Impostare il Tempo
  #--------------------------------------------------------------------------
  def update
    # Il tempo rimanente viene ridotto a meno 1
    if @timer_working and @timer > 0
      @timer -= 1
    end
  end
end

In questa classe noterete qualcosa di nuovo. Avvengono sempre quei processi di nomina e inizializzazione che avvenivano nella classe precedente. Solo che qui vengono costituiti nuovi metodi.

Che cos'è un metodo?

 

Un metodo è un processo, che serve a far eseguire qualcosa agli oggetti che vengono indicizzati. Paradossalmente anche il processo di indicizzazione è un metodo.
Solitamente tali ci appaiono nelle nostre classi con i suffissi azzurri denominati "def" che credo stia ad indicare "definizione".
al suffisso def viene associato il nome della tipologia di metodo che si vuole usare per far eseguire quel determinato processo.
e qui, in questa classe, ne vediamo alcuni esempi:

 

def initialize #si occupa di associare dei valori agli oggetti identificati.

def bgm_play(bgm) #si occupa di eseguire la musica di ambientazione che ci allieterà durante il gioco

def bgm_stop #si occupa di stopparla in maniera netta

def bgm_fade(time) #si occupa di stopparla utilizzando un effetto sfumato tipo dissolvenza dei volumi dell'audio

def bgm_memorize #si occupa di memorizzare la musica che si sta riproducendo e attraverso...

def bgm_restore #la si continua a fare eseguire fino a quando si vuole, tenendola memorizzata.

 

all'interno dello script troverete altri metodi simili a quelli sopra citati ma che riguarderanno gli oggetti BGS, SE, ME.

Mi secca ripetermi, trovate comunque tutto scritto in maniera dettagliata, all'interno dei commenti dello script medesimo.

 

Un altra cosa, spesso dentro lo script avrete sentito parlare del modulo AudioFile denominato Rpg::Audiofile.new
E' il seguente:

 

module RPG
  class AudioFile
    def initialize(name = "", volume = 100, pitch = 100)
      @name = name
      @volume = volume
      @pitch = pitch
    end
    attr_accessor :name    #Nome del file audio
    attr_accessor :volume  #Livello del volume (0 = silenzioso / 100 = alto)
    attr_accessor :pitch   #Tonalità del volume (si regola con un valore compreso fra 0 e 100)
  end
end 

Significa che gli elementi usati per completare alcuni metodi presenti in Game_System utilizzano le regole di questa classe AudioFile appartenente
al modulo RPG.
Cos'è un Modulo?

 

Paradossalmente anche tutte le classi Game_ sono come dei moduli. Notate bene la sua struttura, se dopo quel class vi fosse scritto
Game_Temp.. sembrano quasi identiche.

un modulo serve per trasportare attraverso un richiamo tutti gli elementi presenti in quella classe e adoperarli in altre tramite il comando
(in questo caso) RPG:: dove dopo i due doppi punti si digita il nome della classe che si vuole identificare dentro un'altra classe. e si chiude
il comando con .new .

Vediamo l'esempio concreto: andiamo su in Game_System e prendiamo un metodo qualsiasi, inerenti l'esecuzioni dei suoni.
Dentro le condizioni notiamo costrutti tipo .name oppure altri suffissi a noi inizialmente incomprensibili, bene ecco ora svelato l'arcano.

 

 

 

 

Prossimo script:
Game_Switches

 

 

#==============================================================================
# ** Game_Switches
#------------------------------------------------------------------------------
#  Questa classe è responsabile degli interruttori . 
#  Si tratta di un contenitore per il "matrice " classe incorporata .
#  Consulta " game_switches $" per l'istanza della suddetta classe 
#==============================================================================

class Game_Switches
  #--------------------------------------------------------------------------
  # * Inizializzazione oggetti
  #--------------------------------------------------------------------------
  def initialize
    @data = []
  end
  #--------------------------------------------------------------------------
  # * Ottieni Interruttore
  #     switch_id : ID Interruttore
  #--------------------------------------------------------------------------
  def [](switch_id)
    if switch_id <= 5000 and @data[switch_id] != nil
      return @data[switch_id]
    else
      return false
    end
  end
  #--------------------------------------------------------------------------
  # * Seleziona Interruttore
  #     switch_id : ID Interruttore
  #     value     : ON (true) / OFF (false) [Acceso(true)/Spento(false)]
  #--------------------------------------------------------------------------
  def []=(switch_id, value)
    if switch_id <= 5000
      @data[switch_id] = value
    end
  end
end

Questa classe gestisce tutte le informazioni che si riferiscono agli switch presenti nel nostro gioco.
E' composta essenzialmente da due metodi molto intuitivi:

Innanzi tutto possiamo notare come dentro il metodo initialize costituisce un array (intendo "@data = []" )
così impostato l'oggetto data non è ne una variabile ne una switch, ma con quel valore lì di seguito diventa una sorta di Bus o Treno.

Che cos'è un Array?

 

Un array ha la stessa logica di un Bus, trasporta uno o un gruppo di oggetti e fa si che questi tutti insieme eseguono una determinata operazione, (nel caso dell'esempio si spostano tutti in un unica direzione) E' una sorta di insieme di oggetti in cui si può far gestire
a tutti gli elementi posti al suo interno delle operazioni. Spesso lo incontriamo nei cicli, in alcune condizioni e nei metodi.

 

 

 

Creato il Bus che ci faciliterà la vita, bisogna ottenere i suoi occupanti. Bene per farlo il metodo [](switch_id) è quello che fa al caso nostro. Impostando dentro se stesso una condizione, il processo (che poi in diritto sarebbe paragonabile ad una "fattispecie") crea la condizione generica e a tale ne associa la risultante che si vuole far generare.

Che cos'è una condizione?

Una condizione è una "fattispecie" ossia la definizione generica di un fatto, in questo caso, procedimento logico.
Per capirci analizziamo quanto segue:

Poniamo il caso che io ho un interruttore. Se tale soddisfa condizione 1 + condizione 2, io ottengo un risultato 3
Analizzando la condizione che troviamo all'interno del metodo "ottieni switch" troviamo:

che se la switch è minore o uguale di 5000 #condizione 1

+

e l'array che ospita la switch non ha un valore identificativo, ovvero sarà nullo (= nil) #condizione 2

 

noi otterremo che il bus che ospita il nostro switch assumerà un valore qualsiasi. # =risultato 3

 

Quindi in futuro se si imposta if @switch_id == true
@data[switch_id] = print "Ciao :D"

else

@data[switch_id] = print ""

end

 

In questo modo si otterrà una condizione simile che enuncia che quando il nostro interruttore sarà acceso,
apparirà una scritta "Ciao :D" altrimenti non apparirà nulla. (ovviamente questo è un esempio)

P.S: fuori ci sono un mucchio di guide se avete dei dubbi chiedetelo nel forum, esistono migliaia di guide in merito.

 

Una volta che abbiamo dedicato del tempo ad identificare la switch, ci dedichiamo a giustificare il concetto di valore.

E il metodo da usare sostanzialmente è semplice perché indica che qualsiasi valore ottenuto apparterrà alla switch
posta dentro il bus. (io lo chiamo Bus perché mi piace il paragone ma tecnicamente si chiama Array).

Quel valore, 5000 indica una soglia lontana. Non credo che userete mai più di 5000 interruttori in un vostro gioco.
Per intenderci, è come il concetto delle pagine di exel non sono infinite sono un numero in esubero di fogli, ma sempre
di numero finito si parla. Non esiste il concetto di infinito.

 

Prossima Classe:
Game_Variables

#==============================================================================
# ** Game_Variables
#------------------------------------------------------------------------------
#  Questa classe gestisce le variabili . 
#  Consulta " game_variables $" per l'istanza della suddetta classe.
#==============================================================================

class Game_Variables
  #--------------------------------------------------------------------------
  # * Inizializzazione oggetti
  #--------------------------------------------------------------------------
  def initialize
    @data = []
  end
  #--------------------------------------------------------------------------
  # * Seleziona Variabile
  #     variable_id : ID Variabile
  #--------------------------------------------------------------------------
  def [](variable_id)
    if variable_id <= 5000 and @data[variable_id] != nil
      return @data[variable_id]
    else
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # * Seleziona valore della Variabile
  #     variable_id : ID Variabile
  #     value       : Valore della variabile
  #--------------------------------------------------------------------------
  def []=(variable_id, value)
    if variable_id <= 5000
      @data[variable_id] = value
    end
  end
end

Come potete notare il metodi usati sono sostanzialmente gli stessi, cambia solo qualcosina. Ne approfitto per ripetere il concetto.
Come per le switches, per le variabili è lo stesso. Vengono richiamate dall'archivio @data[], che altro non è che un Array, quello che io chiamavo Bus per farvi capire. In un Array potete trovare un oggetto, più di uno, non so se avete mai visto in autostrada quei camion che trasportano le macchine, benissimo per intenderci un Array può contenere altri array con a loro interno uno o più valori.

Sostanzialmente sto benedetto array serve per raggruppare un numero n di elementi e associarli ad un valore.

Prima abbiamo visto che veniva usato per identificare un interruttore, adesso in questa classe, identifica una variabile.

Cos'è questo suffisso _id che vedo scritto sempre?

ID sta ad indicare il codice "personale" dell'oggetto da utilizzare, sia se questo è un interruttore o una variabile. Chi mastica programmazione ad eventi, identificare l'ID di un oggetto che si vuole usare è pane quotidiano. Lo è anche per chi scripta.

 

 

PS: qui sul sito ci sono un casino di guide da consultare per approfondire per bene tutti questi concetti. Se siete proprio bassi
andatevi a studiare qualche nozione e poi mettetela in pratica magari analizzando queste classi.

 

 

***Non capisco perché non mi chiude l'ultimo spoiler, con tutto che è stato inserito il comando

(ho ancora da mostrarvi molte altre classi tra cui le traduzioni dei 3 Game_Battler ma non la posto se non mi risolvete questo impiccio)
Nei tre game_battler ci sono metodi davvero interessanti per chi vuole imparare a scriptare un BS da zero, o semplicemente modificarlo.
Momentaneamente stoppo qua.

Edited August 11, 2015 by Lomax_Iced

[Guardian of Irael]

Credo che da qualche parte ci sia un XP con la traduzione italiana anche per gli script, mi pare di ricordarlo; comunque sì leggere i commenti è utile, ma se hai tempo e voglia direi di iniziare anche a sperimentare col codice stesso degli script base e fare piccole modifiche per capire di più: nei commenti non c'è tutto, anzi pure poco.

^ ^

[Lomax_Iced]

L'idea era di aiutare i nuovi utenti a ragionare sulle varie sezioni degli script. Tempi fa avevo sostituito tutti gli script dell'editor inglese con quelli che aveva un utente Portoghese. Questi script hanno un casino di commenti ove il quale a loro interno vi sono spiegati tutti i passaggi step by step di tutti i processi logici che avvengono
nelle varie classi. in più questo tipo, di cui proprio non ricordo il Nikname, aveva con se, nella sua lista di script, tutti i moduli a cui fanno riferimento tutte le classi del nostro editor. Questo perché spesso nei vari processi logici che riscontriamo all'interno dei metodi, troviamo diciture che non sono state inizializzate in quella classe
E ci incuriosiscono, non sappiamo come sono spuntate, addirittura, io ad esempio all'inizio pensavo che questi costrutti venivano inseriti là a discrezione del programmatore. Pertanto volevo tradurre il più possibile e sbagliavo, perché ad esempio traducevo l'elemento bgm.name con nome.bgm e sbagliavo perché andavo a scombussolare qualsiasi cosa aveva come riferimento quel determinato comando, presente in chissà quale altra classe.
E spesso non riuscendo a venirne a capo, accantonavo tutto e cambiavo via.

Invece adesso so per esempio che se devo proprio cambiare quel comando come voglio io e renderlo valido.
Devo recarmi alla classe AudioFile; rinominare la variabile attr_accessor :name trasformandola in attr_accessor :nome andare in def inizialize della stessa classe
e identificare la variabile @nome = "" eliminando totalmente la precedente @name = "" .

In questo modo una volta ritornato nel metodo dove si era trovato quel costrutto bgm.name so che così non avrà più valenza ma acquisirà considerazione se
scritto così bgm.nome

Dico è un esempio per intenderci.
Sto pensando a coloro che chiedono nelle varie sezioni come si fa questo o come si fa quell'altro. In questo modo avendo comunque un incipit con cui iniziare, possono capire realmente cosa c'è nei loro script di origine e poi divertirsi a modificare, per poi passare a ricrearli di sana PIANTA! O.o
Magari aggiungendo migliorie xD

[Guardian of Irael]

Avere ogni riga di codice commentato come è stato per quella traduzione portoghese non è male, aiuta meglio a capire. Se hai la possibilità di tradurre quella dovrebbe essere di grande aiuto per chi si butta sugli script.

Ma questa cosa...

 

nvece adesso so per esempio che se devo proprio cambiare quel comando come voglio io e renderlo valido.
Devo recarmi alla classe AudioFile; rinominare la variabile attr_accessor :name trasformandola in attr_accessor :nome andare in def inizialize della stessa classe
e identificare la variabile @nome = "" eliminando totalmente la precedente @name = "" .

In questo modo una volta ritornato nel metodo dove si era trovato quel costrutto bgm.name so che così non avrà più valenza ma acquisirà considerazione se
scritto così bgm.nome

dovresti evitarla. E' meglio lasciare tutti i termini così come sono, toccare solo i commenti ed uniformarsi alla lingua inglese per il resto. Altrimenti se tu cambi in nome ed uno scripter inglese fa riferimento a quella cosa con scritto name si perde tutta la compatibilità di script esterni e simili.

^ ^

[Holy87]

Avere ogni riga di codice commentato come è stato per quella traduzione portoghese non è male, aiuta meglio a capire. Se hai la possibilità di tradurre quella dovrebbe essere di grande aiuto per chi si butta sugli script.

Ma questa cosa...

dovresti evitarla. E' meglio lasciare tutti i termini così come sono, toccare solo i commenti ed uniformarsi alla lingua inglese per il resto. Altrimenti se tu cambi in nome ed uno scripter inglese fa riferimento a quella cosa con scritto name si perde tutta la compatibilità di script esterni e simili.

^ ^

Assolutamente, è pura blasfemia tradurre anche le istruzioni degli script, si finisce per rendere incompatibili tutti gli script scaricati che usano quei metodi. SEMPRE limitarsi a tradurre i commenti, e soprattutto si programma sempre in inglese.

[Lomax_Iced]

Si no.. vi do assolutamente ragione. :) Non intendevo asserire che bisogna tradurre tutto tutto. Ma prima pensavo si potesse (mi riferisco al lontano 2007/2008, quegli anni lì) Magari sto pensando che un altro utente può cimentarsi in questa strada ed avvisarlo prima che è assolutamente una via che non spunta.

OT: Ho letto la tua guida da 133 pagine sei un Grande :D Holy87

Piuttosto ho potuto appurare che si possono denominare diversamente i nomi degli oggetti, ma è tipo magia nera nel senso metaforico del termine, ovvero che
"si può fare ma è meglio non farlo" appunto per il discorso di compatibilità fra script.

Ora il mio intervento qui è voluto per cercare di scoprire il codice, lavorando direttamente sulle funzioni degli script standard.
Veramente, io che in quegli anni lì, cercavo e stra cercavo guide o tutorial inerenti l'rgss, spulciavo dal ruby ma senza capirci molto, proprio non riuscivo a capire che bastava semplicemente analizzare le classi di base.

E' da un po che mi esercito, facendo esperimenti. In questa sezione mi limiterò a spulciare gli script tradotti.
Si dice sempre che esiste da qualche parte una Pach con su gli script tradotti in italiano ma non la si trova mai.
Quindi voglio fare si che in quest'angolo del sito vi siano gli script di base analizzati uno per uno, dove gli utenti possono trarne materiale di studio. Così vedono con i loro occhi che tutto quello che gli necessità è presente sia nella tua guida Holy87 che all'interno del loro editor.

Senza dover girare troppo per siti o tutorial.

(Non vedo l'ora di arrivare a trattare i tre Game_Battler e non solo, poi mi sposterò ai Game_Character! Cioè ho scoperto cose che sono veramente fighissime e sono lì a portata di tutti.)

 

In questo momento sono impegnato con il tentare di creare un file.rxdata. L'idea è di compilare al suo interno dei nuovi archivi di riferimento.
Voi dite.. perché complicarti la vita? è già tutto là!... studio picciotti e curiosità nulla più. e questa voglia matta di rendere personale ogni mia creazione.

vediamo se ci riesco oppure niente. Io ci provo.

Una cosa importante. Nel caso in cui io dovessi dire castronerie col botto, correggetemi pure, io cercherò di non farle. :)

[Holy87]

Si no.. vi do assolutamente ragione. :) Non intendevo asserire che bisogna tradurre tutto tutto. Ma prima pensavo si potesse (mi riferisco al lontano 2007/2008, quegli anni lì) Magari sto pensando che un altro utente può cimentarsi in questa strada ed avvisarlo prima che è assolutamente una via che non spunta.

 

OT: Ho letto la tua guida da 133 pagine sei un Grande :D Holy87

 

Piuttosto ho potuto appurare che si possono denominare diversamente i nomi degli oggetti, ma è tipo magia nera nel senso metaforico del termine, ovvero che

"si può fare ma è meglio non farlo" appunto per il discorso di compatibilità fra script.

 

Ora il mio intervento qui è voluto per cercare di scoprire il codice, lavorando direttamente sulle funzioni degli script standard.

Veramente, io che in quegli anni lì, cercavo e stra cercavo guide o tutorial inerenti l'rgss, spulciavo dal ruby ma senza capirci molto, proprio non riuscivo a capire che bastava semplicemente analizzare le classi di base.

 

E' da un po che mi esercito, facendo esperimenti. In questa sezione mi limiterò a spulciare gli script tradotti.

Si dice sempre che esiste da qualche parte una Pach con su gli script tradotti in italiano ma non la si trova mai.

Quindi voglio fare si che in quest'angolo del sito vi siano gli script di base analizzati uno per uno, dove gli utenti possono trarne materiale di studio. Così vedono con i loro occhi che tutto quello che gli necessità è presente sia nella tua guida Holy87 che all'interno del loro editor.

 

Senza dover girare troppo per siti o tutorial.

 

(Non vedo l'ora di arrivare a trattare i tre Game_Battler e non solo, poi mi sposterò ai Game_Character! Cioè ho scoperto cose che sono veramente fighissime e sono lì a portata di tutti.)

 

 

 

In questo momento sono impegnato con il tentare di creare un file.rxdata. L'idea è di compilare al suo interno dei nuovi archivi di riferimento.

Voi dite.. perché complicarti la vita? è già tutto là!... studio picciotti e curiosità nulla più. e questa voglia matta di rendere personale ogni mia creazione.

vediamo se ci riesco oppure niente. Io ci provo.

 

 

 

Una cosa importante. Nel caso in cui io dovessi dire castronerie col botto, correggetemi pure, io cercherò di non farle. :)

Non esiste compilare un file .rxdata, esiste creare un file ruby dumpato tramite metodo Marshal.dump (documentato nel ruby reference e nella guida di RPG Maker). In pratica non è altro che salvare un oggetto in un file. Poi l'estensione .rxdata è solo una comodità per identificare il file, ma puoi chiamarlo anche .pippo, non cambia niente.

[Lomax_Iced]

Grazie Holy lo devo imparare assolutamente :D

[Guardian of Irael]

 

Quindi voglio fare si che in quest'angolo del sito vi siano gli script di base analizzati uno per uno, dove gli utenti possono trarne materiale di studio. Così vedono con i loro occhi che tutto quello che gli necessità è presente sia nella tua guida Holy87 che all'interno del loro editor.

Rimane comunque un'ottima iniziativa dato che quella patch di traduzione non si trova e comunque qualora si trovasse tu puoi sempre mettere aggiunte personali nei vari commenti ed ampliarli.

Aspettiamo un bel po' di script, raccoglili poi comodamente nel primo post.

^ ^