Aiuto per imparare l'RGSS 4

[nihil-omen]

Io li fo tutti venerdì che fino a giovedì sto incasinatissimo >.<
Però poi partecipo volentieri ^^

[mikb89]

Mi sono deciso (finalmente) a postare l'ultimo passo di questo simil-corso di ruby base. Credo proprio che non continuerò, vedendo quanto tempo mi è stato necessario prima di scrivere questa parte, ma chissà, intanto posto questa.

Passo 6: Moduli, classi, funzioni

Moduli, classi e funzioni servono per ordinare il codice, per rendere più facile il suo utilizzo e le modifiche e comunque per fare cose altrimenti impossibili in altri modi.
Iniziamo dai moduli.
I moduli sono forse la cosa meno usata dei tre, ma non per questo sono inutili. La definizione a script è semplicemente questa:

<div class="de1"><span class="kw1">module</span> Qualcosa</div><div class="de1"><span class="br0">[</span>codice<span class="br0">]</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

L'unica regola è che il nome del modulo deve iniziare per maiuscola. All'interno del modulo possono andare le costanti (prime lezioni, ecco un buon posto dove usarle) usate per impostazioni (se guardate i vari script credo sarà facile che troviate dei moduli con delle costanti dentro come configurazioni), le classi (che vedremo di seguito), le funzioni (che vedremo anch'esse). Variabili che non sono costanti le potete mettere pure (quelle vanno ovunque) anche se di solito non si fa.
Un'importante funzione dei moduli è quella di modifica di script creati. Cioè quando si fa una patch per qualche script da applicare sotto allo script stesso. Si può ottenere per aliasing, per riscrittura, per aggiunta o coi moduli. Le vedremo tutte a suo tempo e infine approfondiremo.
Perchè usare i moduli?
- per inserire configurazioni degli script;
- per modificare script rgss che hanno già un modulo (RPG, Math);
- per modificare script creati con patch;
- per fare l'esercizio di questo passo :).
Una volta che un modulo è creato, da una funzione, per aver accesso alle costanti, si usano i doppi due punti. Faccio un esempio direttamente a codice:

<div class="de1"><span class="kw1">module</span> Impostazioni</div><div class="de1">Scorrimento_Veloce = <span class="kw2">false</span> <span class="co1"># non lo so, è la prima cosa che mi è venuta in mente</span></div><div class="de1"><span class="kw1">end</span></div><div class="de1"> </div><div class="de1"><span class="kw1">def</span> imposta_scorrimento</div><div class="de1"><span class="kw1">if</span> <span class="re2">Impostazioni::Scorrimento_Veloce</span> == <span class="kw2">false</span></div><div class="de1"><span class="re1">@scorrimento</span> = <span class="nu0">0</span></div><div class="de1"><span class="kw1">else</span></div><div class="de1"><span class="re1">@scorrimento</span> = <span class="nu0">1</span></div><div class="de1"><span class="kw1">end</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

Ecco, non fate molto caso a quello che non abbiamo ancora fatto, ma osservate come il modulo è stato chiamato: Impostazioni::Scorrimento_Veloce.
Ossia, NomeModulo::Costante. Se invece avessimo avuto una funzione dentro, per chiamarla avremmo usato semplicemente il punto: NomeModulo.Funzione.

Passiamo ora alle classi. Le classi sono le più importanti per indispensabilità (cioè delle funzioni si può fare a meno, ma delle classi difficilmente). Ne sono esempi gli Scene_QualsiasiCosa, i Game_Qualcosa e in genere tutto, per il fatto che il ruby sia orientato agli oggetti. Questo significa che ogni classe è un oggetto con le sue capacità e caratteristiche. Si parte da

<div class="de1"><span class="kw1">class</span> Esempio</div><div class="de1"> </div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

per poi rifinire di questo oggetto tutto quello che ci serve. Una Window ad esempio avrà la funzione visible per impostare se si vede o no, un oggetto evento avrà la funzione per cancellarlo e così via. Quindi se dovete creare un oggetto, fatelo con class (nessun doppio significato). Per impostare poi le caratteristiche e capacità di questo oggetto utilizziamo le variabili e le funzioni (def). Le variabili vanno create dentro le def (funzioni) e devono essere precedute da @ (o doppia @), dopodichè non saranno nè leggibili, nè modificabili. Per renderli tali infatti si usa una sintassi apposta.

<div class="de1"><span class="kw1">class</span> Esempio</div><div class="de1">attr_accessor <span class="re3">:valore1</span></div><div class="de1">attr_reader <span class="re3">:valore2</span></div><div class="de1">attr_writer <span class="re3">:valore3</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

Questi sono i tre casi. All'interno della class le variabili si trovano con la @ (o doppia @), mentre dopo l'attr_, le @ vanno sostituite con :. Quindi i : sono attaccati al nome della variabile e non all'attr_, nè lasciati staccati da entrambi.
Vediamo cosa fanno. Con questo codice, valore1 potrà essere letto e scritto, valore2 potrà essere soltanto letto e valore3 soltanto scritto (quest'ultimo caso è rarissimo). Con le funzioni vedremo un altro modo di ottenere la stessa cosa (anche un pò più avanzata) senza usare l'attr_. Un'altra cosa da dire sulle classi è la superclasse.
Faccio un esempio preso dall'rgss:

<div class="de1"><span class="kw1">class</span> Window_SaveFile <span class="sy0"><</span> Window_Base</div></div></td></tr></table>

La classe Window_Base contiene già abbastanza specifiche di una window, quindi nell'andare a creare una Window_SaveFile, il programmatore con questa sintassi ha fatto in modo che la sua classe ereditasse tutto quello che la superclasse (che si scrive dopo il <) contiene senza bisogno di andarlo a riscrivere. Vediamo un approfondimento, ma prima parliamo delle funzioni.

Una funzione si crea scrivendo:

<div class="de1"><span class="kw1">def</span> funzione</div><div class="de1"><span class="br0">[</span>codice<span class="br0">]</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

I suoi utilizzi sono quelli di racchiudere codice usato spesso per non riscriverlo più volte e alcune funzioni di 'supporto' alla classe, che andiamo subito a vedere. Abbiamo parlato delle superclassi. Facciamo un esempio:

<div class="de1"><span class="kw1">class</span> SuperClasse</div><div class="de1"><span class="kw1">def</span> scrittura_valore</div><div class="de1"><span class="kw3">p</span> <span class="re1">@valore</span></div><div class="de1"><span class="kw1">end</span></div><div class="de1"><span class="kw1">def</span> aggiunta_valore</div><div class="de1"><span class="re1">@valore</span> <span class="sy0">+</span>= <span class="nu0">1</span></div><div class="de1"><span class="kw1">end</span></div><div class="de1"><span class="kw1">end</span></div><div class="de1"> </div><div class="de1"><span class="kw1">class</span> ClasseDerivata <span class="sy0"><</span> SuperClasse</div><div class="de1"><span class="kw1">def</span> aggiunta_valore</div><div class="de1"><span class="kw1">super</span></div><div class="de1">scrittura_valore</div><div class="de1"><span class="kw1">end</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

Esaminiamo il codice. Intanto è ovvio che la variabile @valore deve essere stata creata e impostata a qualcosa di numerico prima di aggiungere 1, ma non ci interessa. Quello che abbiamo fatto insomma nella classe figlia, è far vedere il valore dopo averlo modificato, una roba inutile, ma utile per capire. Nella superclasse abbiamo una funzione che aggiunge e una che mostra. La funzione che mostra, quindi, pur non essendo stata specificata nella classe figlia, può essere usata. La funzione che aggiunge invece è stata modificata, e quella parolina, super, serve semplicemente a richiamare la funzione originaria della funzione (scusate il gioco di parole) e quindi @valore += 1. Il super poteva essere messo ovunque nella def.
Prima di vedere quell'altra cosa lasciata in sospeso (degli attr_, ricordate?) andiamo a vedere come funziona il passaggio di valori fra le def. Una cosa importante delle def infatti, è quella di poter prendere un valore e restituirne un altro. Vediamo intanto come si scrive:

<div class="de1"><span class="kw1">def</span> somma<span class="br0">(</span>valore1, valore2 = <span class="nu0">1</span><span class="br0">)</span></div><div class="de1">a = valore1 <span class="sy0">+</span> valore2</div><div class="de1"><span class="kw2">return</span> a</div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

Le parentesi dopo il nome contengono i valori che prende la funzione. Vediamo che valore2 è impostato uguale a 1. Questo significa che, se non si passa alcun valore, la variabile (perchè valore1 e valore2 sono variabili utilizzabili nell'ambito della def) rimarrà 1, altrimenti assumerà il valore che gli date. La parolina return, invece, seguita da qualcosa, darà quel valore alla funzione. Ovviamente è facoltativo. Questa funzione va utilizzata così:

<div class="de1"><span class="kw3">p</span> somma<span class="br0">(</span><span class="nu0">5</span>, <span class="nu0">6</span><span class="br0">)</span></div></div></td></tr></table>

Sappiamo che p mostra a schermo una variabile. In questo modo la funzione è come se fosse una variabile, che contiene quello che dice il return. (5, 6) invece sono i valori che andranno a contenere le variabili valore1 e valore2 all'interno della def. Questi valori possono essere più di due e possono essere sia facoltativi (con l'=), sia obbligatori (specificando solo il nome). In genere si mettono prima quelli obbligatori e alla fine quelli facoltativi.
Torniamo quindi alla gestione degli attr_ di una classe.
Supponiamo (senza codice) che una classe abbia l'attributo (variabile, caratteristica, come volete chiamarla) nome. Questo attributo deve essere modificabile, e la cosa è fattibile con attr_. Se però dobbiamo fare in modo che una volta modificato, sia necessario aggiornare la classe (per riscriverlo ad esempio), gli attr_ non bastano. Possiamo sì fare un ciclo che controlla se il vecchio nome è diverso dal nuovo e in tal caso aggiorna la classe, però noi prendiamo in esame la cosa con le funzioni.
Una volta creata la classe, i suoi attributi e le sue funzioni sono raggiungibili tramite il punto (classe.attributo, classe.funzione) e, nel caso dell'attributo, utilizzeremo classe.attributo = valore o valore = classe.attributo a seconda che vogliamo scriverlo o leggerlo. Data la somiglianza con l'utilizzo delle funzioni, possiamo sostiutire la variabile con esse. Faccio il confronto:

<div class="de1"><span class="kw1">class</span> Esempio</div><div class="de1">attr_accessor <span class="re3">:nome</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

<div class="de1"><span class="kw1">class</span> Esempio</div><div class="de1"><span class="kw1">def</span> nome=<span class="br0">(</span>valore<span class="br0">)</span></div><div class="de1"><span class="re1">@nome</span> = valore</div><div class="de1">aggiorna_classe</div><div class="de1"><span class="kw1">end</span></div><div class="de1"><span class="kw1">def</span> nome</div><div class="de1"><span class="kw2">return</span> <span class="re1">@nome</span></div><div class="de1"><span class="kw1">end</span></div><div class="de1"><span class="kw1">end</span></div></div></td></tr></table>

Vedrete che il secondo è più lunghetto, ma non ho riportato per intero il codice del primo perchè non ci interessa. Da quello che abbiamo detto dovrebbe essere già tutto chiaro. La prima def (che contiene un uguale-valore-tra-parentesi) è quella che riceve il valore. La sintassi è così, è diversa da come si usano di solito le def ma è così. Quello che fa all'interno è impostare la variabile e successivamente aggiornare la classe (ho messo un'ipotetico nome di funzione che naturalmente manca nell'esempio). La seconda def invece semplicemente restituisce il valore con return.
Un'ultima cosa che hanno in comune def e classi sono i nomi standard. Cioè i nomi di def che scritti in qul modo hanno una funzione già definita. Farò un accenno superficiale perchè non ci interessa più di tanto. Ad esempio un numero fa parte della class Numeric. Quando aggiungiamo un numero a quell'altro, chiamiamo una funzione della class Numeric che se non sbaglio si chiama __add__ o _add_ o comunque qualcosa di simile. Se noi aggiungiamo questa def in una class window ad esempio, potremo sommare due window e specificare cosa succede quando lo facciamo senza ottenere errore. Ma difficilmente andremo a fare modifiche di questo genere al codice, quindi vediamo soltanto i nomi più importanti. Innanzitutto def initialize. Non abbiamo detto come si chiama una classe e lo diciamo ora:

<div class="de1"><span class="re1">@finestra</span> = Classe_Window.<span class="me1">new</span></div></div></td></tr></table>

In questo modo la variabile @finestra conterrà un'istanza della Classe_Window. Il .new si scrive sempre per creare una nuova istanza. Avrete visto che alcune classi accettano dei valori, come le def. Faccio un esempio dall'rgss:

<div class="de1"><span class="re1">@map_interpreter</span> = Interpreter.<span class="me1">new</span><span class="br0">(</span><span class="nu0">0</span>, <span class="kw2">true</span><span class="br0">)</span></div></div></td></tr></table>

Bene, la def initialize è quella che viene immediatamente eseguita appena un'istanza della classe viene creata. Questo esempio impone che nella classe Interpreter, la def initialize accetta almeno due valori, obbligatori o facoltativi. Cioè i valori passati nella creazione della classe giungono (e sono predisposti) nella def initialize della stessa.
Altri due nomi di def solitamente usati sono update e refresh. refresh spesso è anche assente e soprattutto non è un nome standard, mentre update, non essendo neanch'esso un nome standard, per le Scene_ è un pò come se lo fosse, in quanto di solito fra i vari update viene chiamato anche quello della Scene_ stessa. E, in genere la def update è usata per gli aggiornamenti continui (controllo tasti, controllo numeri, etc...) mentre la def refresh è usata per i metodi grafici e occasionalmente, ovvero quando è necessario cancellare tutto e ridisegnare.
Inoltre anche la def main negli Scene_ è importante perchè lo script Main, per aggiornare le Scene_, esegue la def main di esse

Faccio prima di concludere un piccolo accenno alla differenza fra @ e @@. E' una cosa poco usata, difficile da comprendere per un novizio, fattibile in altri modi e non ci interessa particolarmente trattarla ma per completezza lo faccio. Sappiamo che se una classe contiene una variabile si usa @ per specificarla. Le doppie @ vanno usate invece per far condividere lo stesso valore a più classi. E' quindi simile per certi aspetti a una variabile globale, di poco. Facciamo per esempio una classe che mostra un quadrato. Nonostante la semplicità non scriverò il codice. Supponiamo che ci sono più quadrati, più classi. Ogni quadrato ha un colore diverso, e quindi la classe ha il valore @colore. E ogni nuova istanza della classe dà la possibilità di cambiare il colore. Giusto per esempio, vogliamo anche che di questi quadrati sia impostabile la grandezza, ma vogliamo che tutti debbano averla uguale. Allora la classe avrà la variabile @@grandezza e basterà cambiarla in un'istanza di questa classe, che sarà cambiata in tutte le altre allo stesso modo. Capirete quindi che si può usare una variabile globale, che si può invece creare la variabile @grandezza e cambiarla manualmente in tutte la istanze. Cioè i metodi ci sono, quindi quello delle @@ è poco usato, ma se l'avete compreso utilizzatelo pure, perchè se si comprende è comodo.

Come esercizio non so, improvviso qualcosa.

6) Create un modulo e mettete dentro una costante impostata a 5. Create poi una classe che abbia la variabile valore che sia solo leggibile. Fate in modo che quando la classe viene creata gli viene passato un numero e questo sia sommato alla costante contenuta nel modulo e il risultato venga poi inserito nella variabile valore.
Fuori da tutto, poi create un'istanza della classe e quindi fategli stampare a schermo il valore dell'attributo valore.

A quanto pare serve un passo 7 per parlare della modifica di script (creando patch da applicare sotto) perchè altrimenti la lezione veniva troppo lunga. Questo 7 lo faccio più presto possibile dopodichè vedo se fermarmi o no.
Intanto fate domande se non avete capito e l'esercizio se avete capito, così poi posto il 7.

Modificato da mikb89, 15 August 2009 - 15:42 PM.

[ReZLee]

Ciao a tutti questo corso mi interessa! e non poco! si continua o rimarrà così?

[Guardian of Irael]

Mi sono deciso (finalmente) a postare l'ultimo passo di questo simil-corso di ruby base. Credo proprio che non continuerò, vedendo quanto tempo mi è stato necessario prima di scrivere questa parte, ma chissà, intanto posto questa.

Sembrerebbe di no. ^ ^
Se guardi nella sezione tutorial del forum Fanton sta facendo delle lezioni sull' RGSS mi pare sia arrivato alla terza
^ ^

Modificato da Guardian of Irael, 18 November 2009 - 23:20 PM.

[Keroro]

Riassegnare una costante è una brutta pratica, tanto che l'interprete di ruby non lo fa fare e restituisce: SyntaxError: constant-reassignment.

Ho deciso quindi di modificare l'esercizio usando la costante come prezzo di riferimento, nell'esempio mostro anche un utilizzo delle variabili di classe

<div class="de1"><span class="kw1">module</span> Allevamento</div><div class="de1">PREZZO_MAIALE = <span class="nu0">500</span> <span class="co1">#costante</span></div><div class="de1"> </div><div class="de1"><span class="kw1">class</span> Fattoria</div><div class="de1">  @@maiali_totali = <span class="nu0">0</span> <span class="co1">#variabile condivisa da tutte le fattorie</span></div><div class="de1">  <span class="kw1">def</span> initialize<span class="br0">(</span>maiali<span class="br0">)</span></div><div class="de1">	<span class="re1">@valore</span> = <span class="re2">Allevamento::PREZZO_MAIALE</span><span class="sy0">*</span>maiali</div><div class="de1">	@@maiali_totali<span class="sy0">+</span>=maiali</div><div class="de1">  <span class="kw1">end</span></div><div class="de1">  <span class="kw1">def</span> valore</div><div class="de1">	<span class="kw2">return</span> <span class="re1">@valore</span></div><div class="de1">  <span class="kw1">end</span></div><div class="de1">  <span class="kw1">def</span> <span class="kw2">self</span>.<span class="me1">maiali</span> <span class="co1">#dichiaro un metodo di classe</span></div><div class="de1">	<span class="kw2">return</span> @@maiali_totali</div><div class="de1">  <span class="kw1">end</span></div><div class="de1"><span class="kw1">end</span> </div><div class="de1"> </div><div class="de1"><span class="kw1">end</span></div><div class="de1"> </div><div class="de1">kent_farm = <span class="re2">Allevamento::Fattoria</span>.<span class="me1">new</span><span class="br0">(</span><span class="nu0">5</span><span class="br0">)</span></div><div class="de1"><span class="kw3">puts</span> <span class="st0">"Valore dei Maiali Kent: "</span> <span class="sy0">+</span> kent_farm.<span class="me1">valore</span>.<span class="me1">to_s</span></div><div class="de1">luthor_farm = <span class="re2">Allevamento::Fattoria</span>.<span class="me1">new</span><span class="br0">(</span><span class="nu0">25</span><span class="br0">)</span></div><div class="de1"><span class="kw3">puts</span> <span class="st0">"Valore dei Maiali Luthor: "</span> <span class="sy0">+</span> luthor_farm.<span class="me1">valore</span>.<span class="me1">to_s</span></div><div class="de1"><span class="kw3">puts</span> <span class="st0">"Maiali Totali: "</span> <span class="sy0">+</span> <span class="re2">Allevamento::Fattoria</span>.<span class="me1">maiali</span>.<span class="me1">to_s</span></div></div></td></tr></table>

[Losco individuo]

Grazie della precisazione Keroro^^

[snob]

Questo topic non serve per risolvere i problemi con gli script, per quello c'è lo sportello amico, e non contiene neanche un lungo discorso che spiega gli script, ma sarà un corso passo passo con gli utenti che vorranno partecipare e quindi imparare (e se partecipate imparate perchè altrimenti io non mi darò pace).

Ogni passo del corso sarà identificato con un numero, che va citato quando gli si riferisce, insieme alla risposta sotto spoiler. Ad esempio questo punto:

0) Chi intende partecipare?

