Lezioni di RGSS

[Zuppo]

CORSO DI RGSS

Ereditate dall'ormai fù Campus di Rpg2s

Prefazione

All'apertura del forum Rpg2s, community nata fondendo due opposte community di making, la più importante iniziativa che ha caratterizzato il forum fù il Campus. Ovvero un luogo dove uno staff di ragazzi che avevano qualche esperienza da condividere, la mettevano a disposizione sotto forma di Scuola, con delle vere e proprie lezioni. Questa pratica andò via via scemando per assenza da ambo le parti (insegnanti e alunni), lasciando dietro se vari scrigni di "saggezza" che fino ad oggi abbiamo lasciato disponibili tra le prime sezioni del forum.
Ora, per maggiore ordine e per togliere un antico artefatto dal forum, rinnovandolo, abbiamo riproposto le stesse lezioni sottoforma di "tutorial". :3
Questo topic racchiude tutte le lezioni sulla programmazione RGSS (Prima di RpgMaker-Mv, che si è spostato su Javascript).

 

A seguire, le lezioni recuperate.

[Zuppo]

Prefazione di ProGM

Introduzione sul Ruby:
Il Ruby è un linguaggio di scripting di alto livello. Cosa significa? "Linguaggio di scripting" sarebbe a dire che non viene eseguito direttamente dal processore, ma ha bisogno di un interprete, che faccia da intermediario, evitando il processo di compilazione. Di alto livello significa che è più simile al nostro linguaggio piuttosto che a quello del processore. Ogni linguaggio di programmazione o scripting si basa sulle regole logiche, simili a quelle del cervello umano:
-"ricordare" informazioni (assegnazione e modifica di un valore ad una variabile)
- confrontare informazioni acquisite (operatori di confronto)
- dei casi (se succede questo, fai qualcos'altro, altrimenti ecc...)
e così via...
Per comunicare all'interprete quello che vogliamo abbiamo bisogno di usare una sintassi precisa (es: per farci capire da un francese, parliamo in francese, non in un'altra lingua ). La sintassi del ruby è l'inglese semplificato (più o meno), come scoprirete dalle lezioni di Alato ^^.

RGSS:
L'RGSS (Ruby Game Scripting System) è un linguaggio basato sul ruby, che non necessita dell'interprete installato (viene integrato da rpg maker), e ha uguale sintassi, ma differisce in alcune funzioni. L'RGSS ha integrati dei moduli aggiuntivi predisposti per rendere più semplice la creazione di RPG, ma non possiede alcuni moduli del ruby (come ad esempio tutti i moduli di controllo socket).

