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. ^^
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].
Modificato da Marigno, 15 December 2007 - 15:29 PM.
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. ^^
Visto che alterno periodi di pausa a quelli attivi, ecco il mio log: 12/02/2009= SALTUARIAMENTE sul forum, rpg maker xp= OFF 7/01/2009= PRESENTE sul forum, rpg maker xp=ON 30/12/08=PRESENTE sul forum, rpg maker xp=OFF
Frasi Epiche:
Non sono nato Ronaldinho ma con la tenacia ho toccato il cielo. By Filippo Inzaghi
And when we were good you just closed your eyes, so when we are bad we're going to scar your minds. By Marilyn Manson
Traduzione: E quando eravamo buoni avete chiuso gli occhi, così quando saremo cattivi procureremo cicatrici alle vostre menti.
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
Spoiler
#==============================================================================
# ** 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?
Spoiler
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?
Spoiler
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
Spoiler
#==============================================================================
# ** 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?
Spoiler
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:
Spoiler
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?
Spoiler
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
Spoiler
#==============================================================================
# ** 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?
Spoiler
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?
Spoiler
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
Spoiler
#==============================================================================
# ** 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?
Spoiler
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 [/spoiler]
(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.
Modificato da Lomax_Iced, 11 August 2015 - 09:36 AM.
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.
🖤 E:3 by Testament (notare dettaglio in basso a destra)! E:3 by Idriu E:3
Membro Onorario, Ambasciatore dei Coniglietti (Membro n.44)
Ufficiale "Ad opera della sua onestà e del suo completo appoggio alla causa dei Panda, Guardian Of Irael viene ufficialmente considerato un Membro portante del Partito, e Ambasciatore del suo Popolo presso di noi"
<- Grazie Testament E:3 Ricorda...se rivolgi il tuo sguardo ^ ^ a Guardian anche Guardian volge il suo sguardo ^ ^ a te ^ ^ by Flame ^ ^
Grazie Testament XD Fan n°1 ufficiale di PQ! :D
Viva
il Rhaxen! <- Folletto te lo avevo detto (fa pure rima) che non
avevo programmi di grafica per fare un banner su questo pc XD (ora ho di
nuovo il mio PC veramente :D)
Rosso Guardiano della
Rpg2s RPG BY FORUM:
Spoiler
Nome: Darth Reveal
PV totali 2 PA totali 16
Descrizione: ragazzo dai lunghi capelli rossi ed occhi dello stesso colore. Indossa una elegante giacca rossa sopra ad una maglietta nera. Porta pantaloni rossi larghi, una cintura nera e degli stivali dello stesso colore. E' solito trasportare lo spadone dietro la schiena in un fodero apposito. Ha un pendente al collo e tiene ben legato un pezzo di stoffa (che gli sta particolarmente a cuore) intorno al braccio sinistro sotto la giacca, copre una cicatrice.
Bozze vesti non definitive qui.
Equipaggiamento:
Indossa:
60$ e 59$ divisi in due tasche interne
Levaitan
Spada a due mani elsa lunga
Guanti del Defender (2PA)
Anello del linguaggio animale (diventato del Richiamo)
Scrinieri da lanciere (2 PA)
Elmo del Leone (5 PA)
Corazza del Leone in Ferro Corrazzato (7 PA)
ZAINO (20) contenente:
Portamonete in pelle di cinghiale contenente: 100$
Scatola Sanitaria Sigillata (può contenere e tenere al sicuro fino a 4 oggetti curativi) (contiene Benda di pronto soccorso x3, Pozione di cura)
Corda
Bottiglia di idromele
Forma di formaggio
Torcia (serve ad illuminare, dura tre settori)
Fiasca di ceramica con Giglio Amaro (Dona +1PN e Velocità all'utilizzatore)
Ampolla Bianca
Semi di Balissa
CAVALLO NORMALE + SELLA (30 +2 armi) contentente:
66$
Benda di pronto soccorso x3
Spada a due mani
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
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.
🖤 E:3 by Testament (notare dettaglio in basso a destra)! E:3 by Idriu E:3
Membro Onorario, Ambasciatore dei Coniglietti (Membro n.44)
Ufficiale "Ad opera della sua onestà e del suo completo appoggio alla causa dei Panda, Guardian Of Irael viene ufficialmente considerato un Membro portante del Partito, e Ambasciatore del suo Popolo presso di noi"
<- Grazie Testament E:3 Ricorda...se rivolgi il tuo sguardo ^ ^ a Guardian anche Guardian volge il suo sguardo ^ ^ a te ^ ^ by Flame ^ ^
Grazie Testament XD Fan n°1 ufficiale di PQ! :D
Viva
il Rhaxen! <- Folletto te lo avevo detto (fa pure rima) che non
avevo programmi di grafica per fare un banner su questo pc XD (ora ho di
nuovo il mio PC veramente :D)
Rosso Guardiano della
Rpg2s RPG BY FORUM:
Spoiler
Nome: Darth Reveal
PV totali 2 PA totali 16
Descrizione: ragazzo dai lunghi capelli rossi ed occhi dello stesso colore. Indossa una elegante giacca rossa sopra ad una maglietta nera. Porta pantaloni rossi larghi, una cintura nera e degli stivali dello stesso colore. E' solito trasportare lo spadone dietro la schiena in un fodero apposito. Ha un pendente al collo e tiene ben legato un pezzo di stoffa (che gli sta particolarmente a cuore) intorno al braccio sinistro sotto la giacca, copre una cicatrice.
Bozze vesti non definitive qui.
Equipaggiamento:
Indossa:
60$ e 59$ divisi in due tasche interne
Levaitan
Spada a due mani elsa lunga
Guanti del Defender (2PA)
Anello del linguaggio animale (diventato del Richiamo)
Scrinieri da lanciere (2 PA)
Elmo del Leone (5 PA)
Corazza del Leone in Ferro Corrazzato (7 PA)
ZAINO (20) contenente:
Portamonete in pelle di cinghiale contenente: 100$
Scatola Sanitaria Sigillata (può contenere e tenere al sicuro fino a 4 oggetti curativi) (contiene Benda di pronto soccorso x3, Pozione di cura)
Corda
Bottiglia di idromele
Forma di formaggio
Torcia (serve ad illuminare, dura tre settori)
Fiasca di ceramica con Giglio Amaro (Dona +1PN e Velocità all'utilizzatore)
Ampolla Bianca
Semi di Balissa
CAVALLO NORMALE + SELLA (30 +2 armi) contentente:
66$
Benda di pronto soccorso x3
Spada a due mani