08: TUTORIAL Fatto l'esempio, spiegata la regola ;) (Metodi) 0

[Lomax_Iced]

Bella gente eccomi con un nuovo tutorial dedicato al Javascript utilizzato in ambiente Rpg Maker Mv
((qualcuno di voi avrà detto, ma questo non era il settimo! come mai ora è L'ottavo??? :O )
Niente gente per esigenza ho scoperto che era meglio spiegare prima il concetto di funzione, poi di oggetto e infine di Metodo.
Quindi adesso questo è divenuto appunto il tutorial numero otto.)

Nei tutorial precedenti vi ho fatto l'esempio di come creare un metodo e assegnare in esso delle proprietà o funzioni da far eseguire all'eseguibile il tutto appunto. Nel newSettimo vi ho spiegato l'importanza delle funzioni, delle Tipolgie di Oggetto (I Padri) e di come si creano gli oggetti Figli. 

Per chi non sa di cosa io stia parlando, vi invito a leggere i tutorial precedenti che troverete in questo link già listati:
http://www.rpg2s.net...n-e-javascript/
Però ci tengo che andiate in particolar modo a visionare il tutorial numero 06 e il tutorial numero 07 perché introduco, con degli esempi, tutto l'argomento. 

Vi esorto sin da subito a prestare moltissima attenzione a quanto si dirà fra poco. 
L'argomento riguardante i Metodi javascript è molto complesso però vi assicuro che una volta che lo abbiate capito, vi si aprirà un mondo.   

Detto questo facciamoci coraggio e...
Iniziamo!
 

PremessaTeorica:

 

1. Javascript è un linguaggio diverso dal linguaggio Java. 

 

Premesso questo:

 

2. Ogni Oggetto che verrà creato in linguaggio Javascript appartiene ad un oggetto padre      
     denominato Object.

     Nel caso specifico di Rpg Maker Mv, questo SUPER PADRE a cui fanno riferimento tutti gli altri    

     plugin, è conosciuto come lo script                rpg_objects.js  .

 

3. Tutti gli oggetti figli di rpg_object.js erediteranno tutti i metodi e tutte le proprietà che    

    apparterranno ad Object.
    E si evocheranno in questo modo:  
(vi faccio i tre esempi che già abbiamo incontrato nei tutorial precedenti)

 

vi ricordate?
 

Scene_Boot.prototype.start = function()
{
   //informazioni varie
};

Spoiler

Le informazioni che venivano immesse all'interno del suddetto box, riguardavano unicamente le 
funzioni di avvio del gioco. In particolare la gestione delle locazioni in cui veniva spedito il giocatore
una volta attivata la condizione esatta, fra le tante mosse a disposizione del programmatore.

 

Scene_GameEnd.prototype.commandToTitle = function() 
{
     //informazioni varie
};

Spoiler

Le informazioni che venivano immesse all'interno del suddetto box, riguardavano unicamente le 
funzioni di chiusura del gioco. In particolar modo la possibilità di attivare o disattivare da parte del progettista, la facoltà di poter far visualizzare (si/no) al giocatore il menu iniziale del game, una volta che quest'ultimo avesse deciso di far riavviare una nuova partita. 

Game_Interpreter.prototype.pluginCommand = function(command, args)
{
     //informazioni varie    
};

Spoiler

Le informazioni che venivano immesse all'interno del suddetto box, riguardavano unicamente le 
funzioni di poter far avviare un messaggio testuale immesso all'interno di una windowskin attivabile in gioco, tramite un call script inserito dentro un evento. 

 

Dette le due regole fondamentali e fatti i tre esempi, passiamo all'analisi e alla composizione delle stringhe che compongono i BoxMetodi. 

Prendiamo la fattispecie:
 

 A.Eredita.B = funzioni()

Questa stringa è una sorta di Catena che implica che B (ovvero oggetto2) sia legato tramite un legame ereditario a A (ovvero l'oggetto1) e pertanto questi due elementi possiedono le stesse funzioni. 
Quindi detto questo abbiamo ad esempio che:
Game_Interpreter è un oggetto.

Per oggetto si intende un box o una scatola. Infatti basti pensare che lo stesso Game_Interpreter sia uno script con al suo interno altrettanti suoi metodi e funzioni che lo rendono utile, nella sua funzione originaria. Ed è figlio di rpg_Object.js

Quindi si può definire Padre di pluginCommand e condivide parte (se non tutte) delle sue funzioni. 

il comando che permette di far avvenire il legame è questo:              .prototype.     
lo ripeto per far saltare di più all'occhio i due punti:                    puntoprototypepunto


Studiando gli oggetti nel capitolo 07T ho potuto appurare che non si fa molta distinzione fra Oggetti e Metodi. Cosa voglio dire?
Voglio dire che, dato che tutto si muove in funzione delle funzioni (scusate il gioco di parole). 
Quando si crea un oggetto e si assegnano ad esso delle caratteristiche, in un certo qual senso, si è creato un metodo. 
Cioè il metodo è incorporato nell'oggetto. 
Vi faccio un esempio. 
Se io voglio fare apparire in game un messaggio di testo il metodo che mi permette tale operazione è il richiamare tramite un call script dentro un evento, un oggetto che abbia al suo interno le caratteristiche appropriate. Vi faccio l'esempio che ho inserito all'interno del nostro plugin:

 

Game_Interpreter.prototype.pluginCommand = function(command, args)
{
    aliasPluginCommand.call(this, command, args);

    if (command == 'DiQualcosa' )
    {
       $gameMessage.add('O.o ehm veramente non saprei..ehm ohm..')
    }
};

Se noi andassimo in rpg_object.js  e andassimo a visionare dalla stringa numero 8728 fino all'ultima stringa 10452. Potremmo notare che 
Game_Interpreter ovvero Oggetto1 e citato plurime volte. Questo sta ad indicare che (in questo caso) è lui l'oggetto padre. 
Però ricordiamoci sempre che è posto all'interno di rpg_Object. Quindi oltre ad essere padre, è anche figlio. (non fate battute   )

Quindi tornando al ragionamento, in questo caso, l'oggetto numero due ovvero pluginCommand sarà un altro dei suoi figli. 
E continuando a dire Quindi Quindi, noi (per chi non lo avesse ancora capito) Abbiamo richiamato pluginCommand nel nostro script. 

Che metodo abbiamo usato?
Bella domanda! 
Da un punto di vista analitico posso dire per certo che abbiamo usato un metodo definito constructor che permette di legare a se più oggetti tramite il costrutto prototype cicuito da dei punti. 

Però momentaneamente posso condividere con voi la riflessione che a parte questo metodo, generalmente se volessi creare un secondo oggetto che mi svolge che ne so un altro testo in game e lo chiamerò Messaggio1. 

Per semplificarci dovrei scrivere così:
 

var aliasMessaggio1 = pluginCommand;

pluginCommand.prototype.Messaggio1 = function(command, args)
{
    aliasMessaggio1.call(this, command, args);

    if (command == 'Messaggio1')
    {
        $gameMessage.add('Avvio Messaggio1')
    }
};

E invece no!
Voglio lasciare il codice sopra per indicare gli errori che ho fatto e che si possono fare. Quindi quanto scritto su è Errato! 
Tecnicamente la struttura è corretta solo che si fanno i richiami sbagliati. 

La scrittura corretta risulterà la seguente, e ho pure modificato il nostro plugin rendendo lo script più professionale. 
In sostanza ho aggiunto questi due oggetti:
 

var aliasMessaggio1 = Game_Interpreter.prototype.pluginCommand;

Game_Interpreter.prototype.pluginCommand = function(command, args)
{
    aliasMessaggio1.call(this, command, args);

    if (command == 'Messaggio1' )
    {
       $gameMessage.add('Avvio Messaggio1')
    }
};

var aliasMessaggio2 = Game_Interpreter.prototype.pluginCommand;

Game_Interpreter.prototype.pluginCommand = function(command, args)
{
    aliasMessaggio2.call(this, command, args);

    if (command == 'Messaggio2')
    {
        $gameMessage.add('Avvio Messaggio2')
    }
};

Allora dunque, sono due oggetti simili denominati Messaggio1 e Messaggio2 e si occupano entrambi di far visualizzare una windowskin in gioco (ovviamente con dentro un testo). 
Attivando i rispettivi PluginCommand (terza pagina, ultima voce in basso a destra dei comandi evento) appunto dentro i 2 Eventi. 
In uno ho richiamato il comando 'Messaggio1' e nell'altro il comando 'Messaggio2'. notate le due condizioni (if) che appunto specificano che 
se si comanda Messaggio1 o Messaggio2 la reazione sarà che verrà evocata una finestra con dentro i messaggi corrispettivi. 

Questa cosa può essere utile per creare dei dialoghi complessi, in maniera del tutto semplice e più immediata. 
L'unico metodo che posso dire di avere utilizzato è il constructor . che mi ha permesso di :
 

Game_Interpreter.prototype.pluginCommand = function(command, args)
{
    aliasMessaggio2.call(this, command, args);

    if (command == 'Messaggio2')
    {
        $gameMessage.add('Avvio Messaggio2')
    }
};

1. Game_Interpreter.prototype.pluginCommand = function(command, args)  
     Mi ha permesso di Richiamare le funzioni appartenenti all'oggetto PluginCommand. Andiamolo a trovare..
    Eccolo qua! (riga 10441 fino a 10451 sempre di rpg_object.js ovviamente)
 

// Plugin Command
Game_Interpreter.prototype.command356 = function() {
    var args = this._params[0].split(" ");
    var command = args.shift();
    this.pluginCommand(command, args);
    return true;
};

Game_Interpreter.prototype.pluginCommand = function(command, args) {

    // to be overridden by plugins

};

 

In sostanza Game_Interpreter gestisce tutto ciò che si occupa della programmazione ad eventi. 
PluginCommand ovvero tradotto Comandi Plugin (come dicevo prima, ultima voce a destra della terza pagina del menu Contenuti posto dentro le pagine Evento) è catalogato come comando numero 356. In quest'ultima porzione di codice, estrapolata da rpg_object.js viene specificato che 
il comando356 appartiene a Game_Interpreter e oltre a costituirne le funzioni, lo si rinomina. tramite quel
                                              this.pluginCommand(command, args);
Specificando appunto che il progettista, lo potrà identificare sotto il nome di pluginCommand. 

Ora io per esigenze didattiche ho voluto attuare delle modifiche al comando 356, per vedere un pochettino quali fossero le reazioni. 
E devo dire che tramite questo mio esperimento ho potuto appurare che il costrutto     this.    si occupa di definire le generalità del comando.
vi riporto la modifica attuata: 
 

// Plugin Command
Game_Interpreter.prototype.command356 = function() {
    var args = this._params[0].split(" ");
    var command = args.shift();
    this.ComandiPlugin(command, args);
    return true;
};

Game_Interpreter.prototype.ComandiPlugin = function(command, args) {
    // to be overridden by plugins
};

In sostanza ho soltanto rinominato l'oggetto, per vedere se rinominandolo cambiava qualcosa oppure no. E non è cambiato nulla. 
Quindi questo mi fa credere che gli oggetti sono singole scatole in cui a loro interno possiedono le loro caratteristiche che al tempo stesso corrispondono ai metodi.

Per metodi intendo 'Diversi modi per far qualcosa'. 
Quindi capite bene che il concetto si semplifica di molto. Per un programmatore alle prime armi basterà spulciare gli oggetti presenti all'interno di rpg_object.js, tipo ingredienti presi in un supermarket. Prendere ciò che vi serve, metterlo nel vostro carrello della spesa (il vostro plugin)
e poi una volta a casa (in Sublime text 2 o in altro tool editor) preparare la ricetta. 

Io ad esempio da neofita ho fatto così:
 

(io ho modificato pure il codice inerente pluginCommand italianizzandolo. Perché a me piace. Facendolo diventare così:
 

// Plugin Command
Game_Interpreter.prototype.command356 = function() {
    var parole = this._params[0].split(" ");
    var comando = parole.shift();
    this.ComandiPlugin(comando, parole);
    return true;
};

Game_Interpreter.prototype.ComandiPlugin = function(comando, parole) {
    // to be overridden by plugins
};

Modificando quelle paroline di li, rinomino soltanto il nome delle proprietà che appartengono unicamente al command356. 
e poi modifico il nome pluginCommand in ComandiPlugin. Io vi consiglierei di non farlo anche perché nella foga potreste italianizzare tutto anche i costrutti fondamentali e combinate macelli. Io l'ho fatto perché voglio rendervi al corrente cosa potrebbe essere modificabile e cosa no. 
Anche perché così mi rendo conto di come funziona tutto sto linguaggio. 

Ho trasformato il nostro plugin 00SaltaTitle.js in questo modo:

Spoiler

 

//======================================================
/*:
 * @plugindesc 
 * Permette di saltare lo Scene_Title  
 * E di far apparire due BoxMessaggi richiamando 2 eventi
 * @author 
 * Lomax_Iced
 *                               //Parametri-----------
 * @param Menu Iniziale?
 * @desc Questo comando consente di attivare 
 *       la possibilità di accedere al menu iniziale. 
 * @default Si
 * //---------------------------------------------------
 * @help
 * Entra nella finestra Parametro e cambia il suo valore.
 * Si. Permetti al giocatore di tornare al Menu Iniziale.
 * No. Permetti al giocatore di tornare in Mappa. 
 * Ricominciando una nuova partita.  
 */
//=======================================================
var parameters = PluginManager.parameters('00SaltaTitle');

var vaialmenu = String(parameters['Menu Iniziale?'] || 'Si');

 Scene_Boot.prototype.start = function() {
    Scene_Base.prototype.start.call(this);
    SoundManager.preloadImportantSounds();
    if (DataManager.isBattleTest()) {
        DataManager.setupBattleTest();
        SceneManager.goto(Scene_Battle);
    } else if (DataManager.isEventTest()) {
        DataManager.setupEventTest();
        SceneManager.goto(Scene_Map);
    } else {
        this.checkPlayerLocation();
        DataManager.setupNewGame();
        SceneManager.goto(Scene_Map);
    }
    this.updateDocumentTitle();
};
Scene_GameEnd.prototype.commandToTitle = function() { 
    this.fadeOutAll();
    if(vaialmenu == 'Si') 
    {  
        SceneManager.goto(Scene_Title);
    }
    else 
    { 
        DataManager.setupNewGame();
        SceneManager.goto(Scene_Map);
    }
};
var aliasMessaggio1 = Game_Interpreter.prototype.ComandiPlugin;

Game_Interpreter.prototype.ComandiPlugin = function(comando, parole)
{
    aliasMessaggio1.call(this, comando, parole);

    if (comando == 'Messaggio1' )
    {
       $gameMessage.add('Avvio Messaggio1')
    }
};

var aliasMessaggio2 = Game_Interpreter.prototype.ComandiPlugin;

Game_Interpreter.prototype.ComandiPlugin = function(comando, parole)
{
    aliasMessaggio2.call(this, comando, parole);

    if (comando == 'Messaggio2')
    {
        $gameMessage.add('Avvio Messaggio2')
    }
};

Spero che la spiegazione vi sia piaciuta e soprattutto che l'abbiate capita. In caso contrario dite pure tutto quello che non vi è chiaro ed io 
proverò a renderlo tale. 
Detto questo stoppo qui ehm.. ci rileggiamo al prossimo tutorial. 

Modificato da Lomax_Iced, 20 November 2015 - 13:46 PM.