Strumenti per iniziare:
Le possibilità sono molte. Se volete impararvi per BENE il ruby (che ricordo che NON è uguale all'rgss), consiglio caldamente di farvi un giro sul sito internazionale ( http://www.ruby-lang.org/en/ ), e anche su quello italiano ( http://ruby-it.org/ ) in cui ci sono un sacco di risorse utili, tra cui anche l'interprete online, per fare piccoli esperimenti ^^
Se invece a voi interessa (come è probabile) lavorare direttamente con l'RGSS, magari direttamente sul vostro progetto, allora basterà usare la comodissima funzione "call script" (chiama script), una funzione che permette di eseguire una piccola stringa di rgss direttamente da evento. Vi consiglio di fare mooolta pratica, soprattutto con gli operatori, con i nomi delle variabili e così via.

Corso di RGSS by Alato

Lezione 1
I componenti di uno script

Questa lezione presenta le prime basi sulla struttura degli script, utile alla comprensione del Ruby Game Scripting System (RGSS),e in particolare i seguenti argomenti

• Significato e utilizzo di classe, metodo e oggetto
• Sintassi di base per creazione di classi, metodi e oggetti
• Metodi particolari

Per domande o chiarimenti, postate qui.

Corso_di_RGSS_1.doc

[Zuppo]

Corso di RGSS by Alato

 

Lezione 2
Le variabili

All'interno di ogni script, si avrà spesso a che fare con un gran numero di dati che hanno bisogno di essere archiviati. In questa lezione si tratteranno in particolare i seguenti argomenti

• Che cos'è una variabile
• Nomi delle variabili
• Utilizzo delle variabili
• Tipi di variabili

 

Per domande o chiarimenti, postate qui.

 

 

Corso_di_RGSS_2.doc

[Zuppo]

Corso di RGSS by Alato

 

Lezione 3
Istruzioni e espressioni

Il linguaggio Ruby è costituito da istruzioni, e la maggior parte di esse è costituita di espressioni e operatori. E' indispensabile capire a fondo questi tre elementi prima di poter scrivere qualsiasi script nel RGSS. In questa lezione viene spiegato quanto segue.

• Che cos'è un'istruzione
• Che cos'è un'espressione

Per domande o chiarimenti, postate qui.

 

Corso_di_RGSS_3.doc

[Zuppo]

Corso di RGSS by Alato

 

Lezione 4
Gli operatori

Gli operatori sono il perno fondamentale per comprendere pienamente il funzionamento degli script nel RGSS, e sono un argomento abbastanza ampio. Perci? hanno bisogno di un'intera lezione per essere compresi adeguatamente. In questa lezione viene spiegato quanto segue.

• Che cos'? un operatore
• Classificazione degli operatori
• Precedenza degli operatori

 

Per domande o chiarimenti, postate qui.

 

 

Corso_di_RGSS_4.doc

[Zuppo]

A seguire, degli esercizi che furono proposti agli utenti. Dato che la programmazione trae molti benefici dagli esempi e dalle esercitazioni, riporto tutti i laboratori che sono stati fatti.

Post di Alato

Allora, vediamo.
Questo è il primo abbozzo del Laboratorio, un posto in cui gli utenti possono lavorare su piccoli script proposti dall'insegnante di turno e in generale fare esercizio. Era un po' che pensavo di aprirlo ma mi mancava un argomento da cui partire: l'utilizzo degli Array!

Laboratorio di RGSS - Array e Ciclo for

Ora cercherò di darvi una breve infarinatura dei concetti di base per poter metterci subito al lavoro.

Concetti di base

"Un array (o matrice) è un gruppo di locazioni di memoria che hanno lo stesso nome e si distinguono le une dalle altre attraverso un indice" questa è la sua definizione.
Ma andiamo ad analizzarne il significato: considerando che le variabili sono etichette associate a locazioni di memoria, si capisce che gli array in pratica sono un insieme di variabili con lo stesso nome.
Per poterle distinguere l'una dall'altra si utilizza un indice che viene inserito all'interno di due parentesi quadre subito dopo il nome. L'indice parte da 0 e va aumentando.

Vediamo questo esempio:

@array[0] = 10

Che cosa abbiamo fatto? @array è un array, e abbiamo inserito il valore 10 nella suo primo elemento. Ogni elemento funziona esattamente come una qualunque variabile.
Quindi:

@array[0]

@array[1]

@array[2]

sono tutte considerabili come variabili differenti accomunate dallo stesso nome.

Probabilmente vi starete chiedendo perché bisogna utilizzarli se funzionano esattamente come le variabili: ora non è chiaro perchè abbiamo pochi elementi, ma immaginate di avvere un array con migliaia di elementi, la comoditè di poterli richiamare semplicemente tramite un indice è enorme!

Per creare un array ci sono diversi modi:

@array = []

@array = Array.new

Questi creano un array generico, insomma non sappiamo qual'è il numero di elementi e cosa contengono.
Possiamo invece scrivere:

@array = [10, 15, 20]

per ottenere un array di tre elementi che contengono rispettivamente i valori 10, 15 e 20.

Continuando sulla falsariga di quest'ultimo esempio, immaginiamo di voler stampare il contenuto dei tre elementi dell'array.

print @array[0]

print @array[1]

print @array[2]

Come vedete l'indice parte sempre da 0 e non da 1, quindi se volete richiamare il secondo elemento dell'array dovete mettere un 2 tra le quadre.

Ora pensate che ci sono comandi che permettono di fare la stessa azione 'n' volte: capirete che potrete in poche righe applicare un comando a centinaia di elementi di un array.
Uno di questi comandi, il più comodo per questo utilizzo, è il for.

@array = []

for i in 0..3

@array[i] = 10 * i

end

Analizziamo questo pezzettino di codice: il for è un ciclo che ripete l'azione contenuta tra for ed end e ad ogni giro aumenta la variabile i di 1, variabile che si può utilizzare per qualunque operazione. Questo lo fa partendo dal primo numero dopo l'in fino al numero dopo i puntini: in questo caso quindi parte da 0 e va fino a 3.
ATTENZIONE: non lasciatevi ingannare dallo zero, il ciclo viene ripetuto 4 volte e non 3 come sembrerebbe a prima vista; infatti i valori di i ad ogni giro saranno 0, 1, 2 e 3 quindi il ciclo farà 4 giri.

In questo caso è possibile fare la stessa operazione senza utilizzare for:

@array = []

@array[0] = 10 * 0

@array[1] = 10 * 1

@array[2] = 10 * 2

@array[3] = 10 * 3

In questo caso gli elementi erano solo quattro, ma se per esempio fosse stato for i in 0.. 2700 evidentemente sarebbe stato impossibile farlo senza l'utilizzo degli array e di for.


Un po' d'esercizio

Ora proviamo a fare qualcosa, cominciando da qualcosa di semplice:

Create 5 diversi array ognuno con un nome di un attributo: Forza, Destrezza, Agilita(non metteteci l'accento che non lo accetta), Intelligenza e Costituzione.
Ovviamente cercate nel limite del possibile di fare da soli, altrimenti è tempo perso. ^^

[Zuppo]

Post di Alato

 

In questo laboratorio non spiegherò nulla, o meglio, vi proporrò degli script da fare e in generale degli esercizi e se avrete problemi vi darò una mano.
Non c'è limite di gradi o quant'altro, potete partecipare tutti.

Laboratorio 1

Fai in modo che premendo il tasto Z della tastiera ( Input::A di default) venga aperta/chiusa una finestra semi-trasparente che mostra il tempo di gioco.

Soluzione:

Bon, questa è una possibile soluzione per realizzare la nostra finestra.
In Scene_Map, main:

@win_time = Window_PlayTime.new

@win_time.opacity = 180

@win_time.visible = false

[...,loop,etc,...]

@win.dispose

In Scene_Map, update:

[...]

if @win_time.visible

@win_time.update

if Input.trigger?(Input::A)

@win_time.visible = (not @win_time.visible)

Quest'ultima istruzione pone @win_time = true se è false, e viceversa.

Se l'avete letta prima di aver provato a farla siete dei puzzoni. ;O;/

 

[Zuppo]

Post di Alato

 

Questo laboratorio è stato diviso in "Esercizio base" e "Variante difficile" in modo tale da permettere anche a chi non ha mai trafficato con l'rgss di partecipare.

Laboratorio 2

Esercizio Facile
Cambia il nome dei comandi nella schermata del titolo da [Nuovo, Carica, Esci] a [Nuovo, Esci, Carica].
Se riesci inverti anche l'effetto oltre al nome (in modo che se il giocatore preme su Esci, esce, e se preme su Carica carica una partita).

Variante Difficile
Aggiungi il comando "Extra" tra Carica e Esci. Questo comando aprirà una nuova scena (Scene_Extra) in cui sarà possibile visualizzare immagini del gioco (ovviamente metti immagini a caso).
Scene_extra dovrà essere impostata in modo tale da:
- Mostrare le immagini al centro dello schermo
- Cambiare immagine premendo Destra o Sinistra
- Premendo esc si torna al menu
- Premendo invio si ottiene un effetto sonoro di errore
Se riesci fai in modo che alcune immagini siano visualizzabili e altre no, in base a ciò che viene fatto nel gioco. Per mostrare l'immagine "non visualizzabile" utilizzate un immagine fissa con scritto BLOCCATO per esempio.

Ulteriore Variante Perchihavogliadiesercitarsi?
Fare la stessa cosa della variante difficile, senza creare una nuova scena (tutto all'interno di Scene_title insomma).

 

Questa è una possibile soluzione alla Variante Difficile. Sottolineo che per ora ho ignorato la parte del "visualizzabili o no".

Cominciamo andando a inserire in Scene_Title quelle parti necessarie a richiamare Scene_Extra.
In main:

# Creazione testi

s1 = "Nuovo"

s2 = "Carica"

s3 = "Extra"

s4 = "Esci"

@command_window = Window_Command.new(164, [s1, s2, s3, s4])

In update:

if Input.trigger?(Input::C)

# I vari casi a seconda della posizione del cursore

case @command_window.index

when 0 # Nuovo Gioco

command_new_game

when 1 # Carica

command_continue

when 2 # Extra

command_extra

when 3 # Esci

command_shutdown

end

endDopo command_continue:
#--------------------------------------------------------------------------

# - Comando: Extra

#--------------------------------------------------------------------------

def command_extra

# Suona SE azione

$game_system.se_play($data_system.decision_se)

# Passa alla scena extra

$scene = Scene_Extra.new

end

E infine la nostra Scene_Extra:

#==============================================================================

# - Scene_Extra

#------------------------------------------------------------------------------

# La scena coi contenuti extra

#==============================================================================

class Scene_Extra

#--------------------------------------------------------------------------

# - Processo Principale

#--------------------------------------------------------------------------

def main

# Inizializza l'indice

@pic_index = 0

# Inizializza la picture

@picture = Sprite.new

@picture.bitmap = Bitmap.new(640,480)

@picture.x = 320

@picture.y = 240

# Fade

Graphics.transition

loop do

# Aggiornamento Grafica

Graphics.update

# Aggiornamento Input

Input.update

# Aggiornamento Frame

update

# Quando cambia la scena blocca il loop

if $scene != self

break

end

end

# Preparazione Fade

Graphics.freeze

# Eliminazione picture

@picture.dispose

end

#--------------------------------------------------------------------------

# - Aggiornamento Frame

#--------------------------------------------------------------------------

def update

# Quando SX ? premuto

if Input.repeat?(Input::LEFT)

# Se l'indice ? 0 deve ritornare

# al valore 4

if Input.trigger?(Input::LEFT) or @pic_index > 0

# Suona SE Cursore

$game_system.se_play($data_system.cursor_se)

# Riduci l'indice

@pic_index = (@pic_index - 1) % 5

return

end

end

# Quando DX ? premuto

if Input.repeat?(Input::RIGHT)

# Se l'indice ? 4 deve ritornare

# al valore 0

if Input.trigger?(Input::RIGHT) or @pic_index < 4

# Suona SE Cursore

$game_system.se_play($data_system.cursor_se)

# Aumenta l'indice

@pic_index = (@pic_index + 1) % 5

return

end

end

# Quando B ? premuto

if Input.trigger?(Input::B)

# Suona SE Annulla

$game_system.se_play($data_system.cancel_se)

# Torna alla mappa

$scene = Scene_Title.new

return

end

# Quando C ? premuto

if Input.trigger?(Input::C)

# Suona SE Azione Impossibile

$game_system.se_play($data_system.buzzer_se)

return

end

# Seleziona l'immagine

pic = @pic_index + 1

@picture.bitmap= RPG::Cache.picture(pic.to_s+".png")

# Centra l'immagine

@picture.ox = @picture.bitmap.width / 2

@picture.oy = @picture.bitmap.height / 2

@picture.update

return

end

end

Sta parte si poteva fare meglio, per esempio facendo in modo che le nuove coordinate della pic e il relativo update vengano calcolate solo quando si entra nella scena o viene cambiato l'indice.

 

 

 

[Zuppo]

.

.

.

.

Qui si conclusero le poche lezioni. Sentitevi liberi di prendere gli esercizi sul serio ed usare questo topic come deposito dei vostri esercizi.

.

.

.