Per rispondere a questo passo, bisogna scrivere il messaggio così:


<div style="margin:20px;margin-top:5px"">
<div class="codetop" style="margin-bottom:2px">Spoiler <input type="button" value="Visualizza" style="width:65px;font-size:10px;margin:0px;padding:0px;" onClick="if (this.parentNode.parentNode.getElementsByTagName('div')[1].getElementsByTagName('div')[0].style.display != '') { this.parentNode.parentNode.getElementsByTagName('div')[1].getElementsByTagName('div')[0].style.display = ''; this.innerText = ''; this.value = 'Nascondi'; } else { this.parentNode.parentNode.getElementsByTagName('div')[1].getElementsByTagName('div')[0].style.display = 'none'; this.innerText = ''; this.value = 'Visualizza'; }"></div><div class="spoiler" style='overflow:auto'>
<div style="display: none;">
Io partecipo ^^
</div>
</div>
</div>

E tutto quello che sta fuori dallo spoiler può essere un commento di altro tipo.

La partecipazione è vincolante, nel senso che non andrò avanti col 2° passo se tutti quelli che hanno dichiarato di partecipare non dicono che va bene il primo, quindi partecipate se avete intenzioni serie, altrimenti bloccate tutto ><

In qualsiasi momento cmq uno può disdire la partecipazione o uno che non partecipa può iniziare a partecipare.

Se chi già conosce gli script nota che sbaglio qualcosa, è pregato di farlo notare, con garbatezza e gentilezza, in modo da non impartire possibili nozioni errate a chi desidera imparare.

Credo che sia tutto. Vi aspetto in molti ^^

Ecco i link rapidi ai passi già postati.
Passo 1: Le variabili
Passo 2: Gestione delle variabili
Passo 3: Gli array
Passo 4: Le condizioni
Passo 5: I cicli

credo sia molto interessante tt la tua spiegazione,ma nn riuscirei a seguire praticamente mai...nn c'è tipo un manuake?

Modificato da snob, 19 January 2010 - 13:48 PM.