[Johnny 97]

Salve a tutti! ^-^
Dopo la "Guida Basilare all'RGSS2", avrei dovuto fare la seconda parte, una guida più avanzata, ma nel frattempo è uscito un nuovo programma: RPG Maker VX Ace.
Questo nuovo RPG Maker presenta moltissime novità, fra cui l'utilizzo dell' RGSS3 invece dell' RGSS2 utilizzato in RPG Maker VX.
Tralasciando tutti i dettaglia fra le differenze del nuovo RPG Maker (d'ora in poi RPGM), oggi parleremo delle differenze fra i vari linguaggi di scripting utilizzati in RPGM, e spiegheremo meglio alcuni concetti che nella precedente guida all'RGSS2 erano stati spiegati vagamente o male, aggiungendo anche qualcosa di nuovo.
Bene, iniziamo subito!
NOTA: Se non avete letto la guida precedente, è inutile leggere questa, quindi vi consiglio di andare qui e leggere la prima parte.

DIFFERENZE FRA I VARI "RGSS":
Iniziamo mettendo in chiaro che ad ogni versione di RPGM corrisponde una diversa versione dell'RGSS.
Vediamo le corrispondenze fra le varie versioni:
RPG Maker XP: RGSS;
RPG Maker VX: RGSS2;
RPG Maker VX Ace: RGSS3.

L'RGSS2 non è altro che una versione migliorata dell'RGSS, e l'RGSS3 è una versione ancora migliore dell'RGSS, nonchè dell'RGSS2.
RGSS < RGSS2 < RGSS3.

Alla fine, le differenze fra i vari RGSS sono minime, il linguaggio è sempre lo stesso, anche se ad ogni versione viene reso più comprensibile, e vengono aggiunti/modificati alcuni comandi. Non posso spiegarvi le funzioni di tutti i comandi aggiunti/modificati nella nuova versione, poichè ci metterei secoli, ma posso elencarveli. I comandi saranno divisi per tipologia. Il prossimo mese rilascerò un'altra guida, che spiegherà uno ad uno questi comandi.

COMANDI NUOVI NELL'RGSS3:

Audio:

Codice:

-Audio.setup_midi
-Audio.bgm_play(filename[, volume[, pitch[, pos]]])
-Audio.bgm_pos
-Audio.bgs_play(filename[, volume[, pitch[, pos]]])
-Audio.bgs_pos

Colore:

Codice:

-Color.new
-set(color)

Font:

Codice:

-outline
-out_color
-default_outline
-default_out_color

Grafica:

Codice:

-Graphics.play_movie(filename)

Input:

Codice:

-Input.press?(sym)
-Input.trigger?(sym)
-Input.repeat?(sym)

Rect:

Codice:

-Rect.new
-set(rect)

Funzioni Built-In RGSS:

Codice:

-rgss_main { ... }
-rgss_stop
-msgbox(arg[, ...])
-msgbox_p(obj, [obj2, ...])

BGM:

Codice:

-play([pos])
-replay

BGS:

Codice:

-play([pos])-replay

Tilemap:

Codice:

-flags

Tonalità Colore:

Codice:

-Tone.new
-set(tone)

Viewport:

Codice:

-Viewport.new

Finestra:

Codice:

-Window.new([x, y, width, height])
-move(x, y, width, height)
-open?
-close?
-arrows_visible
-padding
-padding_bottom
-tone

Passiamo adesso allo scripting! Le cose scritte da adesso in poi, saranno applicabili più o meno in tutti e tre i linguaggi RGSS.
Nella precedente guida abbiamo spiegato:

Codice:

-Classi
-Commenti
-Condizioni con If
-Variabili
-Switch

Quel che andremo a spiegare adesso, sarà un po' più complicato, ma non preoccupatevi! Ho detto UN PO' xD Sono sempre accenni basilari...
Gli argomenti di questa guida saranno:

Codice:

-Avviare uno script da evento
-Moduli
-Method Definitions (che avevo tentato di spiegare nella guida precedente)
-Attributi
-Condizioni con Unless e Case
-Strutture Loop

Questi sei punti rappresentano gli ultimi punti della guida basilare. In seguito farò una guida più avanzata su vari comandi dell'RGSS.

CHIAMARE UNO SCRIPT:
Iniziamo con una cosa tanto semplice quanto utile che non ho spiegato nella precedente guida (non so perchè O.o)
Quando abbiamo bisogno che uno script si avvii soltanto in uno specifico momento del gioco, ad esempio quando tocchiamo un evento, dobbiamo usare il "call script". Il call script è l'ultima opzione della terza finestra della lista dei comandi degli eventi. Cliccando sul tasto "Script" si aprirà una finestra dove potrete scrivere un mini-script, oppure richiamarne uno già esistente.
In base allo script e alle vostre esigenze ci sono diversi modi di richiamare uno script. Di seguito elenco 3 dei metodi più importanti e di uso più comune:

1- Richiamare uno script per intero.
Se ad esempio volete che appena il giocatore tocchi l'evento X, il gioco legga uno script per intero basta inserire questo codice nel Call Script:

Codice:

NomeClasse.new

Dove NomeClasse sta per il nome che avete dato alla classe dello script che volete chiamare.

2- Richiamare una parte dello script.
Se volete chiamare soltanto una parte del vostro script, serve che quella parte sia contenuta all'interno di una Method Definition (poi capirete cosa sono le Method Definitions).
Allora, facciamo come prima, ma aggiungendo una parte nel Call Script:

Codice:

NomeClasse.NomeMethod.new

Dove NomeClasse sta per il nome della classe dello script e NomeMethod sta per il nome della Method Definition. Ovviamente, è necessario che la Method Definition sia contenuta all'interno della classe che avete scritto in NomeClasse.
Quando leggerete la parte di questa guida dedicata alle Method Definitions, vi accorgerete che spesso non serve applicare questo metodo di richiamo, e basta semplicemente richiamare lo script per intero.

3- Richiamare una Scena:
Partiamo spiegando cosa sono le Scene. Ogni cosa nel gioco è una Scena. Per farvi degli esempi, quando premete ESC o X in gioco, si apre il menù. Il menù è una scena. Oppure quando incontrate un mostro e si apre la schermata di battaglia, anche quella è una scena. Anche quando camminate nella mappa, è una scena. Il gioco come potete notare, apre una scena alla volta, e questa scena aperta è gestita dalla variabile globale $scene. Dunque, se il nostro script è una scena, e vogliamo richiamare questa scena nel gioco, dobbiamo assegnare alla variabile $scene il valore del nome della nostra classe, seguito da .new. Quindi basta inserire questo nell Call Script:

Codice:

$scene = NomeClasse.new

Se volete iniziare a creare script, tenete bene a mente questi codici scritti sopra, perchè vi serviranno!
Ricordate inoltre che tramite il Call Script (la finestra dove avete inserito i codici di qui sopra), potrete settare varibili globali e tanto altro!

I MODULI:
Con "Modulo" si intende un raggruppamento di varie variabili, messe tutte insieme per creare più ordine e rendere lo script personalizzabile nel modo più facile per chi userà lo script. Se non avete capito, non preoccupatevi, continuate a leggere e capirete!
Innanzitutto, un Modulo deve essere dichiarato prima di ogni classe.
Come per le classi, prima di scrivere il nome proprio del Modulo, bisonga inserire una parola chiave: "module".
Dunque se vogliamo dichiarare un modulo chiamato "Guida" scriviamo così:

Codice:

module Guida

Ricordate che, come per le classi, il nome di un Modulo DEVE iniziare con una lettera maiuscola. Inoltre il nome NON può contenere spazi, ma PUO' contenere underscore ("_"). Sempre allo stesso modo delle classi, i moduli terminano con il comando "end".

Nei moduli, vanno dichiarati variabili e switch che ci serviranno all'interno dello script. Vediamo allora come utilizzare una variabile che abbiamo dichiarato nel nostro Modulo Guida.
Se avete letto la guida precedente, dovreste sapere come si dichiara una variabile locale, quindi dichiarate una variabile chiamandola "Esempio" e dandole il valore "Hello World".
Terminate il Modulo e create una classe "Ciao". Sotto questa classe create una Method Definition (continuando a leggere questa guida capirete cosa sono, al momento seguite soltanto le istruzioni), scrivendo "def initialize". Sotto "def initialize" scrivete "print". Il comando print serve ad aprire una finestra con un messaggio di avviso. In questo caso il nostro messaggio di avviso sarà quello che abbiamo scritto nella variabile Esempio, quindi scrivete accanto a print "Guida::Esempio".
Analizziamo quest'ultima riga che abbiamo scritto:

Codice:

print Guida::Esempio

Come abbiamo detto prima, il comando print crea una finestra di avviso con il messaggio che impostiamo. Accanto a print, và scritto il messaggio che vogliamo mostrare, tra virgolette. Le virgolette, servono a indicare che stiamo scrivendo una stringa, cioè un testo. Siccome la nostra variabile Esempio è una stringa da sè, non abbiamo bisogno delle virgolette. Dunque mettiamo scriviamo accanto a print il nome del nostro mudulo seguito da :: e poi il nome della variabile che vogliamo utilizzare.

Chiudete adesso la classe e la Method Definition con due "end"
Ecco qui lo script completo:

Codice:

module Guida
Esempio = "Hello World!"
end

class Ciao
def initialize
print Guida::Esempio
end
end

Create adesso un evento parallelo nel vostro progetto e richiamate lo script per intero, come spiegato nel precedente paragrafo. Avviate il gioco, andate nella mappa in cui avete posizionato l'evento e apparirà una piccola finestra con scritto "Hello World!" e un pulsante OK. Premendo il pulsante OK otterrete un errore, ma non preoccupatevi, lo scopo di questo script era riuscire ad utilizzare la variabile di un modulo, e se nella finestra ci sarà scritto ciò che avete impostato nella variabile, ci siete riusciti!

LE METHOD DEFINITIONS:
Eccoci arrivati alla parte di script che odio tanto quanto è utile: le Method Definitions.
Nella guida precedente avevo tentato di spiegare questa parte, ma senza ottimi risultati. Adesso che ho capito il meccanismo, mi trovo a riespiegare quest'argomento!
Come dovreste sapere, una classe è un grande gruppo che racchiude tutto il codice di uno script. Se conoscete altri linguaggi, sappiate che le Method Definitions nell' RGSS corrispondono alle "funzioni" di altri linguaggi. Le Method Definitions, sono invece dei sottogruppi, per rendere lo script più ordinato o più facilmente configurabile. Ricordate che una Method Definition, dipende dal nome, può svolgere dei ruoli fondamentali, oltre a fare da sottogruppo!
Dopo vedremo quattro di queste funzioni, adesso passiamo a spiegare come aprire una Method Definition. Semplice!
Basta scrivere il nome della Method Definition dopo la parola "def". Come ogni altro blocco, si chiude con "end".

Codice:

def esempio
end

NOTA: Il nome di una Method Definition DEVE iniziare con una lettera MINUSCOLA e NON può contenere spazi.

Passiamo alle funzioni di una Method Definition, oltre a fungere da sottogruppo.
Dovete sapere, che ci sono delle "parole riservate", chiamate "Methods", con cui è possibile chiamare una Method Definition. Queste parole se assegnate come nomi, svolgono delle "funzioni speciali". Lo capirete meglio continuando a leggere.
Ecco una lista delle Methods più comuni e la loro funzione:
"initialize": Inizializza variabili ecc...
"main": Viene ripetuto all'infinito finchè non decidiamo noi di fermarlo con altri metodi. Viene spesso utilizzato per creare finestre e scene.
"refresh" e "update": Aggiornano la def "main".
"dispose": Cancella ciò che è successo prima (utile quindi per fermare la def "main").

Andiamo ora a completare le Method Definitions, e vediamo qual è la loro definizione.
Una Method Definition è un blocco che ritorna valori. Ad esempio, chiamiamo una def "esempio". Accanto al nome della def scrivete tra parentesi tutti i valori che volete, separati da virgole.

Codice:

def esempio (valore1, valore2, valore3...)
end

Ad essere sincero non ho ancora capito l'utilità di questa cosa, cioè utilizzare def che ritornino valori, quindi non posso farvi alcun esempio pratico xD

Non abbiamo ancora finito con le Method Definitions!! Vi tornerà sicuramente utile, dover avviare una Method Definition una volta che ne sia finita una! Mi spiego meglio con un esempio:

Codice:

class Ciao
def initialize
@variabile = "Hello World!"
end

def esempio
print variabile
end
end

Come potrete notare avviando lo script per intero, non succederà niente di visibile, perchè il comando print si trova in una def che non viene avviata dallo script! L'unica cosa che otterrete avviando questo script per intero sarà quella di aver dato alla variabile "variabile" il valore di "Hello World!". Allora aggiungiamo una riga di codice alla fine del primo def (il def initialize), quindi sotto la riga "@variabile = "Hello World!"", lo stesso nome che abbiamo dato alla nostra def da richiamare.

Codice:

class Ciao
def initialize
@variabile = "Hello World!"
esempio
end

def esempio
print variabile
end
end

Come potrete notare, questa volta su schermo è apparsa una finestra con scritto il messaggio della variabile da noi impostata! Inoltre, se c'avete fatto caso, dopo aver premuto OK nella finestra non abbiamo ottenuto l'errore che abbiamo ottenuto nello script del primo capitolo di questa guida, da questo deduciamo che il comando print non va inserito nel def initialize, dunque inserire il print in un def a parte come abbiamo appena fatto è un buon metodo per far apparire finestre senza ottenere errori. Il Call Methods (cioè richiamare Method Definitions come abbiamo appena fatto) può essere utile per altre cose, ad esempio, quando vi capiterà di dover usare lo stesso codice per più def, vi bastera mettere il codice uguale in una def a parte per poi richiamarlo! Capirete quando vi servirà xD

GLI ATTRIBUTI:
Gli Attributi stanno alla base delle variabili. Quello degli Attributi è un concetto facile da capire e spiegare: con gli attributi possiamo rendere una variabile modificabile, oppure di sola lettura. Gli attributi vanno creati prima di ogni Method Definition e dentro la classe.
La stringa che costituisce un attributo si può dividere in tre parti:
-attr_ è il prefisso, va inserito prima di ogni attributo.
-accessor/reader il tipo di attributo da impostare. "accessor" permette la lettura e la scrittura della variabile, mentre reader non permette la modifica della variabile ma ne permette la lettura.
-: nomevariabile il nome della variabile a cui dare l'attributo, dove "nomevariabile" è il nome della variabile.

Facciamo degli esempi:

Codice:

class Ciao
attr_accessor: prima #questa variabile sarà modificabile e leggibile
attr_reader: seconda #questa variabile sarà leggibile ma non modificabile
def esempio
#qualcosa
end
end

Vi ricordo che la parte di codice dopo # è un commento e non verrà letto dall'Interpreter. (Dovreste saperlo se avete letto la prima guida.)
Se dovete utilizzare una varibile importata, cioè una variabile locale o di istanza presa da un'altro script (Come al solito, per utilizzare una variabile locale o variabile di istanza di un altro script, leggere la guida precedente.) vi servirà impostare gli attributi. Esempio:

Codice:

class Principale
def initialize
variabile = 1
end
end

Codice:

class Secondaria < Principale
attr_accessor: variabile
def initialize
variabile + 1
end
end

CONDIZIONI CON UNLESS E CASE:
Nella guida precedente abbiamo visto come creare delle condizioni con if.
Per chi se lo fosse dimenticato, questa è la sintassi:

Codice:

if @var = true #se la switch @var è ON
@var = false #la switch @var diventa OFF
else #se la switch @var non è ON
print "var è già OFF!" #crea un messaggio con scritto "var è già OFF!"
end #termina la condizione

Nella prima guida però, non ho spiegato un altra struttura della condizione If. Ecco come può essere strutturata:

Codice:

print "Switch ON" if @var == true

In questo caso, crea un messaggio con scritto "switch ON if @var == true". Quindi

Codice:

if @var == true
print "Switch ON"
end

e

Codice:

print "Switch ON" if @var == true

sono la stessa cosa!

Vediamo adesso la sintassi e le funzioni di altri due tipi di Condizioni: Unless e Case. Iniziamo con Unless:
La parola inglese "Unless" significa "A meno che". Dopo questa affermazione, spero abbiate intuito cosa fa questa condizione! Esaminiamo la sintassi, così da spiegare meglio Unless con degli esempi:

Codice:

unless @var == false #A meno che @var sia OFF
print "Switch ON" #Crea un messaggio con scritto "Switch ON"
else #Altrimenti
print "Switch OFF" #Crea un messaggio con scritto "Switch OFF"
end #Termina condizione

Come avrete potuto notare, Unless è l'esatto contrario di If, quindi Unless è anche traducibile con "Se...non". Come nella struttura di If, la parte "else" è facoltativa, quindi un altra condizione potrebbe essere questa:

Codice:

unless @var == false #Se @var non è OFF
print "Switch ON" #Crea un messaggio con scritto "Switch ON"
end #Termina la condizione

Sempre allo stesso modo di If, per Unless c'è un'altra struttura:

Codice:

print "Switch ON" unless @var == false
#Crea un messaggio con scritto "Switch ON" se @var non è OFF.

Ricordate quindi che scrivere

Codice:

unless @var == false
print "Switch ON"
end

o scrivere

Codice:

print "Switch ON" unless @var == false

è la stessa cosa!

Paragonando If a Unless, possiamo dire che:
Scrivere

Codice:

if @var == true
print "Switch ON"
end

o scrivere

Codice:

unless @var == false
print "Switch ON"
end

è la stessa cosa.

Passiamo adesso alla condizione Case. La parola "Case" è traducibile con varie parole, in questo caso credo che la più adatta sia "Processo".
La condizione Case, considera diverse condizioni, ed esegue un'azione diversa per ogni diversa condizione avverata. Ovviamente si può avverare una condizione alla volta! Questo tipo di condizioni, saranno molto utili nei menù, infatti se cercate nello script del menù di base del gioco troverete una condizione Case che controlla quale pulsante è premuto.
Passiamo a vedere la sintassi e spiegare la condizione, perchè non l'ho definito chiaramente questo tipo di condizione:

Codice:

case @var #Analizza la variabile @var
when nil #Quando la variabile è nulla, cioè non le è stato assegnato alcun valore
print "Valore non assegnato" #Stampa "Valore non assegnato"
when 1 #Quando il valore della variabile è 1
print "Valore = 1." #Stampa "Valore = 1."
when 2 .. 5 #Quando il valore della variabile va da 2 a 5 (2, 3, 4, 5)
print "Valore da 2 a 5." #Stampa "Valore da 2 a 5."
else #Altrimenti (Quindi se nessuna delle precedenti condizioni si avvera)
print "Valore minore di 1 o maggiore di 5." #Stampa "Valore minore di 1 o maggiore di 5."
end

Con la condizione Case potete sbizzarrirvi quanto volete! Allenatevi creando condizioni complesse mixando fra loro le varie condizioni, e settando variabili globali dal Call Script! Per concludere questo capitolo, la condizione Case, al contrario di If e Unless non ha strutture alternative, ma ne ha una soltanto.

I LOOP:
Eccoci arrivati all'ultimo capitolo di questa quida basilare agli RGSS: I Loop. Un Loop, è un blocco di codice che si ripete finchè una determinata condizione non si avvera. Come sempre, se non avete capito, capirete meglio con gli esempi dopo, al momento lasciatemi spiegare.
Esistono vari tipi di Loop, e ogni tipo ha una diversa utilità, andiamo ad elencare i vari Loop!
-While: esegue dei comandi finchè la condizione è vera.
-Until: come While, esegue dei comandi finche la condizione è vera.
-For: esegue dei comandi per ogni elemento uguale in diverse variabili.

Creare un Loop può servire tanto quanto interromperlo, per questo ci sono i comandi "break" e "next".
Facciamo adesso degli esempi per vedere come utilizzare i vari Loop e i vari comandi per fermare i Loop.

Codice:

while @var == true #Finchè la switch @var è ON
@var2 + 1 #Aggiunge 1 alla variabile @var2
end #fine del blocco Loop (In questo caso end non blocca il Loop, ma serve a terminare la lista dei comandi da eseguire durante il Loop.)

Codice:

unless @var == true #Finchè la switch @var è ON
@var2 + 1 #Aggiunge 1 alla variabile @var2
end #fine del blocco Loop (In questo caso end non blocca il Loop, ma serve a terminare la lista dei comandi da eseguire durante il Loop.)

(Come avrete notato, Unless e While sono praticamente uguali.)

Codice:

for i in [1, 2, 3]
print i*2
end

(Quest'esempio l'ho preso dalla documentazione ufficiale, in quanto non so come applicare il Loop for.)

Prendiamo adesso un esempio precedente e vediamo come interrompere un Loop quando si avvera una condizione:

Codice:

while @var == true #Finchè la switch @var è ON
@var2 + 1 #Aggiunge 1 alla variabile @var2
break if @var2 == 30 #Interrompe il Loop se la variabile @var2 ha valore 30.
end #fine del blocco Loop (In questo caso end non blocca il Loop, ma serve a terminare la lista dei comandi da eseguire durante il Loop.)

Come avrete notato, non ho utilizzato la struttura classica della condizione if nella riga "break if @var2 == 30", ma ho utilizzato la struttura lineare. Questo perchè appunto, la struttura è più lineare, e sebbene l'altra struttura sia più ordinata, questa mi permette di risparmiare spazio, e dentro un Loop risulta più ordinata.
Comunque sia, scrivere

Codice:

while @var == true #Finchè la switch @var è ON
@var2 + 1
if @var2 == 30
break
end
end

non è errato, ma è molto più confusionario come Loop.

Dunque, per questa guida è tutto, se avete domande di qualsiasi genere create un nuovo topic nella sezione adatta, se avete gradito la mia guida registratevi (se non l'avete ancora fatto) e cliccate sul pulsante "THANKYOU" qui sotto, e se avete dubbi riguardanti la mia guida, rispondete in questo topic!