0
3
Bella gente Benvenuti in un nuovo tutorial dedicato al Javascript in ambiente Rpg Maker Mv.
Nel tutorial precedente: 09T :http://www.rpg2s.net...-gli-operatori/ .
Ho iniziato ad introdurre il concetto sugli Operatori. Essi sono dei simboli che corrispondono a delle operazioni specifiche.
Sono essenziali e servono unicamente a far svolgere tutti quei processi che indurranno il plugin a svolgere determinate azioni.
Li abbiamo incontrati in:
00SaltaTitle
//======================================================
/*:
* @plugindesc
* Permette di saltare lo Scene_Title
* @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_Test);
}
this.updateDocumentTitle();
};
Scene_GameEnd.prototype.commandToTitle = function() {
this.fadeOutAll();
if(vaialmenu == 'Si')
{
SceneManager.goto(Scene_Title);
}
else
{
DataManager.setupNewGame();
SceneManager.goto(Scene_Map);
}
};
In
01Calcolatrice
//======================================================
/*:
* @plugindesc
* Permette di far apparire un BoxMessaggi
* @author
* Lomax_Iced
*
* @help
*
*/
//=======================================================
var aliasRisultato = Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function(command, args)
{
aliasRisultato.call(this, command, args);
if (command == 'Risultato' )
{
var PrimoNumero = 6
var SecondoNumero = PrimoNumero >= 6
$gameMessage.add(String(SecondoNumero))
}
};
Ovviamente sono presenti in qualsiasi altro script o plugin esistente al mondo!
Ripeto sono fondamentali.
Nel tutorial numero nove, ho spiegato abbondantemente, in linea generica come si possono richiamare.
Li ho suddivisi per categoria. Adesso, in questo decimo capitolo, proverò ad analizzarli per categoria.
Quindi fatta la premessa..
Iniziamo
:. . .
Gli OPERATORI MATEMATICI:
sono cinque e corrispondono alle comuni operazioni che siamo soliti imparare a scuola.
Sono questi qui:
+ // addizione - // sottrazione * //moltiplicazione / // divisione % // resto
Determinano il risultato dell'espressione a cui essi fanno parte. Ad esempio se io prendessi in considerazione i numeri 4 e 5 in questo modo esprimerei soltanto di possedere due elementi denominati 4 e 5, aldilà del fatto che sono unità numeriche.
Per porre in relazione questi due elementi, occorrono gli operatori (in questo caso tratteremo solo i Matematici).
Ci tengo a precisare che 4 e 5 sono due elementi, aldilà del fatto che sono numeri. Perché dico questo? Perché due elementi lo possono essere pure Pane e Pasta. Oppure 5 e giallo.
Oppure più comunemente in Rpg Maker Mv, x e y. Oppure ancora Width e Heigth . Capito dove voglio arrivare?
Vi faccio un esempio estrapolato direttamente da rpg_core.js (un altro dei vostri plugin di base)
Andate lì e cercate la riga numero 823 e copia/incollate fino alla riga 849.
Per intenderci, questa porzione di codice:
Bitmap.prototype.drawText = function(text, x, y, maxWidth, lineHeight, align) {
// Note: Firefox has a bug with textBaseline: Bug 737852
// So we use 'alphabetic' here.
if (text !== undefined) {
var tx = x;
var ty = y + lineHeight - (lineHeight - this.fontSize * 0.7) / 2;
var context = this._context;
var alpha = context.globalAlpha;
maxWidth = maxWidth || 0xffffffff;
if (align === 'center') {
tx += maxWidth / 2;
}
if (align === 'right') {
tx += maxWidth;
}
context.save();
context.font = this._makeFontNameText();
context.textAlign = align;
context.textBaseline = 'alphabetic';
context.globalAlpha = 1;
this._drawTextOutline(text, tx, ty, maxWidth);
context.globalAlpha = alpha;
this._drawTextBody(text, tx, ty, maxWidth);
context.restore();
this._setDirty();
}
};
Ora già dovreste essere in grado di tradurre il codice direttamente dalle stringhe. In sommatoria abbiamo che si è creato l'oggetto drawText figlio dell'oggetto Bitmap. Quello che a noi interessa è iniziare a saper decifrare le operazioni che avvengono in PANCIA.
Isoliamo ancora di più la parte interessata:
if (text !== undefined) {
var tx = x;
var ty = y + lineHeight - (lineHeight - this.fontSize * 0.7) / 2;
var context = this._context;
var alpha = context.globalAlpha;
maxWidth = maxWidth || 0xffffffff;
if (align === 'center') {
tx += maxWidth / 2;
}
if (align === 'right') {
tx += maxWidth;
}
context.save();
context.font = this._makeFontNameText();
context.textAlign = align;
context.textBaseline = 'alphabetic';
context.globalAlpha = 1;
this._drawTextOutline(text, tx, ty, maxWidth);
context.globalAlpha = alpha;
this._drawTextBody(text, tx, ty, maxWidth);
context.restore();
this._setDirty();
}
Sappiamo tutti che questa è una condizione. Il costrutto per richiamarla è if che in italiano vuol dire Se.
Ricordate l'esempio? Se io ho 18 anni, posso guidare la macchina. In questo caso:
Se è stato già definito il testo del messaggio....
tx è uguale a x
ty è uguale al risultato di questo calcolo qua: y + lineHeight - (lineHeight - this.fontSize * 0.7) / 2; .
ecc ecc Per ora fermiamoci qui, senza andare molto oltre.
Quindi:
Qui abbiamo.. y + lineHeight - (lineHeight - this.fontSize * 0.7) / 2;
Che è un po come dire:
10 + 5 - (5 - 4 *0.7) / 2 =
Come vedete abbiamo generato un'espressione. Il suo risultato finale poi sarà eguagliato a ty .
Quindi tornando al concetto principale:
Qui avremo:
1. Un'addizione, ovvero y + lineHeight che è come dire 10 + 5
2. Diverse sottrazioni, tipo lineHeight - (thi.fontSize * 0.7)/2 ovvero 5 - 4
3. Una moltiplicazione come this.fontSize * 0.7 tipo 3 * 6
4. Una divisione y + lineHeight - (lineHeight - this.fontSize * 0.7) / 2; oppure 25 / 5
(anche se non è presente nell'esempio, questo operatore % restituisce il resto dell'operazione.
Ora solo per farvelo vedere all'opera, io l'ho trovato cercando in rpg_core.js già alla riga 35.
Ovvero qui:
Number.prototype.mod = function(n) {
return ((this % n) + n) % n;
};
Non addentriamoci oltre momentaneamente.
Adesso divertitevi a sperimentare, emulando qualche operazione di base e poi stravolgetela, utilizzando la nostra 01calcolatrice.js
magari per visualizzarne i risultati sulla mappa di gioco .
Ora dedichiamoci alla seconda categoria di Operatori, ovvero:
GLI OPERATORI ARITMETICI:
GLI OPERATORI ARITMETICI: - // negazione es: var x = -2 ++ // incremento es: var z = ++5 -- // decremento es: var w = --z
Sappiamo tutti che c'è distinzione fra un numero positivo 19 oppure +19 o x oppure +x
E un numero negativo -19 oppure -x
Dire -x + (-9) = 0 e dire x + (-9) = 0
Ovviamente non sono la stessa cosa. nel primo caso l'incognita x assumerà un valore negativo. Nel secondo caso, no.
Quest'altri altri due operatori ++ e -- si occupano invece di gestire la fluttuazione del tasso del parametro.
Facendo incrementare o decrementare il valore secondo la specifica impostata dal programmatore.
Li potete riconoscere perché possono precedere o no il valore a cui essi fanno riferimento. Di fatti c'è distinzione fra questa espressione: x = ++1 e quest'altra x = 1++ oppure fra questa x = --1 e questa'altra ancora x = 1-- .
Aldilà del fatto che si può facilmente intuire che l'operatore ++ indica un incremento del suo valore (in questo caso di 1).
Mentre -- indica un decremento . Un altro fattore importante da tenere in considerazione è soprattutto la differenza di posizionamento dell'operatore. In quanto possiamo trovarlo che precede il suo specifico oppure lo segue.
La differenza sta perché cambia anche il suo significato:
1. Se l'operatore precede il proprio valore, il tasso viene modificato Prima che l'espressione venga eseguita.
Ovvero avremo oggetti tassati in questo modo x = ++1 oppure y = --1
2. Se l'operatore segue il proprio valore, il tasso viene modificato Dopo che l'espressione verrà eseguita.
Ovvero avremo oggetti tassati in questo modo x = 1++ oppure y = 1--
Spero che vi sia tutto chiaro fino a qua.
Adesso finalmente analizzeremo..
gli OPERATORI RELAZIONALI:
|||||||||||||||||||||||||TUTORIAL NON ANCORA CONCLUSO|||||||||||||||||||||||||||
|||||||||||||||||||||||||||||||TUTORIAL DA COMPLETARE||||||||||||||||||||||||||||||||||||
Che sono i seguenti:
> // Maggiore >= // Maggiore uguale < // Minore <= // Minore uguale == // uguale != // diverso === // Identico !== // Differente
Modificato da Lomax_Iced, 21 November 2015 - 15:42 PM.
