Guida RPG Maker XP Script #8 – Approfondimenti Window & Input


Nelle 2 parti precedenti abbiamo visto Eventi e Database, una marea di informazioni, possono sembrare parti puramente teoriche ma non lo sono affatto, gran parte delle informazioni date serviranno prima o poi… almeno se siete come me che si divertono a creare sistemi di giochi tutti diversi tra loro; ora però torniamo allo scripting puro, andando ad approfindire gli argomenti principali, Window e Input, cioè le “finestre” e comandi di gioco.

– WINDOW –

Prima di aggiungere informazioni rivediamo ciò che abbiamo visto nelle parti precedenti:

Var = Window_Base.new(X, Y, W, H) è il codice strandard per creare una finestra, dove “Var” è il nome della finestra nonchè una variabile, consigliabile farla di istanza (aggiungendo @ all’inizio del nome) o in alcuni casi adirittura globale (aggiungendo $ all’inizio del nome), in questo caso l’ho fatta locale perchè è solo d’esempio, funzionerebbe lo stesso ma solo nel Def dove viene creata; “X” e “Y” indicano la posizione dove inserire la finestra, più precisamente l’angolo alto sinistro della finestra, se X e Y 0 verrà inserita nell’angolo alto sinistro della schermata, più in basso deve aumentare Y, più a destra X; “W” e “H” sono Width e Height, ovvero Larghezza e Altezza, per specificare la grandezza della finestra, ricordando che le schemata è grande 640×480 e che 32 verrà automaticamente, non evitabile, dato al bordo della finestra, dove quindi non verrà mostrato alcun contenuto se non il bordo.

Var.contents = Bitmap.new(W, H) creata la finestra, bisogna preparla a ricevere contenuto utilizzando questo codice, dove “W” e “H” anche in questo caso vanno a specificare la grandezza, nel dubbio fate direttamente una cosa tipo (Var.width-32, Var.height-32) per dire di volere disponibile il massimo possibile, evitate di fare l’errore che facevo io, cioè pensando che per ogni contenuto andava aggiunto un “Bitmap” nuovo, non è affatto così, tutto il contenuto potrà essere mostrato sullo stesso Bitmap.

Var.dispose quando la finestra non vi serivirà più, con questo codice la si eliminerà e per il programma è come se non fosse mai esistita, se invece fate Var.contents.dispose si eliminerà solo il contenuto o meglio la Bitmap, la finestra ci sarà ancora e se volete aggiungere nuovamente contenuto va ripetuto il codice Var.contents = Bitmap.new(W, H) ma se siete interessati a svuotare una finestra non è necessario tutto ciò, basta usare il codice Var.contents.clear, con quest’ultimo il Bitmap rimarrà ma verrà svuotato da ogni contenuto.

Ora che abbiamo visto cose già spiegate, aggiungendo qualche dettaglio, andiamo a vedere cose nuove e capirete perchè ho preferito saltare altre cose già spiegate:

Var.contents.draw_text(X, Y, W, H, TXT, A) questo pure lo abbiamo già visto, X e Y per decidere dove posizionarlo nella finestra, dove con X e Y 0 si andrà a inserire nell’angolo alto sinistro della finestra e non schermata a meno che non siano 0 anche l’X e Y della finestra; W e H pure hanno lo stesso significato, andando a specificare in quanto spazio il testo si dovrà inserire, per esempio se il testo è molto lungo ma W non è abbastanza, il testo verrà schiacciato, con un certo limite di grandezza minima, per stare nello spazio specificato, mentre H non andrà a schiacciare mai il testo, nel caso orizzontalmente, se il testo è troppo grande si vedrà solo in parte; TXT è il testo da visualizzare, dovrà o essere rinchiuso tra virgolette, “TXT”, o essere una variabile “string”, se non lo è o si fa TXT.to_s o “#{TXT}”, virgolette comprese; in fine A sta per Aling (Allineamento), cioè se 0 il testo si allinea a sinistra, se 1 centrato oppure 2 per allinearlo a destra, se non viene specificato verrà considerato 0.

– RPG::Cache –

“draw_text” aggiunge un testo ma se volessimo aggiungere un immagine? Il codice dovrà essere una cosa tipo Var.contents.blt(X, Y, IMG, RECT), X e Y identici a draw_text, mentre per capire IMG bisogna capire “RPG::Cache”.

La prima cosa da capire è che RPG::Cache fa riferimento alla cartella “Graphics”, del progetto ma anche di RPG Maker XP, così come alle sue sotto cartelle ma per le sottocartelle bisognerà aggiungere il nome della sottocartella ma al singolare e non plurale come la cartella, tipo “RPG::Cache.battler” fa riferimento alla cartella “Battlers”.
Il codice è spesso uguale tra le varie sotto cartelle; “autotile”, “battleback”, “gameover”, “icon”, “picture”, “tileset”, “title” e “widowskin” serve precisare solo il nome del file immagine, inserito tra virgolette o comunque tramite variabile testo, senza nemmeno il formato (png, jpg, ecc… ), più precisamente, sempre come esempio, “RPG::Cache.autotile(“NOME”)”, valerà lo stesso con quelli che seguono, inutile ripeterlo sempre, cambieranno però i dati da inserire tra parentesi; “animation”, “battler”, “character”, “fog” e “panorama” bisognerà fare “(NOME, HUE)”, HUE lo abbiamo visto così tante volte che immagino darebbe fastidio se lo rispiego; poi l’ultimo è “RPG::Cache.tile(NOME, ID, HUE)”, nella parte della guida del database abbiamo visto per bene cos’è un tile, ricapitolando il tile è una porzione 32×32 pixel di un tileset, nella cartella “Tilesets”, dato che il tile non ha un nome bisognerà inserire il nome dell’immagine Tilesets, ID poi parte da 384 per il primo poi aumenta di 1 andando verso destra, chiaramente arrivati al limite destro si andrà accapo, a mò di macchina da scrivere, per far capire bene ecco un immagine, che forse aveva più senso inserire nella parte Database ma c’erano già troppe cose, non volevo appesantire ulteriolmente… ah, ho completato solo la prima riga per far capire, vale la stessa logica con quelle che seguono.



Tornando al codice iniziale, aggiungendo letteralmente cosa abbiamo imparato: Var.contents.blt(X, Y, RPG::Cache.autotile(“NOME”), RECT), volendo non è necessario inserirlo direttamente in codice ma creare una variabile che ha come valore l’immagine, tornando a come era prima: Var.contents.blt(X, Y, IMG, RECT) dove IMG = RPG::Cache.autotile(“NOME”) da inserire prima, durante la scrittura del codice.

– RECT –

Ora vediamo il valore RECT, cioè RETTA, per crearla fare RECT = Rect.new(X, Y, W, H), i valori tra parentesi hanno lo stesso significato di come abbiamo già visto MA stavolta fa caso all’immagine inserita dove ho messo IMG nell’esempio, nel senso ritaglia una zona dell’immagine, se volete l’intera immagine dovrete inserire X e Y 0 mentre W e H pari alle misure dell’immagine, non c’è nemmeno bisogno di andarle a vedere, basta “IMG.width, IMG.height” dove ho messo “W, H”, solo però se create prima una variabile con l’immagine, “IMG.width, IMG.height” non funzionerà se inserite l’immagine direttamente in blt.
Se invece volete visualizzare solo una zona specifica, anche in questo caso X e Y sono entrambi 0 nell’angolo alto sinistro dell’immagine, in base proprio ai pixel dell’immagine inserire i valori di X e Y dell’angolo alto sinistro dell’area desiderata, poi W la larghezza e H l’altezza, se avete fatto tutto bene non si vedrà l’intera immagine ma solo l’area specificata con RECT da non confondere X e Y di blt, quelle fanno riferimento in che punto della finestra visualizzare.
Anche in questo caso si può aggiungere la retta direttamente in codice facendo Var.contents.blt(X, Y, IMG, Rect.new(X, Y, W, H)) oppure col codice iniziale aggiungendo prima RECT = Rect.new(X, Y, W, H).

– OPACITY –

Prima di proseguire va specificato che esiste un ulteriore valore, OPACITY cioè OPACITÁ, non è obbligatorio per questo non l’ho nominato prima ma può comunque servire sapere, nel caso fare Var.contents.blt(X, Y, IMG, RECT, O) dove O è il valore di opacità; opacità è il contrario di trasparenza e va da 0 a 255, il che vuol dire più il valore è basso meno l’immagine si vedrà, infatti a 0 sarà totalmente invisibile ma comunque viene considerata visibile dal programma, poi vedremo a cosa mi riferisco.

– METODI –

Non so se “metodi” sia il termine giusto per definire ciò che sto per spiegare ma non avendo idea che termine generale usare, nella gran parte nel programma viene usato il termine “methods” quindi cerchiamo di avere dei punti di riferimento almeno.
Ma a cosa mi riferisco? Abbiamo già visto alcuni di questi metodi, “Var.contents.clear” e “Var.dipose” che, nello stesso ordine, cancellano l’intero contenuto e eliminano la finestra; ma forse meglio vederli con ordine, non li spiegherò proprio tutti perchè alcuni non li ho mai usati e non è solo questione “non so a cosa servono” ma anche “non avendo mai avuto bisogno di capirli, meglio evitare e concentriamoci su solo una parte”.
Ce ne sono alcuni da usare direttamente con la variabile finestra, tipo “Var.dipose”, mentre altri che vanno a interagire col contenuto (“contents” appunto), tipo “Var.contents.clear”.

dispose – Elimina la finestra o solo il contenuto se si aggiunge “contents” tra variabile e “disposed”, senza dimenticare i punti tra una parola e l’altra; ricordo che così facendo per il programma è come se non fosse mai esistita.
disposed? – Utilizzabile anche con “contents”; chiede al programma se esiste o meno, la risposta sarà “true” se si o “false” se no, vale sia per le finestre create poi eliminate sia con finestre mai create.
update – Serve per le finestre opzioni, altrimenti il cursore non lampeggerà, non è neccessario per il suo funzionamento ma aiuterà il giocatore a capire meglio cosa è selezionato.
active – Per rendere attiva o meno, coi soliti true o false, una finestra, utile se ci sono più finestre opzioni; il codice esatto è, per esempio per attivarla, “Var.active = true”.
visible – Funzionamento simile a “active” ma la sua funzione è rendere visibile o meno la finestra, chiaramente una finestra non visibile c’è ancora.
x, y, width, height – I valori prima descritti con X, Y, W, e H, dopo la creazione della finestra è possibile cambiarli usando uno di questi, se volete cambiare più di 1 dovrete farlo su più righe e giusto per essere sicuro che capite ecco un esempio: “Var.x = 100”. “width” e “height” vanno bene anche con “contents”.
z – Nel caso ci siano più finestre, col metodo “z” decidete quale fare apparire sopra, prospetticamente, in situazioni basiliari quella creata prima sta più sotto.
opacity, back_opacity, contents_opacity – “opacity” per cambiare l’opacità della finestra, contenuto compreso, anche in questo caso va da 0 a 255 e più è basso meno si vede; “back_opacity” per l’opacità solo dello sfondo della finestra, ESCLUSI bordo e contenuto; “contents_opacity” cambia l’opacità del contenuto.
get_pixel(X, Y), set_pixel(X, Y, CLR) – Entrambi utilizzabili solamente con contents, get_pixel darà un array di 4 valori in base al colore presente nelle coordinate citate tra parentesi, coordinate che devono tener conto del bitmap che rappresenta il contenuto della finestra, non della schermata; un array colore ha i valori RGBA, cioè Red (Rosso), Green (Verde), Blue (Blu), Alpha (Opacità), tutti e 4 posso valere da 0 a 255, per creare un’array colore dal nulla bisogna fare “Color.new(R, G, B, A)” sostituendo chiaramente i quattro valori con numeri in base al colore desiderato, dove A è possibile non specificarlo, nel caso è come fosse 255; “set_pixel(X, Y, CLR)” infatti imposta il colore di CLR in X e Y.
hue_change(HUE) – Questo va utilizzato con “contents” e cambia l’hue della bitmap quindi dell’intero contenuto, ricordo che va da 0 a 255.
font – Il font è praticamente la caligrafia, come insomma scrivere il testo ma in questo caso non va solo a cambiare font, appunto, bensì: “name” per cambiare il tipo del font, di base c’è “MS PGothic” poi effettivamente ne sono dispobili pochi altri ma non ho mai approfondito ne sentito il bisogno; “size” è la grandezza, di base è 22, comunque in “draw text” è consigliabile usare un altezza poco superiore, di solito 32; “bold” e “italic” poi sono grassetto e “corsivo”, di base entrambi su “false”; “color” per specificare il colore del testo, come abbiamo già visto per creare un colore si fa “Color.new(R, G, B, A)”, di base è “Color.new(0, 0, 0, 255)”.
Per essere sicuri di capirci, per cambiare il valori del font bisognerà fare una cosa tipo “Var.contents.font.size = 22”.

– CONTENTS –

Ricapitoliamo velocemente i tipi di contenuti inseribili per poi approfondire cose nuove:

draw_text(X, Y, W, H, TXT, A) – Per inserire il testo TXT, X e Y specificano dove, mentre W e H in quanto spazio, infine A per allinearlo a destra, centro o sinistra (0, 1 o 2).
blt(X, Y, IMG, RECT) – Per inserire l’immagine IMG, X e Y la posizione mentre RECT ritaglia l’area dell’immagine grazie al codice “Rect.new(X, Y, W, H)”.
stretch_blt(ZOOM, IMG, RECT) – Anche in questo caso per inserire l’immagine IMG, anche qui RECT ha la stessa funzione… ma cos’è ZOOM che ha sostituito X e Y? Anche qui ci va una retta quindi “Rect.new(X, Y, W, H)”, però chiaramente questa retta non ritaglia l’immagine facendolo già quella alla fine, il termine ZOOM messo nell’esempio non è tanto per perchè questa retta può andar a zoomare l’immagine, più piccola, più grande ma anche le dimensioni normali, così come distorcere le proporzioni tra altezza e largezza, in che modo?
“Rect.new(X, Y, W, H)”, al posto di ZOOM chiaramente, X e Y hanno la stessa funzione dell’X e Y di “blt(X, Y, IMG, RECT)”, mentre W e H per specificare in che area l’immagine deve estendersi, come detto varierà le sue dimensioni se neccessario.
Extra – Se studiate i codici pre inseriti noterete spesso codici del tipo “Var.draw_actor_name(…)”, chiaremente invece dei 3 puntini un numero di valori specifici, di cosa si tratta? Ricordate che per creare una finestra il codice iniziale è “Window_Base.new(X, Y, W, H)”? Bene, ora andate nel script preinserito nominato proprio “Window_Base”, vedrete vari “def”, uno fra tanti proprio quello che ho citato “draw_actor_name”, tornando alla parte della guida dove ho spiegato classi e sotto classi capirete tutto va però approfondito leggermente a questo punto.
Facendo “Var = Window_Base.new(X, Y, W, H)”, la variabile Var praticamente eredita tutto il contenuto della classe Window_Base, può quindi utilizzare i suoi def, facendo “Var.nomedef”, questo può servire per rispiarmiare righe di codice, finchè fate cose semplici va anche bene andare a riscrivere ogni minimo codice ma quando ne fate di più complessi è cosa buona e giusta risparmiare quando è possibile, per evitare di confondervi o quanto meno per fare un codice più pulito; chiaramente lo stesso può funzionare con qualsiasi altra classe, facendo tipo “Var = Classe.new”, ma preferisco approfondire questo più avanti, non tanto lontano però (come tempo però probabilmente si), l’unica cosa che specifico è che la classe deve trovarsi più in alto rispetto alla classe dove si trova la variabile.

– INPUT MOUSE –

Come anticipai oltre agli input da tastiera è possibile anche sfruttare il mouse, per questo però bisogna inserire codici specifici e sapere alcune cose, che chiaramente spiegherò.
Tanto per iniziare i codici che ho trovato sono stati creati da dei certi “Near Fantastica & SephirothSpawn” che però io ho perfezionato sotto vari aspetti; tali codici non li inserirò qui ma saranno presenti nel progetto, subito sopra “Main”, in download in questa pagina (click qui) essendo davvero troppo lunghi, facendo caso alla variabile globale “$mouse” presente in “StartGame”, è impostata su “false” perchè mi crea disturbo mentre testo gli script, mettetela su “true” per provare l’input mouse.
Andiamo comunque a vedere codici aggiuntivi da inserire in classi che i primi codici non prendono in cosiderazione.

Prima cosa, i codici da inserire nelle classi in modo da accettare il mouse sono:

# Get / check mouse position
mouse_x, mouse_y = *Mouse.position
# mouse left
left = *Mouse.trigger?(0)
# mouse right
right = *Mouse.trigger?(1)
# mouse center
center = *Mouse.trigger?(2)
A dir il vero, essendo variabili senza @ ne $, funzioneranno solo nel “def” dove sono inserite, è consigliabile fare così poi spiegherò perchè, chiaramente poi le righe che iniziano con # servono solo come punto di riferimento, ricordo che nel codice vengono saltate le righe che iniziano con tale simbolo.

– La prima riga di codice va a ricavare le coordinate del mouse rispetto la schermata di gioco, mentre le altre 3 i 3 pulsanti del mouse.
– Invece se si vogliono le coordinate del mouse rispetto una specifica finestra, dove è 0, 0 posto nell’angolo alto sinistro del bitmap della finestra, serve fare delle sottrazioni alle coordinate del mouse: “mouse_x -= Var.x+20” e “mouse_y -= Var.y+16”, chiaramente uno sotto l’altro e chiaramente nell’esempio c’è una finestra chiamata “Var”.
– Il prossimo passo è specificare coordinate e input, dove “left”, “right” e “center” sono “true” se si clicca quel pulsante del mouse, altrimenti “false”.

– CONCLUSIONE –

Non mi viene nient’altro da aggiungere, finalmente basta parti lunghe piene solo di informazioni; spero che sia utile anche solo per una persona… oltre me che ogni tanto me le rileggo perchè dimentico un specifico codice… ma vabbè, sono problemi miei, non vostri; grazie e alla prossima.

Guida RPG Maker XP Script #7 – Database


E rieccoci, nell’ultima parte abbiamo visto gli eventi, più “standard” meno script ma bisognava saperlo, ora vediamo nei dettagli il più volte nominato database, in tal caso invece sarà un misto tra standard e script, è molto utile sapere come costruire e sfruttare il database se si ha intenzione di creare un gioco completo e ben fatto ma soprattutto in modo pratico e facile; volendo, grazie all’RGSS, si potrebbe anche ignorare o espandere il database di RPG Maker XP e crearne uno personale ma prima di fare ciò bisogna prima capire come interagire con tale, quindi per ora dimenticate questa possibilità, è solo una breve anticipazione di cosa vedremo nelle prossime parti (non so quando ma prima o poi). Per iniziare potremo dire, semplicemente, che il database è il contenitore dei dati o informazioni varie delle cose presenti nel gioco.



Giusto per essere sicuro che capite (è una guida pensata per CHIUNQUE) ecco una schermata dove ho cerchiato di rosso dove bisogna cliccare per accedere al database, 2 a sinistra dove si accede agli script; qui vi ritroverete varie schede, divise per categorie: Actors, Classes, Skills, Items, Weapons, Armors, Enemies, Troops, States, Animations, Tilesets, Common Events e System; se non avete mai aperto la schermata vi ritroverete la scheda “Actors” altrimenti l’ultima visualizzata, in base all’ultimo salvataggio del progetto… ah, nel caso ve lo state chiedendo, si, dall’ultima schermata mostrata ho aggiunto vari eventi, per far prove ed essere sicuro che ciò che scrivevo nella parte precedente era corretto, appena aggiorno il download potrete studiarveli.
Prima di spiegare le varie schede voglio dare alcune informazioni generiche, le informazioni presenti nel database sono memorizzate in alcune array globali “$data_” e “$game_”, con l’aggiunta, dopo il trattino basso “_” sensa spazi ne altro, del nome della scheda da dove prendere i dati, per esempio “$data_actors” è l’array che contiene i dati della scheda “Actors”; la differenza tra “data” e “game” è che il primo contiene i dati così come sono nel progetto, mentre “game” i dati modificati in base a determinate azioni, se per esempio un “Actors” aumenta di livello, con data si avrà il suo livello base mentre con game il suo livello attuale.

– ACTORS –

Ecco la prima scheda, quella che contiene gli “attori” o per meglio dire i personaggi giocabili, che cioè potrà usare il giocatore.
SCRIPT – Come anticipato per richiamare questi dati ci sarà l’array $data_actors o $game_actors, come detto “game” per averlo “aggiornato” mentre “data” per avere ciò che c’è scritto nel database, quindi i valori iniziali; $game_party.actors invece è l’array con memorizzati i personaggi presenti attualmente nel party.

Actors – Tutte le schede, tranne System, ha a sinistra la lista dei suoi “elementi”, subito sotto la scritta del nome della scheda; c’è l’ID a 3 cifre, viene quindi da se pensare che il massimo inseribile sia 999, in questo caso, come per gli eventi, gli ID iniziano da 1 e non 0 come di solito accade negli array, subito di fianco all’ID c’è il nome dell’elemento, quello selezionato poi è evidenziato di blu, per concludere poi va notato che sotto a questa lista c’è il pulsante “Change Maximum”, ha la stessa funzione di tutti gli altri casi, cioè aumentare il numero degli elementi della lista, qui consiglio di non esagerare, anche avere elementi inutilizzati andrà ad appesantire il gioco.
Cliccando col destro (o sinistro se li avete invertiti) del mouse su un elemento, che lo andrà anche a selezionare, appariranno alcune funzioni che potranno essere utili in alcuni casi: Copy per copiare un elemento, per magari incollarlo altrove, sempre nella stessa scheda, anche di un progetto diverso; Paste per appunto incollare un elemento copiato, che andrà a sostituire quello attualmente presente in quello ID quindi attenzione; Clear per cancellare l’elemento, un può come fare “nuovo file”, diverrà uguale a come quando aggiungerete nuovi elementi con Change Maximum; in fine c’è Multy-Copy che va a copiare più elementi conteporaneamente, sarete voi a decidere quanti, partendo da quello su cui si è cliccato, anche in questo caso quando si incollerà andrà a sostituire gli ID con quelli copiati.
Dovrebbe essere tutto per questa zona, l’ho spiegato in modo generico perchè sarà uguale in tutte le schede quindi mi sembra ovvio che sia inutile spiegare le stesse cose più volte, la guida è pensata per essere letta in ordine.
SCRIPT – È indispensabile conoscere l’ID dell’elemento desiderato quando si utilizzano gli array $data e $game, nel caso degli actors $data_actors[ID] sostituendo ID con l’ID dell’elemento desiderato, non è neccessario, per esempio, scrivere “001” basta solamente “1”; paradossalmente, ma ha una sua utilità in alcuni casi, per conoscere l’ID si potrà usare il codice $data_actors[ID].id, infatti se si preferisce $game_party.actors[ID].id, in tal caso ID deve essere sostituito con la posizione del personaggio nel party, qui la prima è ID 0 non 1… so che è un casino ricordarsi dove il primo è 0 oppure 1 ma non sono io a deciderlo, comunque utilizzando questo codice, per esempio $game_party.actors[0].id, si avrà l’ID del personaggio posizionato per primo nel party.
Name – Iniziamo ora la parte più importante, anche se nel caso del nome pure sarà uguale per tutte le schede quindi credo che anche in questo caso eviterò di spiegare sempre le stesse cose, tranne se serve aggiungere dettagli; ebbene il nome può essere quello che volete, sempre nei limiti del numero dei caratteri, persino tutti uguali, anche se lo sconsiglio come al solito e… tutti qui? Si.
SCRIPT – Similmente a prima $data_actors[ID].name per sapere il nome; va notato che negli esempi tendo a scrivere in minuscolo ciò che va scritto così com’è (scriverlo proprio in minuscolo), mentre in maiuscolo ciò che va cambiato in base alle esigenze.
Class – Finalmente qualcosa di diverso dalle altre schede, qui si dovrà semplicemente scegliere che classe deve essere il personaggio, dato che spiegherò la scheda delle classi per ora non specifico cosa cambia.
SCRIPT$data_actors[ID].class_id darà l’ID della classe scelta, qui poi si dovrà approfondire nella scheda Classes.
Initial, Final Level – Qui invece si dovrà specificare il livello che il personaggio dovrà avere all’inizio, poi il massimo che potrà raggiungere, entrambi minimo 1 e massimo 99.
SCRIPT$data_actors[ID].initial_level per avere il dato inserito nel primo, $data_actors[ID].final_level il dato inserito nel secondo.
EXP Curve – Traducibile in “curva dell’esperienza”, intende in che modo bisogna calcolare quanti punti esperienza deve guadagnare per aumentare di livello, andando nelle impostazioni ci saranno 2 schede: “To Next Level” per visualizzare quanti punti deve guadagnare per superare quel livello, mentre “Total” quanti punti esperienza totali avrà guadagnato appena raggiunto quel livello; per determinare questa curva ci sono poi 2 valori da impostare, entrambi minimo 10 e massimo 50, che sono: “Basis” è la quantità minima per ogni livello, senza “Inflation” (che non è possibile essendo minimo 10) per ogni livello servirebbe la stessa quantità di esperienza, a dirla tutta però viene usato un calcolo così complesso che credo sia inutile spiegare, c’è per fortuna la tabella che indica quanti punti esperienza servono.
SCRIPT – Nel caso vorreste questi 2 ultimi valori negli script utilizzate $data_actors[ID].exp_basis o $data_actors[ID].exp_inflation poi $game_actors.exp (non accettato con “data” quest’ultimo) per sapere la quantità di esperienza guadagnata; se invece si vorrebbe conoscere la quantità di esperienza guadagnata ma con $data_actors, dopo il punto va scritto “exp_s”, mentre “next_rest_exp_s” per sapere quanti punti mancano per superare il livello attuale o ancora “next_exp_s” quanti punti totali si avranno una volta raggiunto il prossimo livello.
Character, Battler Graphic – Nel primo si seleziona il “charset”, ovvero come apparirà sulla mappa, mentre “Battler Graphic” come apparirà in battaglia.
SCRIPT$data_actors[ID]. “character_name” per avere il nome dell’immagine, a proposito di ciò, vedrete che quelli di base di RPG Maker XP hanno un numero all’inizio ma non è l’ID dell’immagine e solo un modo per ordinarli allo stesso modo come si trovano nel database, quindi anche quel numero fa parte del nome, se ne inserite una vostra potete anche non mettere il numero, inoltre essendo file all’interno di una cartella dovranno avere tutti nomi diversi e non per forza corrispondere al personaggio; poi c’è “character_hue”, che fa riferimento alla stessa immagine ma l'”hue” di quest’ultima, cos’è l’hue? Praticamente potete dare un filtro colorato all’immagine, per appunto cambiargli colore anche se ho sempre preferito, per comodità, creare io stesso una nuova immagine con colori cambiati quindi fate come preferite.
Allo stesso modo c’è “battler_name” e “battler_hue”, hanno lo stesso scopo ma fanno riferimento all’immagine di battaglia.
Parameters – Traducibile in “parametri” ma più comunemente chiamati/e statistiche, ovvero attacco, difesa, ecc… , in questo specifico caso: MaxHP, i punti salute massimi, quelli che se vanno a 0 il personaggio è KO; MaxSP, i punti speciali massimi, quelli che vengono consumati dalle Skills (Abilità); STR sta per Strong (Forza), quindi più è alto il valore maggiori danni fisici farà il personaggio; DEX sta per Dexterity (Destrezza), va a influire sulla precisione degli attacchi fisici; AGI sta per Agility (Agilità), va a influire sulla probabilità di schivare un attacco fisico e nella fuga da una battaglia; INT sta per Intelligence (Intelligenza), similmente a STR ma per i danni magici.
Spiegato cosa sono questi valori, ora potete modificarli come meglio credete, doppio click su uno dei riquadri e si aprirà la schermata per le modifiche; c’è “Quick Setting” che va da A a E, da più alto a più basso; oppure potete essere più precisi con “Level” e “Value” andando a specificare un livello poi quanto tale statistica deve valere in quel livello; ancora potete invece usare “Generate Curve”, specificando quanto deve valere al livello 1 a quanto al 99 e in che modo deve aumentare, se “Fast” raggiungerà valori maggiori a livelli inferiori senza però aumentare oltre il massimo speficicato, se “Middle” aumenterà in modo lineare, infine c’è “Slow” che tarderà a raggiungere i valori alti ma anche in questo caso al livello 99 comunque raggiungerà quello specificato; qui sta in voi, quale referite, potete anche utilizzare tutti e 3 i medoti in modo creativo.
SCRIPT – Qui bisognerà utilizzare un metodo diverso in base all’array che preferite; se $game_actors[ID]. seguendo poi con “hp”, “maxhp”, “sp”, “maxsp”, “str”, “dex”, “agi” o “int”, ho già spiegato a quali statistiche corrispondono, ebbene verrà dato il valore della statistica specificata, inoltre, SOLAMENTE CON QUEST’ARRAY, ci saranno statistiche extra da poter estrapolare, cioè: “atk”, “pdef”, “mdef”, “eva” o “hit”, nello stesso ordine, vogliono dire: “Attack” (Attacco) dato dall’arma che potenzia le skill fisiche; “Phisical Defense” (Difesa Fisica) che diminuisce i danni fisici subiti; “Magical Defense” (Difesa Magica) che diminuisce i danni magici subiti; “Evasion” (Evasione) che aumenta la probabilità di evitare un colpo; “Hit” (Colpire) che aumenta la probabilità di colpire.
In alternativa ci sono gli array $data_actors[ID]. e $game_party.actors[ID]., in questo caso bisognerà usare “parameters[N, LV]”, dove N potrà avere un valore da 0 a 5 che corrisponde alle statistiche seguendo quest’ordine: “maxhp”, “maxsp”, “str”, “dex”, “agi” o “int”, mentre LV col livello interessato, cioè se scrivete $data_actors[ID].parameters[0, 10], avrete il valore di “maxhp” al livello 10, indipendetemente dal livello del personaggio, facendo però caso che si avranno i valori base, senza considerare potenziamenti dovuti, per esempio, da un’arma, a differenza dell’array inizialmente specificata.
Starting Equipment – “Equipaggiamento Iniziale”, cioè l’equipaggiamento che avrà a partita appena iniziata, poi può essere cambiato o attraverso comandi o dal giocatore; non credo ci sia bisogno di precisare cosa si intende con equipaggiamento ma per completezza: è ciò che il personaggio “indossa”, arma, armatura e via dicendo, nello specifico 5: Weapon (Arma), Shield (Scudo), Helmet (Elmo), Body Armor (Armatura), Accessory (Accessorio), credo sia abbastanza intuitivo l’utilità di ognuno di loro ma con un pò di fantasia e bravura si può sempre essere originali, riguardo a chi crea il gioco.
Infine c’è una spunta per ogni pezzo dell’equipaggiamento con scritto “Fixed”, se attiva vuol dire che quello “slot” non può essere modificato, almeno con metodi tradizionali, lo si può fare, per esempio, attraverso comandi o permetterlo di farlo fare al giocatore dopo un certo evento di gioco.
SCRIPT$data_actors[ID]. (se non specifico $data e $game funzionano entrambi) “weapon_id” per avere l’ID dell’arma equipaggiata, si avrà 0 se non ne ha, mentre “weapon_fix” specifica, con true o false, se la spunta Fixed c’è all’arma; oppure usare “armor1_id”, “armor1_fix”, “armor2_id”, “armor2_fix”, “armor3_id”, “armor3_fix”, “armor4_id” o “armor4_fix” per il resto dell’equipaggiamento, con la stessa logica di weapon ma a cosa corrispondono? “armor1” corrisponde a “shield” per poi seguire, numericamente, “helmet”, “body armor” e “accessory”.

– CLASSES –

Passiamo ora alla scheda successiva, quella delle classi, questa è strettamente collegata a quella precedente, infatti è qui che si costruiscono le classi da dare poi ai vari “attori”, ma cosa sono esattamente le classi? É come dire, io sono un bravo falegname, tu un bravo pizzaiolo… chiaramente sono solo esempi a caso, in poche parole la classe è la specialità di un determinato, o più, personaggio ma basta con la teoria, passiamo alla parte davvero interessante.
SCRIPT – In tal caso usare l’array $data_classes[ID], sostituendo ovviamente ID con un numero, per avere la classe desiderata; se si vuole sapere l’ID della classe di un personaggio usare invece $game_actors[ID].class_id, dato che esistono vari modi per cambiare classe durante il gioco, in questo codice sostituire però ID con l’ID dell’attore, poi inserire tutto questo a posta di ID del codice $data_classes[ID]; riguardo sempre questo, anche qui sono presenti “.id” e “.name” per conoscere l’ID o il nome della classe.
Position – Come anticipato salteremo le parti identiche in tutte le schede, passiamo quindi subito alla “Posizione”, è possibile sceglierne 3: Front (Frontale), Middle (Centrale), Rear (Retrovia, NON letteralmente); non mi risulta che cambi qualcosa la posizione, almeno non negli script standard, potete quindi voi arricchire il codice e le tattiche di battaglia sfruttando quest’elemento.
SCRIPT$data_classes[ID]. per far ciò che ho detto dovete aggiungere “position”, facendo caso al punto aggiunto alla fine dell’array, come sempre facendo ciò si avrà il valore di tale elemento della classe, che darà un numero da 0 a 2 in base all’ordine.
Equippable Weapons, Armors – “Armi/Armature Equipaggiabili”, sarebbe a dire, quali armi e armature (prese dal database) è possibile equipaggiare a chi è di questa classe, di solito è per una questione tipo: il cavaliere può avere solo spade, l’arciere solo archi, il mago solo bastoni e così via, ovviamente potete fare come volete, ho solo spiegato il classico per farvi capire.
SCRIPT – Anche qui semplicemente usare il codice “weapon_set” o “armor_set”, in base a quale siete interessati, in questo caso si avrà un array (per richiamare il primo valore [0]) con tutte le armi o armature selezionate, per la precisione l’ID di tali.
Element, State Efficiency – “Efficacia Elemento/Stato”, gli elementi sono le varie tipologie di skill, i classici fuoco, acqua, tenembra, ecc…, mentre gli stati sono per esempio veleno, bruciatura, ecc… ; entrambi i valori vanno da A a F, partendo da maggior efficacia a minore, cioè colui che è di tale classe, se per esempio avrà A su fuoco, allora il fuoco gli farà il massimo male possibile.
SCRIPT – Similmente a prima, qui ci sono “element_ranks” e “state_ranks”, anche qui un array che però inizia con 1 ma invece che contenere l’ID degli elementi e stati, contiene valori che vanno da 1 a 6, cioè da A a F.
Skills to Learn – “Abilità da Imparare”, ecco con cosa bisogna maneggiare per specificare le skill da far imparare ai personaggi, scegliendo quale e a che livello.
SCRIPT – E ancora si avrà un array nell’array aggiungendo dopo il punto “learnings”, per far confusione stavolta il primo elemento si richiamerà invece con 0, non sono io che decido… comunque in tal caso ci sarà un ulteriore livello di array con elementi aggiuntivi “level” o “skill_id”, facciamo un esempio che sta diventando non difficile ma complesso: $data_classes[1].learnings[0].level, questo codice va a prendere la prima classe, poi la prima skill andando a dire il livello di quando la impara, ah, per essere sicuri specifico che se invece usate “skill_id” si avrà l’ID della skill, ovviamente in base alla scheda delle skill.

– SKILLS –

Ecco la scheda delle “Skills”, traducibile in “Abilità” ma come avrete visto preferisco usare il termine “skill” sia in singolare che plurale per abitudine; potremo anche definirle tecniche, giusto per avere un’idea più chiara di cosa sono, ma se avete giocato ad almeno un RPG dovreste già sapere di cosa si tratta, se siete giocatori Pokémon li vengono chiamate mosse e chissà in quale altro modo in altri giochi, in poche parole sono attacchi particolari… ma credo sia il caso di smetterla di ripetere le stesse cose con parole diverse.
SCRIPT – L’array base per questa scheda è $data_skills[ID], con i soliti “id” e “name”.
Icon – Beh, è abbastanza esplicativo immagino, qui dovrete scegliere l’icona da dare alla skill, presa dalla cartella Graphics->Icons del progetto o del programma; l’icona verrà mostrata ogni volta che si visualizza l’elenco delle skill, almeno di standard, sia in battaglia che dal menù principale.
SCRIPT – Semplicemente “icon_name” per visualizzare il nome dell’icona, ovviamente sto evitando di ripetere che bisogna usare l’array specificata all’inizio della spiegazione della scheda, aggiungendo un punto poi la scritta, credo ormai sia chiaro, no?.
Description – Ovvero “Descrizione”, non ha un utilizzo tecnico ma solo per far capire al giocatore cosa fa, facendo attenzione al limite di caratteri.
SCRIPT – “description” per visualizzarla all’interno di un codice.
Scope – Indica la skill a chi è indirizzata; “None” vuol dire nessuno, magari una skill che cambia le caratteristiche dell’arena ma non essendo presente nulla del genere nel codice standard dovrete programmarlo voi, se volete skill di questo tipo; “One Enemy” e “All Enemies” vogliono dire un nemico e tutti i nemici, mentre “One Ally” e “All Allies” un alleato e tutti gli alleati, ovviamente nemico o alleato in base a chi la usa, se la usa un avversario gli alleati sono sempre avversari, per il giocatore almeno; “(HP0)” vuol dire solo se è KO e in fine “The User” è proprio l’utilizzatore, quindi la skill ha effetto su chi la usa.
SCRIPT – “scope” darà un numero da 0 a 7 in base a quest’ordine: None, One Enemy, All Enemies, One Ally, All Allies, One Ally(HP0), All Allies(HP0), The User.
Occasion – Cioè in quali occasioni è possibile usarla, “Always” sempre, “Only in Battle” solo durante una battaglia, “Only from the Menù” solo dal menù, quindi per esclusione non durante la battaglia, in fine “Never” vuol dire mai ma a cosa serve una skill che non è mai utilizzabile? Anche in questo caso non c’è niente nei codici standard, potreste creare un’abilità passiva, quindi non ha bisogno di essere selezionata per funzionare, o cose del genere… magari approfondirermo questi argomenti, per ora mi limito a spiegare genericamente.
SCRIPT – “occasion” similmente a prima darà un numero da 0 a 3, seguendo lo stesso ordine di come le ho spiegate giusto sopra.
User, Target Animation – Come detto user si intende chi la usa, target invece vuol dire chi la subisce, il “bersaglio” della skill; qui selezionare che animazione mostrare, create nella scheda “Animations”, su chi la usa e sul bersaglio quando la skill viene usata, potete anche mettere nessuna animazione ma chiaramente è più bello da vedere, poi ovviamente se ha come Scope The User basta solo 1 animazione essendo entrambi la stessa “entità”.
SCRIPT – “animation1_id” per avere l’ID della prima animazione, quella sull’utilizzatore, mentre “animation2_id” per l’ID dell’animazione sul bersaglio, chiaramente l’ID dipende dalla lista della scheda Animations.
Menu Use SE – Se è una skill utilizzabile fuori dalla battaglia, potrete scegliere qui che suono far partire quando utilizzata.
SCRIPT – “menu_se” per avere il codice del file sonoro, l’utilizzo? Beh, potete per esempio usare il codice $game_system.se_play($data_skills[ID].menu_se) per far partire il suono della skill dell’ID specificato.
Common Event – Specificando se e quale evento comune avviare utilizzando la skill, gli eventi comuni li abbiamo già spiegati nella parte della guida dedicata agli eventi ma comunque se ve lo siete dimenticati sono gestibili dal database, potreste per esempio creare una skill che fa teletrasportare o chissà che, le possibilità sono chiaramente limitate se si tratta di una skill usata in battaglia; se si seleziona “(None)” vuol dire nessun evento.
SCRIPT – “common_event_id” per avere l’ID dell’evento comune, similmente a prima esiste un codice per avviare l’evento specificato, ed è: $game_temp.common_event_id = $data_skills[ID].common_event_id.
Parameters – Utilizziamo un termine già visto in Actors, per spiegare tutt’insieme quelli che sono i “parametri” delle skill; “SP Cost” specifica quanti punti SP servono per usare la skill, “Power” è la potenza, se negativa invece di danneggiare cura, “ATK-F”, “STR-F”, “DEX-F”, “AGI-F” e “INT-F” indicano la percentuale di quanto le statistiche di chi la usa vanno a influire sulla potenza; “EVA-F” si riferisce invece al bersaglio, in questo caso quanto influisce la sua evasione (probabilità di schivata), mentre “PDEF-F” e “MDEF-F” depotenziano in base a tali statistiche sempre del bersaglio; “Hit Rate” è la probabilità base della skill di andare a segno, mentre “Variance” devo dire di non aver capito molto ma da quello che ho capito più è alto maggiore sarà la “varietà” del danno, cioè che va da “n” a “n”, insomma se è 0 il danno è sempre lo stesso.
SCRIPT – Beh, semplicemente “sp_cost”, “power”, “atk_f”, “eva_f”, “str_f”, “dex_f”, “agi_f”, “int_f”, “hit”, “pdef_f”, “mdef_f” o “variance” per avere il numero segnato nella casella specifica.
Element – Qui mettere le spunte per specificare di che elemento è la skill, potete metterne nessuno, 1 o tutti, quanti e quali volete; l’elemento della skill va a influire con debolezze e resistenze di classi e nemici, andando quindi a potenziare o depotenziare la skill in base a chi la subisce; per modificare gli elementi presenti andare nella scheda System.
SCRIPT – “element_set” per avere un array con gli ID di tutti gli elementi della skill.
State Change – “Cambia Stato” cliccando su una casella apparirà un “+” poi un “-“, andando a specificare quali stati vengono aggiunti e quali tolti a chi subisce la skill.
SCRIPT – “plus_state_set” o “minus_state_set” per avere un array degli stati che vengono aggiunti o tolti dalla skill, anche in questo caso gli ID degli stati.

– ITEMS, WEAPONS, ARMORS –

Siamo ormai alla quarta scheda, quella degli oggetti, che vengono distinti da armi e armature, trovandosi quest’ultimi in schede a loro dedicate ma tutte e 3 fanno parte dell’inventario e molto simili tra loro, per questo li spiegheremo insieme andando però a specificare le cose diverse; esistono tanti tipi di oggetti diversi, curativi, danneggianti, d’evento (tipo servono per sbloccare un certo evento) e così via; beh, mentre armi e armature sono già esplicativi ma vedremo comunque come sfruttarli nel possibile… ovviamente come al solito all’inizio vado lento poi accelero, se c’è tanto da spiegare, perchè tanto molti concetti base è inutile rispecificarli ogni volta.
SCRIPT$data_items[ID] è l’array che contiene le info degli oggetti, $data_weapons[ID] le armi, $data_armors[ID] le armature, da rispecificare “id” e “name” per recuperare tale informazione.
Icon, Description – L’icona e la descrizione sono pari pari come nelle skill, l’icona giusto per dare un’immagine mentre la descrizione per spiegare al giocatore l’utilizzo.
SCRIPT – Come per le skill anche il codice, “icon_name” o “description” per avere tale informazione.
Scope, Occasion – Questi due valgono solo per Items e ancora come per le skill, Scope specifica su chi l’oggetto deve essere utilizzato: None, One Enemy, All Enemies, One Ally, All Allies, One Ally(HP0), All Allies(HP0) o The User; dove “Enemy” e “Enemies” sono nemico e nemici, “Ally” e “Allies” alleato e alleati, “HP0” solo se è KO in fine “User” chi usa l’oggetto.
Ripetendo anche Occasion: “Always” sempre, “Only in Battle” solo durante una battaglia, “Only from the Menù” solo dal menù, in fine “Never” vuol dire mai.
SCRIPT – “scope” da un numero da 0 a 7 seguendo l’ordine delle opzioni come elencate sopra, così come “occasion” ma va da 0 a 3.
User, Attacker, Target Animation – Target Animation per selezionare l’animazione che appare sul bersaglio, sia Items che Weapons; User Animation per l’animazione su chi usa l’oggetto, similmente a Attacker Animation ma nella scheda Weapons quindi chi usa l’arma.
SCRIPT – Anche qui “animation1_id” o “animation2_id” per la prima animazione (User o Attacker) o la seconda (Target).
Menu Use SE, Common Event – Quest’altri due ancora uguale alla scheda Skills, presente però solo in Items (considerando le 3 che stiamo spiegando ora); ricapitolando “Menu Use SE” è il suono che parte quando si usa mentre “Common Event” l’evento comune che viene richiamato, sempre quando si usa.
SCRIPT – Scusate la ripetitività anche qui l’utilizzo è pari alle skill con i codici, da mettere d’avanti a $data_items[ID]. in questo caso, “menu_se” o “common_event_id”, utilizzabili negli script allo stesso modo.
Kind – Passiamo finalmente a cose esclusive della scheda Armors, in questo caso va selezionata la tipologia, in che slot è possibile inserire tale “armatura”: Shield, Helmet, Body Armor, Accessory.
SCRIPT – “kind” seguendo ovviamente l’array delle armature, darà un numero che va da 0 a 3 seguendo l’ordine specificato sopra.
Auto State – Ancora esclusiva Armors, in questo caso bisogna specificare se e quale stato dare a chi viene equipaggiato tale oggetto, si potrebbe dare uno stato per potenziare ulteriormente o uno negativo per regolare il fatto che è un oggetto estremamente potente e così via.
SCRIPT – “auto_state_id” per avere un array che contiene gli ID degli stati specificati.
Parameters – Uhm… devo dire che qui potrebbe risultare complesso spiegare tutte e 3 le schede insieme quindi andremo 1 alla volta, tranne per “Price” che cel’hanno tutte e 3 e va a specificare il prezzo dell’oggetto/arma/armatura in un probabile negozio o simile.
Items: “Consumable” va a specificare se rendere l’oggetto consumabile o no con “Yes” o “No”, cosa vuol dire consumabile? Praticamente l’oggetto sparisce dopo l’utilizzo; “Parameter” e “Param Inc” il primo esclude il secondo se “None”, vuol dire quale parametro andare a potenziare, poi “Param Inc” di quanto, il potenziamento è definitivo; i vari “Rcvr” intendono “Recover” (Cura), gli HP e/o gli SP, in percentuale e/o quantità fissa; “Hit Rate” è la percentuale dell’oggetto di funzionare; “PDEF-F”, “MDEF-F” e “Variance” sono come per le skill, se per esempio è un oggetto che danneggia (Rcvr in negativo), questi valori possono modificare il danno inflitto.
Weapons e Armors: entrambi hanno “PDEF” (difesa fisica) e “MDEF” (difesa magica), cioè vanno a aumentare tali statistiche a chi li indossa, chiaramente sono potenziamenti che durano solo finchè vengono equipaggiati; di potenziamenti finchè l’hanno equipaggiato ci sono anche “ATK” (attacco) per Weapons e “Eva” (evasione) per Armors; non è finita qui con i potenziamenti (solita cosa), ci sono anche “STR+” (forza), “DEX+” (destrezza), “AGI+” (agilità), “INT+” (intelligenza).
SCRIPT – Anche qui divideremo la spiegazione, solito “price” per vedere tale info che va bene per tutte e 3 le array delle schede.
Partendo con Items: “consumable” darà “true” o “false” in base se è selezionato “Yes” o “No”, “parameter_type” va da 0 a 6 (none, max HP, max SP, str, dex, agi e int), “parameter_points” darà il valore specificato così come tutti quelli che seguono, “recover_hp_rate” “rate” si intende la percentuale, “recover_hp”, “recover_sp_rate”, “recover_sp”, “hit”, “pdef_f”, “mdef_f”, “variance”.
Weapons e Armors daranno tutti valori numerici: “atk” (solo Weapons), “pdef”, “mdef”, “eva” (solo Armors), “str_plus”, “dex_plus”, “agi_plus”, “int_plus”.
Element, State Change – E riecco una cosa già vista in Skills, stavolta sarà presente sia in Items che Weapons; “Element” è l’elemento dell’oggetto o dell’attacco eseguito con l’arma, può cambiare efficacia o danni in base a resistenza e debolezza di chi riceve; “State Change” aggiunge (+) o rimuove (-) uno stato a chi riceve l’effetto dell’oggetto o il colpo dell’arma.
SCRIPT – “element_set” per avere un array con gli ID di tutti gli elementi; “plus_state_set” o “minus_state_set” per avere un array degli stati che vengono aggiunti o tolti; chiaramente utilizzare l’array di Items o Weapons in base alle necessità.
Element, State Defense – Presente solo in Armors e aggiunge resistenza agli elementi e stati selezionati a chi cel’ha equipaggiata; resistenza agli stati vuol dire meno probabilità di subirlo, il massimo infatti lo rende immune a quello stato.
SCRIPT – “guard_element_set” o “guard_state_set” come di consueto danno un array con gli ID degli elementi o stati selezionati.

– ENEMIES –

Actors sono i personaggi del giocatore mentre Enemies quelli che dovrà affrontare, infatti come abbiamo già visto si potrebbe tradurre con “nemici”; in generale sono schede simili ma neanche tanto vedendo meglio, una cosa principale è che gli attori cambiano livello mentre i nemici no.
SCRIPT$data_enemies[ID] sostituendo ID con l’ID del nemico desiderato, similmente a Actors c’è anche $game_troop.enemies[ID], la “truppa” è il party nemico, così come l’array $game_party qui l’ID non deve essere del nemico ma della posizione all’interno del gruppo… “id” e “name” vale per tutte le schede, credo che non sia il caso di ripeterlo ancora.
Battler Graphic – Beh, “Grafica Lottatore”, in questo caso non ci sarà “Character Graphic” essendo, almeno di base, solo nemici da vedere in battaglia.
SCRIPT – “battler_name” o “battler_hue” fanno ancora riferimento alla “Battler Graphic”, il primo da il nome dell’immagine mentre il secondo il filtro applicato all’immagine (applicato dal database).
Parameters – Chiaramanete anche i nemici hanno parametri, o statistiche, ma in questo caso sono fissi e non variano in base al livello, almeno di base; non c’è altro da aggiungere, sono le solite statistiche viste e riviste, hanno lo stesso utilizzo.
SCRIPT – Chiaramente bisognerà scrivere il nome del parametro desiderato, per ordine ora li ripeto: “hp”, “maxhp”, “sp”, “maxsp”, “str”, “dex”, “agi”, “int”, “atk”, “pdef”, “mdef” o “eva”.
Attacker, Target Animation – Similmente a Weapon, “Attacker Animation” è l’animazione che apparirà, in questo caso, sul nemico quando attaccherà, mentre “Target Animation” quella che apparirà su chi colpisce.
SCRIPT – “animation1_id” o “animation2_id” per la prima o la seconda, sempre l’ID dal database ovviamente.
EXP, Gold, Treasure – Questi 3 valori vanno a indicare cosa si ottiene sconfiggendolo, “EXP” i punti esperienza che servono per aumentare di livello, “Gold” la moneta di gioco in fine “Treasure” (Tesoro) un oggetto, che può essere anche un’arma o armatura, andando anche a specificare in quante probabilità viene dato.
SCRIPT – “exp”, “gold”, “item_id”, “weapon_id”, “armor_id” o “treasure_prob” per avere uno di questi valori; “item_id”, “weapon_id”, “armor_id” daranno 0 se non c’è alcun oggetto/arma/armatura selezionata, mentre “treasure_prob” intende la probabilità nel dare il tesoro.
Element, State Efficiency – Qui per specificare l’efficacia di un elemento o stato contro tale nemico, A più efficace, F meno.
SCRIPT – “element_ranks” o “state_ranks” per avere un’array con ognuno dei valori da 0 a 5, cioè da A a F; utilizzando $game_troop.enemies[ID].state_guard?(ID) si avrà “true” o “false” in base a se è immune allo stato spacificato nel secondo ID.
Action – Sono le varie “Azioni” che può eseguire il nemico, doppio click sotto all’ultimo per aggiungerne una nuova; si può scegliere “Basic” (Base) o “Skill”, dato che sappaimo già sono sono le skill vediamo bene cosa si intende con Basic: “Attack” eseguirà un attacco standard, “Defend” si preparerà a incassare il colpo subendo meno danni, “Escape” fuggirà dalla lotta (se fuggono tutti i nemici la lotta finisce senza ottenere alcun che) in fine “Do Nothing” farà nulla… letteralmente.
La zona superiore chiamata “Condition”, intende in quali condizioni potrà eseguire tale azioni, si potrà scegliere “Turn” se passati un certo numero di turni, “+ … X” vuol dire che dopo aver raggiunto il turno si dovrà attendere ogni volta il numero di turni specificati nel secondo; “HP … % o below” se il nemico avrà quella percentuale di HP o meno; “Level … o above” se è presente un giocatore di quel livello o maggiore; “Switch” se la switch specificata è ON; chiaramente se la condizione non è vera allora l’azione non verrà eseguita. In fine c’è “Rating” che intende con quanta frequenza eseguire tale azione, va da 0 a 10, se più con lo stesso rating vuol dire che avranno la stessa probabilità di venir scelta.
SCRIPT – Qui per andare nei dettagli servirebbe una parte della guida creata di proposito, infatti meglio attendere di creare una parte dedicata alla battaglia; $data_enemies[ID].action è il primo livello dell’array che contiene le possibili azioni, poi aggiungendo “kind” darà 0 se “Basic”, 1 se “Skill”; “basic”, chiaramente se “kind” è 0, darà un numero da 0 a 3 seguendo l’ordine: attacca, difendi, fuggi, niente; “skill_id”, in questo caso se “kind” è 0, darà l’ID della skill; “condition_turn_a”, “condition_turn_b”, “condition_hp”, “condition_level” o “condition_switch_id” chiaramente fanno riferimento alla condizione; in fine “rating” al numero specificato per la frequenza.

– TROOPS –

Come già detto Troops sono il gruppo dei nemici, che vanno creati in questa scheda del database; per non far confusione, la lista a sinistra sono le truppe, mentre quella piccola a destra i nemici da selezionare (spiegherò bene poco giù); anche qui non scenderò nei dettagli che riguardano la battaglia ma solo il database.
SCRIPT – Come già visto c’è l’array $game_troop, come la variante che inizia con $data invece di $game, aggiungendo “.enemies” si avrà l’array dei nemici che contiene.
Enemies – Forse è proprio il caso di partire da questa zona, che nel database non c’è scritto niente ma c’è direttamente la lista dei nemici della scheda Enemies; a destra la lista, a sinistra l’anteprima mentre al centro per gestire il tutto, selezionando un nemico dalla lista poi il pulsante “” lo si rimuove; “C” immagino intenda “Clear” dato che svuota la truppa eliminando tutti i nemici presenti mentre “A” “Align” dato che li allinea visto che dall’anteprima è possibile posizionarli come più vi aggrada.
SCRIPT – Una cosa vista e rivista, “enemies” per l’array che contiene i nemici presenti nella truppa, da qui vedere la spiegazione della scheda Enemies per dettagli.
Autoname, [ED] Battleback, Battle Test – “Autoname” darà il nome in maniera automatica basandosi sui nemici presenti; “[ED] Battleback” per selezionare lo sfondo della battaglia, che sarà uguale in tutte le truppe; “Battle Test” per iniziare una battaglia di prova, creando il party come lo si desidera, utile per capire se dovete cambiare qualcosa o meno, se è equilibrato giusto insomma.
SCRIPT – Chiaramente “name” per vedere il nome, mentre direttamente “$data_system.battleback_name” per il nome dell’immagine di sfondo della battaglia, così come “$BTEST” che darà “true” o “false” in base al fatto se si sta eseguendo una battaglia di prova o no.
Battle Event – Cose già spiegate nella parte della guida degli eventi, lo sottolineo se qualcuno si trovi qui per caso e pensi che me ne sia dimenticato, giusto alcune precisazioni in script.
SCRIPT – “pages” per avere l’array che contiene le informazioni degli eventi della battaglia, seguono poi, sempre dopo “pages[N].” con N che specifica la pagina dell’evento, “condition” per le condizioni dell’evento, “Don’t Run” si intende “non farlo partire” l’evento; “span” va da 0 a 2 in base se si selezioni “battle”, “turn” o “moment” (sinceramente non ho capito cosa cambia, facendo prove); poi “list” per la lista di comandi presenti, anche qui andrebbe da approfondire tanto ma per ora voglio limitarmi a spiegare il database.

– STATES –

Wow, siamo vicini alla fine, avendo superato le schede più complesse, non che in States ci sia poco da spiegare ma neanche tanto, li abbiamo nominati spesso, qui è dove si creano gli stati, veleno, bruciatura, gelo e più chi ne ha più ne metta… sul serio, potete sbizzarirvi in tantissimi modi, vediamo nello specifico come.
SCRIPT$data_states[ID] è l’array che contiene gli stati del database.
Animation – Qui si seleziona l’animazione da mostrare su chi ne è affetto.
SCRIPT – “animation_id” per avere l’ID dell’animazione.
Restrinction – Chi ne è affetto potrà avere una delle seguenti restrinzioni: “None” se nessuna, “Can’t use magic” non può usare magie (intese le skill), “Always attack enemies” potrà solamente usare l’azione “attacca” sui nemici, “Always attack allies” come prima ma sui alleati, “Can’t move” non potrà muoversi, far nulla quindi.
SCRIPT – “restrinction” darà un numero da 0 a 4 nello stesso ordine di come spiegate.
Nonresistence… Slip Damage – Speghiamo tutt’insieme le 5 spunte di cui ho nominato la prima e l’ultima; “Nonresistence” devo dire che questo proprio non ho capito cosa cambia, tra gli stati standard la tengono attiva solo quelli di potenziamento; “Regard as HP 0” farà andare gli HP a 0, innescando quindi il KO; “Can’t Get Exp” negerà il guadagno di punti esperienza a chi ne è affetto; “Can’t Evade” qui ho dei dubbi, mi viene da dire che chi ne è affetto non potrà schivare alcun colpo ma per correttezza specifico che non ho certezza; “Slip Damage” farà subire un tot di percentuale di danni, in base ai propri HP massimi, di standard è circa 1/10.
SCRIPT – In questo caso si avrà semplicemente “true” o “false” se la spunta c’è o no, nello stesso ordine di prima i codici sono: “nonresistance”, “zero_hp”, “cant_get_exp”, “cant_evade” o “slip_damage”.
Parameters – E rieccoci con questo termine per analizzare i vari parametri, in questo caso di States; “Rating” va a specificare quale stato ha maggiore priorità in un turno, cioè quale ha prima effetto e prima si calcola se si viene curati automaticamente (vedremo tra poco); poi tutti quelli che finiscono con “%” vanno a modificare la statistica specificata della perncentuale specificata, così come “EVA” che va da -100 a 100.
SCRIPT – Per avere i vari valori specificati andare proprio a specificare quale: “rating”, “hit_rate”, “maxhp_rate”, “maxsp_rate”, “str_rate”, “dex_rate”, “agi_rate “, “int_rate”, “atk_rate “, “pdef_rate “, “mdef_rate” o “eva”.
Release Conditions – “Condizioni di Cura” non è una traduzione letterale ma rende l’idea, come anticipato va a specificare in che modo curare lo stato in modo automatico, senza oggetti o altro; “Release at the end of battle” con questa spunta si specifica che lo stato si curerà appena finirà la battaglia, il che vuol dire che senza questa spunta rimarrà, solitamente gli stati di potenziamento o indebolimento vengono tolti a fine battaglia; “After … turns, … % change” cioè ogni quanti turni c’è possibilità di curare dallo stato, andando a specificare poi la percentuale, mettere 100 se lo si vuole rimuovere di sicuro; “Each physical damage deal, … % change” in questo caso invece c’è una percentuale di cura se si subisce un danno fisico.
SCRIPT – “battle_only” “true” o “false” se la spunta c’è o no, “hold_turn” per i turni di cura, “auto_release_prob” per la probabilità specificata nei turni, “shock_release_prob” invece la percentuale di cura subendo un attacco fisico.
Element Defense, State Change – Il primo è come per Armors, aumenta la resistenza di un certo stato, mentre il secondo come per Weapons, “+” per aggiungere uno stato, “-” per rimuoverlo.
SCRIPT – Anche i codici sono gli stessi, ovviamente sempre specificando l’array della scheda desiderata; “guard_element_set” darà l’array degli elementi selezionati, “plus_state_set” o “minus_state_set” per l’array degli stati aggiunti o tolti.

– ANIMATIONS –

Eeeh… mi ero dimenticato che anche per questa scheda servirebbe una parte di guida apposta per scendere nei dettagli, il che mi spinge a spiegare a grandi linee, almeno per ora. Tanto per iniziare le abbiamo nominate spessisimo quindi credo che vi siete fatti un idea ampia su cosa servono, sul come creare in verità è molto più facile di come sembri, solo ci sono molte opzioni, per questo ho detto che non scenderò nei dettagli, per ora dico solo che se sapete usare programmi di grafica, tipo Photoshop o Gimp, o di montaggio video, di sicuro non avrete difficoltà a capire bene come funziona.
SCRIPT – Chiaramente l’array delle animazioni sarà $data_animations[ID].
Animation Graphic – Come prima cosa serve scegliere/creare un’immagine che contiene i possibili frame dell’animazione, massimo 5 per riga.
SCRIPT – Soliti “animation_name” o “animation_hue” per nome e filtro dell’immagine selezionata.
Position, Frame – Per selezionare la posizione di dove appare l’animazione, sopra, centro, sotto o… schermo? Quest’ultima immagino al centro dello schermo; poi “Frame” per precisare di quanti frame volete che duri.
SCRIPT – “position” 0 se “top”, 1 se “middle”, 2 se “bottom”, 3 se “screen”; “frame_max” conterrà il numero di frame di quanto dura l’animazione.
Frames – Tra il pulsante “Back” e “Next” si trovano i singoli frame, utilizzando questi pulsanti infatti ci si muove al frame precedente o successivo, ma sappiate che è più comodo farlo con le frecce della tastiera o andando a selezionare quello desidato col mouse.
É qui, grazie anche all’anteprima appena a destra, che si costruisce l’animazione, studiamo quindi prima l’anteprima, ci sarà un Actors di standard ma è possibile cambiarlo dal pulsante “[ED] Battler” e servirà solo d’esempio, poi vedrete delle linee verdi che vanno a dividere a metà orizontalmente e verticalmente l’area dove averrà l’animazione, infatti in base a “Position” saranno posizionate in modo diverso; poi dei riquadri arancio e blu numerati, quelli arancio sono del frame attuale mentre quelli blu di quello precedente, per avere un’idea della fluidità dell’animazione.
Per creare finalmente un animazione, selezionare un immagine sotto, che ricordo far parte dell’immagine selezionata su “Animation Graphic”, poi selezionare nell’anteprima dove volete che si posizioni, tranquilli se non vi riesce a primo colpo, potrete spostarla tenendo premuto col mouse, chiaramente ricordatevi di cambiare frame per avere un animazione.
Finito ci sono i pulsanti “Play Hit” e “Play Miss” per vedere l’animazione creata, cosa cambia tra i 2? Vedremo nella prossima opzione. Se spiego gli altri pulsanti rischio di farvi venir mal di testa, servono comunque solo ad accelerare probabili modifiche.
SCRIPT – “frames”… non saprei l’utilizzo pratico ma è un array che contiene i singoli frame.
Ricordate i riquadri aranci e blu numerati? Sono chiamate celle, infatti si possono aggiungere, a “frames[N].”, “cell_max” o “cell_data”, il primo specifica quante celle contiene il frame, il secondo specifica proprio i dati della cella, in un array che contiene tutte quelle del frame.
SE and Flash Timing – E non è finita, ci sono ulteriori possibili aggiunte per l’animazione, qui è possibile aggiungere suoni e flash, specificando in quale frame mentre “Condition”: “None” non cambia nulla, “Hit” solo se la probabile skill va a segno, “Miss” se non va a segno.
SCRIPT – Subito dopo l’array di Animation aggiungere “timings” per avere questi dati in un array, così come, dopo “timings[N].”, “frame”, “se”, “flash_scope”, “flash_color”, “flash_duration” o “condition” per le varie informazioni.

– TILESETS –

Sembra complicato ma non lo è affatto, i Tilesets servono a dare l’aspetto grafico alle mappe, oltre a altre cose come il raggiungimento o meno di un certo luogo, vediamo nei dettagli.
SCRIPT$data_tilesets[ID] per l’array degli elementi di questa scheda, sostituendo ID con quello desiderato, i solitissimi “id” o “name” vanno bene anche qui.
Graphic – Qui come vedrete esistono molti file immagine, li possiamo spiegare a gruppo, senza andare troppo nel dettaglio; “Tileset Graphic” per l’immagine base; “Autotile Graphic” per quelli che si vanno ad adattare in modo automatico, dovete solo “spalmarli” e creerà gli angoli, o simili, in automatico, sempre se è fatto bene, massimo si possono avere 7 autotile per ogni tileset; “Panorama Graphic” sarà lo sfondo, visibile solo se ci sono tile in parte o totalmete invisibili; “Fog Graphic” per scegliere se e in che modo apparirà la nebbia (fog, appunto), esiste anche un comando negli eventi comunque; “Battleback Graphic”, in Troops si è già scelto lo sfondo di battaglia ma verrà visualizzato quello selezionato in Troops se non ce ne alcuno nel Tileset.
SCRIPT – Per avere l’informazione su quale immagine si ha impostato nel tileset aggiungere all’array base: “tileset_name”, “autotile_names” (array contenente tutti i 7, con ID da 0 a 6), “panorama_name”, “panorama_hue”, “fog_name”, “fog_hue”, “fog_opacity”, “fog_blend_type”, “fog_zoom”, “fog_sx”, “fog_sy”, “battleback_name”.
Tile – Traducibile in “Piastrella”, un tileset è appunto diviso in tante piastrelle, 32×32 pixel, che vanno a creare la mappa, non solo graficamente, vediamo ora a che servono i vari pulsanti:
“Passage” darà la “passabilità” a un tile, la prima riga, escluso il primo tile a sinistra, sono presenti i vari autotile selezionati, questi (anche quello non autotile) potranno avere 3 tipi di passage: cerchio, croce o quadrato, mentre gli altri solo cerchio o croce, ma cosa cambia ciò? Il cerchio indica che è un tile che il giocatore potrà calpestare; la croce invece sarà un tile che bloccherà il giocatore, di conseguenza non calpestabile; in fine il quadrato è un pò più complesso, se si creerà una linea orizzontale a tile singolo, il giocatore potrà passare oltre come fosse un cerchio, mentre 2 o più no, o meglio sarà “calpestabile” (in prospettiva copre il giocatore) solo il tile più in alto, tutti gli altri saranno come quelli impostati su croce.
“Passage (4 dir)” è simile a passage ma più preciso, vedrete punti o frecce nei 4 punti cardinali per ogni singolo tile, questo per specificare da che direzione è possibile raggiungere tale tile così come la direzione dove è possibile “lasciarlo” quando ci si trova sopra; chiaramente una freccia indica che quel punto cardinale è accessibile mentre un puntino no.
“Priority” per indicare la priorità di una tile rispetto agli altri e giocatore, indicandolo con una stella e un numero, fino a 5, se un puntino la priorità è 0 mentre il giocatore ha priorità 1 (modificabile ma per ora non vedremo come); tale valore si riferisce alla prospettiva, un pò come aggiungere la terza dimensione (Z oltre a X e Y) anche se la grafica è 2D, per esempio potete creare una tettoia dove il giocatore potrà camminarci sotto ma, essendo una visuale dall’alto, la tettoia coprirà il giocatore, mettendola a una priorità alta (2 dovrebbe bastare).
“Bush Flag” bush vuol dire cespuglio quindi serve per indicare se dare l’effetto cespuglio o meno, come sempre il puntino indica che non c’è mentre, in questo caso, le ondine si; praticamente il tile, se calpestato, coprirà in parte il giocatore e farà un leggero movimento quando il giocatore si muoverà.
“Counter Flag” se puntino disattivato, se rombo attivato ma a cosa serve? Ammetto che mi sono informato proprio mentre scrivevo perchè non ho mai avuto occasione di provarlo ne capirlo; praticamente immaginate di avere un tile con questo “flag” attivo (quindi col rombo), un’altro in una qualsiasi delle quattro direzioni, poi un evento posto oltre il secondo tile col rombo avente come trigger “Action Button”, di norma dovete per forza porvi a uno dei tile appena vicini per attivare l’evento, no? Ebbene grazie a “Counter Flag”, se vi mettete al tile più lontano avente il rombo, girati verso l’evento, se cliccate l’evento si attiverà comunque anche se c’è 1 tile di distanza tra giocatore e evento, con maggiore distanza però non succede, ricordate però che il rombo deve averlo sia il tile sotto al giocatore sia quello verso la direzione dell’evento; questo può essere utile se magari si deve parlare a un NPC (Non Player Character) che si trova dietro un bancone.
“Terrain Tag” darà, chiaramente a scelta, un numero da 0 a 7 a ogni tile, l’utilizzo è puramente script o comando, per esempio spesso negli RPG è possibile attraversare le acque con imbarcazioni o altro ma non tutte, quindi si possono creare dei tile trasparenti con un valore specifico da mettere solo sulle sponde che si vuole permettere di attraversare, oppure in alcuni punti si potrà eseguire un salto e così via, sono solo esempi ma sbizzaritevi pure… ah, vedremo poi in SCRIPT come fare ciò, per ora ho spiegato più teoria che pratica.
Parlando dei Tile non possiamo non tornare sui “Layer”, ovvero “Strati”, come anticipato all’inizio della guida esistono ben 3 layer di tile, oltre al 4° occupato dagli eventi, ebbene servono per risparmiare tile nel tileset, per esempio potrete fare un percorso in autotile senza bordi, in modo da non crearne uno per ogni “bioma” in base alle varie zone della mappa, che sia terra, sabbia, roccia o chissà che, al primo layer mettere la superficie mentre nel secondo il percorso, così come tantissimi altri possibili utilizzi pratici; comunque va sottolineato, a parte casi specifici, il tile presente nel layer più in alto avrà priorità maggiori e non mi riferisco a “Priority” ma a “Passage” e “Passage (4 dir)”, se per esempio nel layer1 c’è un tile non calpestabile mentre nel layer2 ce n’è uno calpestabile, allora il giocatore potrà raggiungere quelle coordinate X e Y, così come se invertiti non potrà raggiungerle; l’eccezione è il tile numero 0, quello presente nella riga dei 7 autotile, di norma ha passabilità “cerchio” ma è anche considerato tile vuoto, verrà preso in considerazione solo se tutti e 3 i layer sono vuoti, in tal caso ricordate di “giocare” con “Passage (4 dir)” se volete zone dove è possibile vedere lo sfondo ma non volete che siano calpestabili/raggiungibili.
SCRIPT – Ed eccoci qui a spiegare la parte script degli argomenti… spiegati; ricordo che i “comandi” che ora andrò a elencare vanno aggiunti a $data_tilesets[ID]. per avere l’informazione desiderata, a dirla tutta questi non ho avuto occasione di approfondirli ma almeno le basi le conosco e prima di spiegarli va specificato che ogni tile del tileset ha un ID (a “$data_tileset” però va l’ID del tileset), quello vuoto 0 poi seguono gli autotile ma non 1 il primo autotile, 2 il secondo autotile bensì:
Quello vuoto si 0, ma gli autotile hanno un gruppo di ID in base se si tratti di una linea, orizzontale, verticale, un angolo e così via, è una cosa che mi studiai perchè mi serviva per un progetto, è facile da capire ma lungo quindi evito di andare nei dettagli, il primo autotile va da 48 a 94, il 95 viene saltato per poi passare al secondo autotile dal 96 a 142 e così via, a gruppi di 47 (va contato anche il primo) saltando un numero fino all’ultimo autotile, da 336 a 382, per poi proseguire a 1 a 1 i tile del tileset partendo da 384; per evitare di confonderci però credo sia giusto definire l’ID del tile più come “posizione” del tile.
Spiegato ciò che era doveroso per farvi capire, ecco i comandi per estrarre le informazioni spiegate, dove N va sostituito alla posizione del tile desiderato: “passages[N]” è effettivamente quello che mi ha messo in difficoltà a capirlo, da un valore diverso in base a “Passage”, “Passage (4 dir)”, “Bush Flag” e “Counter Flag”, un valore che somma tutti queste caratteristiche, 0 se è accessibile da tutte le 4 direzioni e niente Bush ne Counter, a questo 0 si aggiunge 1 se non è possibile accedervi da sotto, 2 se non da sinistra, 4 se non da destra, 8 se non da sopra, 64 se Bush e 128 se Counter, la difficoltà viene dal fatto che se possiede più di queste caratteristiche il numero che verrà fuori sarà la somma dei numeri descritti… ora capite la problematica? Volendo esiste un algoritmo neache difficile che però non spiegherò per non complicare ulteriormente il discorso ma se a voi interessa soltanto se il giocatore, o altro evento, può calpestare i tile presenti in determinate coordinate basta usare “$game_player.” per il giocatore o “$game_event[ID_EVENTO].” per un evento, poi “passable?(X,Y,D)”, specificando le coordinate della mappa con X e Y mentre D la direzione, riferito a “Passage (4 dir)”, se D 0 allora se il tile è in qualche modo calpestabile, avendo quindi almeno 1 direzione accesibile, mentre 2 se sotto, 4 se sinistra, 6 se destra o 8 se sopra; darà come risultato “true” o “false” se può passare o no.
Uff… spiegato quello complicato, fa ridere sapere che invece i due che seguono sono di una semplicità disarmante: “priorities[N]” darà il valore da 0 a 5 specificato mentre “terrain_tags[N]” un valore da 0 a 7… si, tutto qui.

– SYSTEM –

Common Events la saltiamo avendo già fatto una parte della guida sugli eventi, dove ho specificato cosa cambia in un evento comune, passiamo quindi all’ultima, finalmente, scheda… System! Se siete rimasti qui dall’inizio alla fine, senza pause, anche di giorni, che dire, grazie e complimenti ma la prossima volta evitate, non credo sia tanto salutare, metto i titoli in base all’argomento in modo molto evidente proprio per permettervi di fare pause e tornare facilmente all’argomento dove avevate lasciato.
La scheda del database System vedrete subito che è tanto diversa dalle altre, quindi andremo nei dettagli per ogni zona, anche perchè ce ben poco da dire… poco ma potrebbe comunque portare una spiegazione non tanto breve.
SCRIPT$data_system per la variabile di questa scheda, ebbene si, stavolta non si tratta di array ma alcuni dei comandi che seguono saranno invece array.
Initial Party – Qui si avrà il party di inizio gioco, chiaramente modificabile proprio da questa scheda.
SCRIPT – “party_members[N]” per sapere appunto i componenti iniziali del party, dove N può essere da 0 a 3, per le 4 posizioni del party; poi, seguendo sempre “$data_system.”, c’è “start_map_id”, “start_x” o “start_y” si riferisce allo stesso ma su mappa.
Element Names – Per fare una lista degli elementi, solo i nomi, per altre carattestiche bisogna modificare le altre schede.
SCRIPT – “elements[ID]” sostituendo l’ID con l’elemento desiderato, il primo avrà ID 1, si avrà direttamente il nome dell’elemento.
System Graphic / BGM / ME / SE – In questa zona sono presenti vari file immagini e audio, basta leggere (tradurre se non capite l’inglese) per capire subito a che servono, l’unico non tanto intuitivo è “Windowskin Graphic”, cambiando questo file cambierete la grafica di finestre e menù di gioco, chiaramente posizionando i vari elementi nella medesima posizione.
SCRIPT – Beh, semplicemente per avere l’informazione desiderata basta aggiungere alla variabile base uno dei seguenti comandi: “windowskin_name”, “title_name”, “gameover_name”, “battle_transition”, “title_bgm”, “battle_bgm”, “battle_end_me”, “gameover_me”, “cursor_se”, “decision_se”, “cancel_se”, “buzzer_se”, “equip_se”, “shop_se”, “save_se”, “load_se”, “battle_start_se”, “escape_se”, “actor_collapse_se” o “enemy_collapse_se”.
Words – Letteralmente “Parole”, cioè come volete che vengono chiamati i vari elementi di gioco.
SCRIPT – In questo caso deve prima seguire “words.” poi “gold”, “weapon”, “armor1”, “armor2”, “armor3”, “armor4”, “attack”, “skill”, “item”, “guard”, “equip”, “hp”, “sp”, “atk”, “pdef”, “mdef”, “str”, “dex”, “agi” o “int”, ricordando che sono solo testi, parole senza un valore numerico o altro.

– CONCLUSIONE –

Ohhh mamma… non mi aspettavo che sarebbe venuto così lungo, infatti in alcuni punti ho accelerato, se quei punti sono poco chiari avvisate che cercherò di essere più preciso e chiaro… ebbene abbiamo finito, alla prossima! Ancora indeciso sull’argomento della prossima parte.

Guida RPG Maker XP Script #6 – Eventi


Ed eccoci in una nuova parte della guida, ne è passato di tempo dall’ultima questo perchè volevo riflettere bene cosa trattare ora che almeno le basi ci sono, anche se mancano ancora alcune cosette per fare un gioco per bene, infatti proprio per questo ho deciso che, ok che la guida si basa sugli script ma con l’obbiettivo ultimo di creare un gioco ben fatto, di conseguenza bisogna trattare anche argomenti non script, anche se ogni cosa di RPG Maker XP può interagire con gli script ma se non la si conosce bene come si può capire come interagirci? Ecco che stavolta parliamo degli “eventi”, un argomento parecchio ampio che quindi cercherò di riassumere il più possibile, dando informazioni a volte imprecise ma sempre complete, quel giusto per capire insomma.

Come detto, qualsiasi argomento trattato su RPG Maker XP può in un modo o nell’altro intrecciarsi con gli script, nel caso degli eventi ci sono gli script, già preinseriti di standard, “Game_Event” e “Interpreter” (dall’1 al 7), racchiusi in classi con lo stesso nome contenenti un bel numero di def, uno sguardo inesperto chiaramente non ci capirà nulla ma siete qui per questo, no? Prima di iniziare vi ricordo che per gestire gli eventi in mappa deve essere attivo il layer a forma di cubo, passandoci col mouse sopra uscirà appunto la scritta “Events”, cioè eventi, in seguito per creare un nuovo evento fare doppio click sul punto della mappa desiderata oppure premere il destro del mouse poi “New Event…”; non si possono creare più eventi nella stessa posizione ma ciò può accadere durante il gioco facendo muovere gli eventi.



Ricicliamo un screen mostrato in parti precedenti della guida, come dico sempre per accrescere le proprie conoscenze bisogna partire da ciò che già si conosce… filosofie a parte analiziamolo ora nella sua interezza:

– ID –

Partiamo dall’alto quindi la barra dov’è presente la X per chiudere la finestra (solo dell’evento in questo caso) al limite destro, appena a sinistra di tale è anche presente un punto interrogativo che effettivamente spiega, in modo minimale, le varie parti della schermata dell’evento; vediamo ora la scritta al centro “Edit Event – ID:001”, non fa altro che dire l’ID dell’evento (in questo caso 1, come vedete), ogni mappa ha i suoi eventi con ID che partono da 1 e, giustamente, aumentano man mano che se ne crea uno nuovo, se si elimina un evento, quelli di ID successivi NON cambiano il proprio ID per riempire lo spazio svuotato, se per esempio si hanno eventi dal 1 al 5, se si elimina il 3, il 4 e il 5 restano il 4 e il 5, va specificato perchè alcuni darebbero per scontato il contrario.

– NOME –

Scendendo ci sono vari pulsanti e un riquadro testo, quest’ultimo ha sopra scritto “Name:” facendo quindi capire che nel riquadro va scritto il nome dell’evento, appena creato sarà tipo come lo vedete qui “EV001”, sostituendo quel 001 con l’ID dell’evento ma potete dargli qualsiasi nome vogliate, nel limite di lunghezza, vanno bene anche tutti uguali ma chiaramente è sconsigliato, se proprio volete più eventi con lo stesso nome vi consiglio di distinguerli con numeri progressivi.

– PAGINA –

Passiamo ora ai vari pulsanti: “New Event Page”, “Copy Event Page”, “Paste Event Page”, “Delete Event Page” e “Clear Event Page”, tutti fanno riferimento a “event page” cioè “pagina evento”, poi ognuno ha un azione diversa, per chi non è ferrato con l’inglese praticamente: nuova, copia, incolla, elimina e pulisci; prima di spiegare i pulsanti va spiegato cos’è una pagina evento: vedete quel numerino 1 appena sotto? Ebbene specifica che questa è la pagina 1 dell’evento, in caso di più pagine quella maggiore ha la priorità sulle altre, con le prossime cose vedremo in che modo gestire questa cosa, intanto va specificato che per capire quale pagina è attualmente attiva nella finestra delle impostazioni evento, quelle non attive visivamente ricordano un pulsante.
Andiamo ora a spiegare i pulsanti, anche se è abbastanza scontato a questo punto: “new” aggiunge una nuova pagina, “copy” copia la pagina attualmente attiva, “paste” incolla la pagina copiata (anche da un evento diverso), “delete” elimina la pagina attiva, infine “clear” resetta la pagina attiva, cioè come fosse stata appena creata; va poi notato che nel screen i pulsanti paste e delete sono disattivi perchè, nel primo non avendo in memoria una pagina copiata non ha nulla da incollare, nel secondo perchè questo evento ha solo 1 pagina, non perchè è la prima, se ne avesse 2 si poteva eliminare la 1 e la 2 diventerrà la 1, quindi a differenza degli ID degli eventi, in caso una pagina venga eliminata quelle successive diminuiscono di 1.

– CONDIZIONI –

Le prossime impostazioni che vedremo sono quelle racchiuse nel riquadro “Conditions”, leggendo la parte della guida che spiega le condizioni è già chiaro di cosa si tratta quindi eviterò di scendere nei dettagli stavolta; qui vengono specificate le condizioni per far si che la pagina evento sia attiva, ecco a cosa mi riferivo quando ho parlato di priorità tra le pagine dell’evento, se non ci sono condizioni ovviamente la pagina sarà sempre attiva, se è un evento a più pagine con condizioni risultanti vere (“true” in linguaggio RGSS), quella col numero maggiore tra queste è quella che viene considerata, avendo appunto priorità su quelle minori, se invece la pagina 1 ha condizioni vere ma la 2 no, allora la 1 è quella in esecuzione (utilizzo termini diversi per far capire meglio), per far si che una condizione risulti vera tutte le ipotesi specificate devono valere, qui non esiste il “o” ma solo il “e”; riguardo alle ipotesi vedremo più avanti a cosa si riferiscono, sempre in questa parte della guida o la prossima se viene troppo lunga.

– GRAFICA –

Ecco ora il riquadro sotto la scritta “Graphic:”, facendo doppio click su di esso (il riquadro non la scritta) si va appunto a modificare la grafica dell’evento, cos’è essattamente la grafica dell’evento? Semplicemente come appare in mappa; si potrà scegliere tra i “charset” (immagine contenente i vari frame di movimento, 4×4 nel caso dell’XP), anche qui vigila la regola dove i puntini blu indicano che non è presente nella cartella del progetto/gioco, al contrario se il puntino è rosso; scegliendo invece “(none)” si sceglierà di non dare un immagine all’evento, mentre “(Tileset)” si sceglierà appunto un “tile”… beh, dal “set” disponibile… mi spiego meglio: per ora non approfondisco ma nelle impostazioni della mappa, modificabili andando nella lista nell’angolo basso sinistro della schermata principale poi “Map Propreties…”, c’è appunto da scegliere un tileset, cioè un’immagine contenente le possibili “piastrelle” (traduzione letterale di “tile”) che andranno a creare la mappa, per le impostazioni dei tileset andare nel database ma come detto per ora non approfondisco… insomma, ricapitolando potete selezionare un tile dal tileset della mappa.

– MOVIMENTO –

A destra della grafica ci sono varie impostazioni denominate “Autonomous Movement”, in italiano “movimento autonomo”, cioè come l’evento si deve muovere senza bisogno di dirglierlo attraverso un comando; si sono 3 valori da impostare: “Type” cioè il tipo, “Speed” cioè velocità infine “Freq” cioè la frequenza, è difficile spiegare la differenza di questi ultimi due, infatti io stesso faccio fatica a trovare il giusto equilibrio per andare a creare ciò che voglio quindi non ho molto da dire a riguardo; avrete notato anche “Move Route…”, cioè percorso di movimento intendendo che percorso deve fare, tale impostazione va usata dopo aver selezionato il “Type” “Custom”, cliccandoci troverete, oltre ai vari possibili movimenti da poter fare (che spiegherò in seguito), anche altre impostazioni da spuntare o meno: “Repeat Action” e “Ignore If Can’t Move”, il primo intende che le istruzioni date devono essere ripetute all’infinito, altrimenti lo farà solo 1 volta, mentre “Ignore If Can’t Move” se c’è la spunta salterà le istruzioni non eseguibili, se per esempio deve andare a destra ma a destra c’è un ostacolo, mentre senza spunta resterà fermo in attesa di poter eseguire l’istruzione.
Gli altri tipi sono: “Fixed” cioè l’evento resterà immobile, con “Random” farà un passo in una direzione sempre casuale, per concludere c’è poi “Approach” che farà muovere l’evento verso l'”eroe”, cioè il personaggio controllato dal giocatore.

– OPZIONI –

Passiamo ora alle “Options”, letteralmente “Opzioni”, ci sono varie spunte da attivare o meno: “Move Animation” intende se durante il movimento deve esserci un animazione, ricordate quando ho parlato dei charset dicendo che sono frame di movimento? Ebbene verticalmente sono le diverse direzioni: sotto, sinistra, destra e sopra, mentre orizzontalmente le animazioni, tenendo quindi la spunta su “Move Animation” l’evento cambierà la sua grafica spostandosi tra i frame orizzontali del charset; “Stop Animation” è simile a quello precedente con la differenza che l’animazione verrà eseguita se sta fermo; con “Direction Fix” si intende che anche se l’evento cambierà direzione il charset mostrato resterà sempre nelle stessa direzione, cioè non cambierà i frame verticali; “Through” renderà intangibile l’evento, sia verso lui che lui verso gli altri, praticamente un fantasma che potrà attraversare anche i muri, in caso si selezioni un tile come grafica potrebbe già avere questa “abilità” in base alle impostazioni del tileset, di sicuro invece se ha “none” come grafica; concludiamo con “Always on Top”, cioè resterà sempre visibile sopra agli altri eventi, con o senza attivare “Through”.

– TRIGGER –

I “trigger” già li abbiamo spiegati in parti passate ma lo ripeterò per completezza, non prima di ricordare che l’impostazione selezionata va a specificare in che modo avviare i comandi dell’evento:

Action Button – Si avvierà quando il giocatore lo “toccherà” e cliccherà il pulsante azione (invio, spazio o “C”).
Player Touch – Si avvierà quando il giocatore tenterà di occupare il suo spazio.
Event Touch – Come Player Touch ma anche nel caso opposto, cioè anche se l’evento tenterà di occupare lo spazio del giocatore.
Autorun – Si avvierà bloccando tutto il resto andando in loop; esistono tanti modi per stopparlo, per esempio col comando “Erase Event” (“Cancella Evento” posto nella colonna a sinistra della prima pagina).
Parallel Process – Simile a “Autorun” con la differenza che non bloccherà il resto.

– PULSANTI FINESTRA –

Prima di andare oltre, in questa guida non voglio dare nulla per scontato dato che voglio essere chiaro anche a chi non se ne intende nemmeno di PC (magari lo incuriosisco); ebbene ci sono 3 pulsanti nell’angolo destro basso della finestra: “OK” per chiuderla a mantenere i cambiamenti, “Cancel” per chiuderla senza salvare i cambiamenti poi “Apply” per salvare i cambiamenti senza chiuderla.

– COMANDI –

Ecco il riquadro più grande e che giustamente salta più all’occhio, “List of Event Commands” traducibile in “Lista dei Comandi Evento”, l’ho lasciato per ultimo sia perchè capendo le cose precedentemente spiegate aiuta molto a comprendere questo sia perchè c’è davvero una marea di cose da dire su ciò; tanto per iniziare a evento appena creato si sarà una singola riga con “@>”, testo che va a introdurre ogni comando presente, per far capire quando finisce uno e inizia un altro perchè non sempre è scritto su una singola riga; doppio click su una riga vuota, o click destro poi “Insert…”, per inserire un nuovo comando all’evento, mentre per modificare uno già inserito premere spazio mentre è selezionato.
“Event Commands”, cioè i possibili comandi da aggiungere a un evento, si divide in 3 pagine che a loro volta si dividono in 2 colonne, quindi per intenderci in modo pratico e veloce specficherò pagina e colonna, vediano intando la lista, poi li spiegherò uno ad uno.





Pagina 1, partendo in alto nella colonna a sinistra…

Show Text – Per visualizzare un testo, per magari un dialogo, con un limite di larghezza e righe, per la larghezza si può andare anche poco oltre la freccia sopra al riquadro mentre per le righe massimo 3; in gioco, una volta visualizzato, attenderà l’input C prima di proseguire.
Ci sono varie curiosità utili da sapere, nel messaggio si potranno digitare alcuni comandi, come per esempio “\c[0]” (escluse virgolette) che cambia il colore del testo che segue, ce ne sono ben 8 diversi, inserendo un numero che va da 0 a 7 dove lo 0 è quello standard, volendo si possono anche cambiare questi colori andando in Script Editor -> Window_Base, precisamente “def text_color(n)”, i colori sono in RGB+Alpha, cioè Red, Green e Blue+Opacità (più quest’ultimo numero è basso più è trasparente), tutti e 4 possono andare da 0 a 255; inoltre c’è il comando “\v[n]”, dove “n” deve essere sostituito col numero della variabile gioco (spiegherò quando arriverà questo comando) da visualizzare.
Show Choinces – “Vedi scelte”, cioè bisognerà scrivere fino a un massimo di 4 possibili testi da selezionare, che di seguito si potrà creare un comando diverso in base a quale scelto, funziona praticamente come la condizione “case” e i testi seguiranno le stesse regole del comando precedente spiegato; nelle impostazioni di questo comando c’è “When Cancel”, che si intende in caso il giocatore dia l’imput B, ignorando praticamente le scelte, come insomma bisogna comportarsi: “Disallow” cioè costringi il giocatore a scegliere, “Branch” specifica cosa accade (può anche accadere nulla quindi ingorando del tutto la scelta) oppure fai come se avesse scelto l’opzione 1, 2, 3 o 4.
Input Number – Il giocatore dovrà inserire un numero, quel numero verrà poi memorizzato nella variabile gioco selezionata nelle impostazioni comando, sempre nelle impostazioni si dovrà specificare di quante cifre deve essere questo numero.
Change Text Option – Per cambiare le opzioni testo, riferito a “Show Text”, “Show Choinces” e “Input Number”; si potrà scegliere la posizione, sopra, centrale o sotto (Top, Middle o Bottom) e se mostrare o meno una finestra di sfondo al testo (Show o Hide); una volta cambiato valerà per tutti i testi che si visualizzeranno, anche di eventi diversi a meno che non si inserirà di nuovo questo comando, che di base è sotto con finestra.
Button Input Processing – Inserendo questo comando, una volta che l’evento che lo contiene viene avviato, si fermerà attendendo un input, in base all’input dato la variabile gioco selezionata nelle impostazioni comando avrà un valore numerico diverso: sotto = 2, sinistra = 4, destra = 6, sopra = 8, input A = 11, input B = 12, input C = 13, input X = 14, input Y = 15, input Z = 16, input L = 17, input R = 18, se non ricordate cosa sono questi input rivedetevi la parte della guida dove spiego appunto gli input.
Wait – Semplicemente si sarà un attesa di tanti frame quanti specificati, per chi non sa cosa siano i frame, dovete immaginare il gioco come una pellicola di un film (anche se ora gran parte sono digitali) o un rullino di una macchina fotografica (anche in questo caso non digitale), ebbene 1 frame è 1 riquadro della pellicola o foto del rullino; quando ho parlato di charset il frame inteso in quel caso è diverso.
Comment – Un pò come i commenti nel RGSS anche in questo caso serve solo per scrivere appunti tra un comando e un altro.
Conditional Branch – Ed eccoci qua, aprendo le impostazioni di questo comando vi potreste spaventare a primo impatto ma calmandovi noterete che non è altro che la condizione “if” ma nell’evento, non ha senso spiegare ogni singola cosa presente perchè non è altro che una lista di “ipotesi” da scegliere, in questo caso può essere solamente singola, in caso vi serva una condizione if a più ipotesi dovete creare un “branch” dentro un altro… o più semplicemente andare nella pagina 4 delle impostazioni comando e selezionare “Script”, com’è facile capire qui potete scrivere come se si scrivesse un’ipotesi if in un script, escluso ovviamente “if” e “end”; ma cos’è quella spunta su “Set handling when conditions do not apply”? Si aggiungerà praticamente un “else”, sempre riferendomi alla condizione if.
Loop, Break Loop – Niente di più facile, il primo creerà un loop, cioè una zona di comandi che si ripeterà all’infinito, poi aggiungere “Break Loop” dove si ha intenzione di fermarlo, per esempio si potrebbe creare un loop con più “Show Choinces” e “Input Number”, se il giocatore farà le scelte giuste allora si fermerà il loop e si andrà avanti nell’evento.
Exit Event Processing – Semplicemente l’evento verrà stoppato ignorando quindi altri comandi presenti in seguito, non c’è altro da aggiungere.
Erase Event – Similmente a quello precedente ma qui l’evento viene proprio cancellato, non eliminato del tutto perchè cambiando mappa poi rientrando riappare.
Call Common Event – Aprendo il database c’è la sezione “Common Events”, praticamente degli eventi che esistono, non per forza sfruttati, in ogni mappa, con questo comando si può richiamare uno di questi eseguendo i comandi presenti in esso; apriamo una piccola parentesi sugli “eventi comuni”:
– Prima cosa inizialmente ne sarà disponibile solamente 1, per aumentare il numero cliccate sul pulsante in basso “Change Maximum” selezionando quanti ne volete ma non esagerate che si rischia un rallentamento del gioco, parlo per esperienza personale.
– In seguito anche questi possono avere un loro nome, stesse regole sui nomi degli eventi su mappa, e un loro “Trigger”, quest’ultimo può essere “None”, “Autorun” o “Parallel”; per gli ultimi 2 pure ne abbiamo già parlato per gli eventi su mappa ma qui si deve per forza selezionare una condizione di attivazione, per la precisione una switch gioco su ON (come per le variabili gioco spiegherò a tempo debito) ma anche se la condizione non è vera potranno avviarsi sotto chiamata; poi c’è “None”, questi eventi comuni si potranno attivare solamente se chiamati.
Label, Jump to Label – I label li possiamo considerare tipo dei segnalibri, la presenza di 1 o più label non cambia nulla, è “Jump to Label” che fa la differenza, quest’ultimo però non potrà essere utilizzato senza label, praticamente vuol dire “vai al segnalibro… ” scrivendo il nome dato al “segnalibro” desiderato, questi due comandi possono essere un’alternativa al loop e anzi, sono anche più versatili.
Control Switches – Passiamo ora alla riga destra della prima pagina e finalmente parliamo delle switch evento, o sarebbe più giusto definirle switch gioco dato che nel script per usarle (in condizioni, modificarle con false o true, ecc…) bisognerà utilizzare il comando “$game_switches[id]” dove “id” bisogna sostituirsi alla ID della switch gioco a cui si fa riferimento; non sono altro che variabili binarie, appartenenti all’array “$game_switches”, negli eventi avranno come valore ON o OFF mentre negli script true o false, nelle condizioni evento è possibile specificare che 1 o 2 di queste switch sia su ON, così come sono le stesse switch a cui fa riferimento “Conditional Branch”.
Parliamo ora delle impostazioni di questo comando: con “Single” bisognerà selezionare una variabile specifica, dove si potrà anche cambiargli nome per magari ricordarsi l’utilizzo che ne fate, vedrete che di base ce ne sono 50 ma premendo “Change Max” potrete aumentare il numero disponibile; se invece volete andar a modificare un gruppo di switch e non una soltano, selezionate “Batch” e specificate l’intervallo di ID; poi semplicemente sotto scegliete se mettere su ON o OFF la switch/l’intervallo selezionata/o, specifico che inizialmente sono tutte su OFF.
Control Variables – Un’altro elemento basiliare, come le switch, sono le variabili gioco, similmente alle switch negli script si potrà usare il codice “$game_variables[id]” sostituendo “id” con l’ID delle variabile desiderata, in questo caso si tratta di variabili numeriche, “integer” per la precisione, anche se usando l’array “$game_variables” in un script si potrà dargli un tipo qualsiasi ma non ha senso, rischiate di confondervi ma giusto per informazione, inoltre sono le variabili specificate nelle condizioni evento e in “Conditional Branch”.
Per quanto riguarda le impostazioni? Lo stesso medesimo funzionamento di “Single” e “Batch” delle switch, qui però vedrete molte più impostazioni, partendo dall’alto c’è “Operation” dove si va a modificare il valore in modalità diverse: “Set” imposterà il valore pari a quello specificato più sotto, poi “Add”, “Sub”, “Mul” e “Div” servono per aumentare, diminuire, moltiplicare o dividere il valore attuale con quello sotto, in fine c’è “Mod” che ha lo stesso utilizzo di “%” negli script, cioè divide il valore attuale con quello sotto ma da come risultato il resto.
L’ultima zona va a specificare in che modo modificare il valore, “Constant” semplicemente col numero scritto o “Variable” col valore della variabile gioco specificata se invece preferite modificare il valore con un numero a caso in un intervallo allora “Random” fa al caso vostro; quelli che seguono poi sono cose più elaborate da spiegare ma abbastanza intuibili se cazzeggiate un pò col database, specifico solo che “Character” si riferisce a un evento della mappa, “Player” appunto è anch’esso un evento, un evento controllato da giocatore.
Prima di passare oltre va detto che le variabili gioco partono col valore 0.
Control Self Switch – Anche in questo caso sono switch, specificate poi nelle condizioni evento e “Conditional Branch”, con la differenza che sono switch appartenenti all’evento stesso, infatti sono solo 4, A, B, C e D; anche qui c’è un codice script che potrete utilizzare anche se poco più complicato da capire, tanto per iniziare il codice è “$game_self_switches[ [m, e, “A”]] = false”, dove “m” è l’ID della mappa dov’è presente l’evento (visualizzabile in “Map Properties” facendo prima click col destro sulla mappa nella lista in basso a sinistra), “e” l’ID dell’evento poi nell’esempio ho messo “A” (qui le virgolette devono rimanere) ma potrete sostituirla con B, C o D, così come mettere true o false dopo l’uguale, in partenza sono tutte OFF o false.
Control Timer – Non c’è molto da dire qui, con “Start” fate partire un timer che apparirà in alto a destra, specificando di quanti minuti e secondi farlo durare, mentre con “Stop” fermate il timer; può essere utile in caso ci sia, per esempio, un rompicapo a tempo e volete che il giocatore sia ben conscio del tempo a sua disposizione, magari poi “Stop” se riesce a concludere il rompicapo dato che poi è inutile continuare a visualizzarlo e tenerlo attivo.
Change Gold, Items, Weapons, Armor – Li spiego tutti insieme essendo pressochè identici; con “Change Gold” potrete aumentare o diminuire, selezionando “Increase” o “Decrease”, la quantità della moneta di gioco posseduta dal giocatore, digitando un numero specifico o in base al valore di una variabile gioco; stesso discorso vale per quelli successivi con l’unica differenza che dovrete selezionare l’oggetto di cui volete cambiare la quantità posseduta.
Change Party Members – Con “party” si intende il gruppo di personaggi “posseduti” dal giocatore, massimo 4 in questo caso; scegliete il personaggio, scegliete se aggiungerlo o rimuoverlo (“Add” o “Remove”) poi se deve resettarsi (“Initialize”), cioè così com’è nel database, annullando ogni modifica avvenuta durante il gioco, che può essere l’equipaggiamento, livello, nome, ecc… .
Change Windowskin, Battler BGM, Battler End ME – Mi è più comodo spiegare in gruppo se ci sono comandi simili, spero anche per voi… comunque “Change Windowskin” cambia lo stile delle finestre di gioco, una cosa presente in molti giochi, se ne volete creare una voi personalizzata prendete come base quella standard da seguire come schema, giusto per essere sicuri di non sbagliare; “Change Battler BGM” per selezionare la musica durante la battaglia; in fine con “Change Battler End ME” selezionate la musica che parte quando si vince una battaglia.
Questi 3 si possono già modificare da quelli standard dal database, senza cambiarli appena inizia il gioco.
Change Save Access, Menu Access – Anche questi 2 sono molto simili, “Disable” vuol dire disattiva mentre “Enable” attiva, cioè se permettere di salvare la partita o se permetterete di aprire il menù.
Change Encounter – Qest’altro funziona come quelli precedenti, dovete selezionare se disattivare o attivare… ma cosa? “Encounter” sono i nemici che appaiono, facendo partire la battaglia, mentre ci si muove in mappa, ogni mappa ha i suoi nemici modificabili in “Map Properties”, sotto la scritta appunto “Encounters” e “Troop” (immagino traducibile in “truppe”), il che vuol dire che disattivando questa cosa non si incontreranno nemici; per quanto riguarda le truppe (gruppo di nemici) le potete gestire nel detabase.



Ero indeciso se concludere qui un ipotetica prima parte e spiegare il resto in una seconda parte perchè sta venendo molto lungo, poi ho pensato finchè WordPress regge il numero di caratteri è più comodo avere tutto in un unica parte; iniziamo quindi la seconda pagina di comandi.

Transfer Player – Cioè “Trasferisci Giocatore”, un teletrasporto praticamente, si può cambiare mappa o spostarsi in un punto diverso della mappa attuale; con “Direct appoinment” andate a selezionare manualmente il punto e/o la mappa in cui volete che il giocatore vada, mentre “Appoint with variables”, come suggerisce la scritta, la posizione viene scelta in base al valore di 3 variabili, una l’ID della mappa poi altre 2 per le coordinate X e Y, infatti con “Control Variables” è possibile “settare” una variabile in base a uno di questi 3 valori nelle zone “Other” e “Character”.
In fine c’è “Direction” e “Fading”, quest’ultima opzione indica se durante lo spostamento deve o meno fare un effetto “dissolvenza”, cioè schiarirsi lo schermo poi riapparire normalmente; per quanto riguarda invece “Direction” bisogna indicare che direzione il giocatore deve guardare una volta spostato, “Retain” si intende che non cambia mentre quelle successive, nello stesso ordine: sotto, sinistra, destra o sopra, che poi è lo stesso ordine direzioni del charset.
Set Event Location – Similmente a quello precedente, sposta però un evento che non sia il giocatore e solo nella mappa attuale; in “Event” si seleziona quale evento spostare, c’è scritto sia l’ID che il nome degli eventi presenti in mappa, invece “This event” vuol dire l’evento dov’è presente questo comando, se è presente in un evento comune si riferisce all’evento che lo chiama, quindi niente se si attiva, l’evento comune, da solo con “Autorun” o “Parallel”; il resto funziona allo stesso modo di “Transfer Player” escludendo ovviamente l’ID mappa, c’è però in aggiunta “Exchange with another event”, cioè “Scambia con un altro evento”, selezionando con quale evento deve scambiarsi la posizione.
Scroll Map – Con questo comando si sposta la visuale della mappa, quella che di base segue il giocatore ovviamente; “Direction” specifica verso dove spostarla, “Distance” di quanto poi “Speed” con che velocità.
Change Map Setting – Cambia i settaggi della mappa: “Panorama Graphic” è l’immagine di sfondo, visualizzabile solo se c’è 1 o più tile in parte o totalmente trasparente in mappa; “Fog Graphic”, fog vuol dire nebbia, quindi per selezionare il tipo di nebbia da visualizzare; “Battleback Graphic” intende lo sfondo durante le battaglie; ognuno di questi 3 hanno come possibile valore “(none)” che vuol dire niente.
Change Fog Color Tone, Opacity – Entrambi cambiano com’è visualizzata la nebbia, “Color Tone” il colore sempre in RGB mentre il quarto valore vuol dire grigio cioè quando il colore deve essere chiaro o scuro, invece “Opacity” opacità, cioè più è alto il valore più la nebbia risulta coprente o forse è meglio dire densa; entrambi questi comandi hanno “Frames” nelle impostazioni, vuol dire che il cambiamento non è immediato ma andrà via via a cambiare la nebbia mettendoci il “tempo” specificato.
Show Animation – “Vedi Animazione”, si seleziona su quale evento e quale animazione visualizzare, prendendo una di quelle presenti nel database.
Change Trasparent Flag – Cioè se rendere trasparente o no il personaggio controllato dal giocatore.
Set Move Route – Vi ritroverete la stessa schermata che vedrete se “Autonomous Movement” di un evento è “Type: Custom” poi cliccando su “Move Route”, con la differenza che qui dovrete selezionare a chi far fare il movimento, al giocatore, a un evento o “This event” che abbiamo già visto che fa riferimento all’evento in cui è presente il comando.
Wait for Move’s Completion – “Aspetta che si completi il movimento” facendo caso al comando precedente, sarebbe a dire che mettendo “Set Move Route” poi un comando, il comando si avvierà immediatamente dopo ma se tra i due ci sarà “Wait for Move’s Completion” allora il comando aspetterà che le istruzioni finiscano prima di eseguirsi.
Prepare for Transition, Execute Transition – Banali ma non tanto nella spiegazione, praticamente “Transition” intende l’effetto transizione/spostamento, mettere prima “Prepare for Transition”, fare lo spostamento (magari con “Transfer Player”) poi selezionare l’effetto con “Execute Transition”, se non avete capito fate una prova mettendo i comandi citati nello stesso ordine.
Change Screen Color Tone – Aggiunge un filtro colorato alla schermata di gioco, un pò come se avreste un vetro colorato d’avanti, similmente a “Change Fog Color Tone” anche qui c’è “Frames” dove bisogna specificare in quanti frame la gradazione deve cambiare.
Screen Flash – Come suggerisce fa visualizzare un flash, si sceglie il colore e la durata, sempre in frame.
Screen Shake – Praticamente per simulare un terremoto, visivamente parlando, “Power” indica di quando la schermata deve muoversi, “Speed” la frequenza del movimento poi “Frames” il solito, quanto deve durare.
Show, Move, Rotate Picture – Tutti comandi che fanno riferimento ai file immagini presenti in Graphics -> Pictures; “Show Picture” è il primo da utilizzare altrimenti gli altri non faranno nulla (se non in eventi eseguiti successivamente), è possibile visualizzare massimo 50 immagini su schermo, escluse quelle script, “Number” infatti intende il numero, praticamente l’ID, dell’immagine, “Picture Graphic” per selezionare il file immagine (ricordate: pallino rosso = presente nella cartella del progetto/gioco), “The Orgin” per selezionare quale punto considerare l’origine dell’immagine, sopra a sinistra o al centro? In seguito specificare dove posizionare l’immagine, se per esempio X e Y 0 e il suo origine è sopra a sinistra l’immagine si posizionerà sopra a sinistra della schermata, se invece si è scelto come origine il centro sarà il centro dell’immagine a posizionarsi sopra a sinistra della schermata sarà quindi visualizzata solo 1/4 di essa, tale posizione come al solito può essere data scrivendola manualmente o attraverso variabili, poi c’è “Zoom” che intende se ingrandire o rimpicciolire l’immagine, se lasciati entrambi su 100 l’immagine non varierà le sue dimensioni, “Opacity” più è basso più l’immagine è trasparente in fine “Blending” non ho ben capito nemmeno io, so solo che serve per far interagire in modo diverso più immagini.
“Move Picture” andrà a spostare l’immagine, volendo si potranno modificare anche i valori “Zoom” ecc…, in alto specificare il numero dell’immagine è in quanto tempo deve raggiungere la nuova posizione; “Rotate Picture” ammetto che non l’ho mai usato quindi non sapevo cosa faceva ma ho fatto varie prove prima di spiegarlo (direi che sarebbe strano il contrario), praticamente: l’immagine inizierà a ruotare considerando il suo origine il centro della rotazione, si dovrà selezionare quale immagine e a che velocità, quest’ultimo potrà essere da -90 a 90, i numeri negativi la faranno routare in senso orario di seguenza quelli positivi in senso antiorario, mentre lo 0? Com’è scontato si fermerà.
Un ultimo appunto per “Show Picture”, se si aggiunge un immagine con un numero già presente andrà a sovrascrivere quella precedentemente associata a quel numero.
Change Picture Color Tone – Ormai s’è capito cosa si intende con “color tone”, in questo caso aggiunge un filtro colorato all’immagine scelta, sempre dove c’è scritto “Number” e anche qui “Frames” per dire in quanto tempo deve avvenire il cambiamento.
Erase Picture – Rapido e indolore: inserire il numero dell’immagine da cancellare, ovviamente tale immagine smette di esistere per il gioco.
Set Weather Effect – “Selezionare Effetto Atmosferico”: “None” come al solito vuol dire “nulla” quindi imposterà un clima neutro, “Rain” pioggia, “Storm” tempesta cioè pioggia forte, “Snow” nevicata; poi “Power” più è alto maggiore sarà l’intensità in fine il solito “Frames” per cambiare gradualmente.
Play, Fade Out BGM, BGS – Sono entrambi audio si sottofondo, “BGM” la musica mentre “BGS” suoni per creare atmosfera, per esempio il rumore del vento, di un fuoco che arde, ecc… ; “Play” per farlo partire, selezionando ovviamente quale mentre “Fade Out” per farlo fermare ma gradualmente, in questo caso però non in frame ma in secondi.
Memorize, Restore BGM/BGS – So che non è professionale dire “non so questo a cosa serve non avendo mai avuto occasione di provarlo” ma piuttosto che inventare e mentire… intanto si riferisce agli stessi BGM e BGS di prima, “Memorize” vuol dire memorizza/ricorda mentre “Restore” ripristina, in “Map Properties” si possono selezionare dei BGM e BGS automatici, quindi per logica mi verrebbe da pensare che “Memorize” modifica questi valori permanentemente mentre “Restore” rimetterà quelli di “Map Properties”… ehm, ho detto all’inizio della guida che non mi considero “onnisciente” su questo argomento, scusate ma rimedierò prima o poi spiegando meglio.
Play ME, Play, Stop SE – “ME” e “SE” pure sono audio ma a differenza di BGM e BGS si avviano 1 volta e basta non andando in loop, “ME” per cose collegate al pratico, magari per un congratulazioni o disfatta, mentre “SE” per suoni che potremo definire tecnici, praticamente output sonori per far capire al giocatore che l’azione è stata eseguita, per esempio spingendo un masso c’è appunto un suono del masso che si muove; per quanto riguarda “Play” o “Stop” non credo ci sia bisogno di spiegare ma lo faccio per completezza: “Play” per far partire il suono mentre “Stop” per fermarlo.



Ed eccomi alla terza e ultima pagina di comandi, gran parte di questi comandi fanno riferimento alla battaglia e il resto potremo dire di sistema ma vediamo con calma.

Battle, Shop, Name Input Processing – Con “Battle Processing” si darà il via a una battaglia selezionando contro quale truppa, “Can Escape” indica se è possibile scappare dalla battaglia (contro i boss, per esempio, non si può scappare solitamente) mentre “Continue Even When Loser” intende che la battaglia continua anche se si perde, magari per dialoghi o cose simili; “Shop Processing” per creare un negozio o simile, andando a selezionare gli oggetti da vendere, il prezzo lo si deve cambiare dal database nel caso; “Name Input Processing” per cambiare nome a un personaggio, selezionando chi e il limite di caratteri.
Change HP, SP, State – Gli “HP” sono gli “Heal Points” (Punti Vita) quelli che se vanno a 0 il personaggio va KO, se tutti della stessa fazione vanno KO la battaglia finisce (a patto casi particolari), “SP” invece “Special Points” (Punti Speciali) quelli che vengono consumati dalle “Skills” (Abilità/Tecniche) in fine “State” indica lo stato, tipo veleno, bruciatura e via dicendo; in tutti e 3 bisogna selezionare su chi agire dove c’è scritto “Actor”, se si seleziona “Entire Party” allora su tutto il party; per HP e SP bisogna dire se aumentarli o diminuirli in base a un numero scritto o valore di una variabile, ovviamente non potranno andare oltre il massimo così come meno di 0 (anche se attraverso script si, persino aggiungere cifre decimali), con la spunta “Allow Knockout in Battle” intende “Permetti KO in Battaglia” praticamente se non è selezionato gli HP non scenderanno sotto lo 0 a prescindere; mentre per lo stato se aggiungerlo o rimuoverlo, selezionando ovviamente quale, ricordate che dal database potete selezionare se uno stato deve rimanere a fine battaglia, se aggiungete uno stato che non deve rimanere a fine battaglia e non è in corso una battaglia si toglierà immediatamente.
Recover All – Fa tornare in piene forze l'”Actor” selezionato, recuperando tutti gli HP, SP e rimuovendo gli stati.
Change Exp, Level – Va a modificare la quantità di punti esperienza, quelli che servono per aumentare di livello, all'”Actor” selezionato, possono aumentare o diminuire attraverso un numero scritto o valore di variabile; mentre con “Change Level” lo stesso ma modificando il livello (da 1 a 99).
Change Parameters – Andrà a modificare il parametro, o statistica, all'”Actor” selezionato, per dire quale modificare selezionandola sotto “Parameter”.
Change Skills, Equipment – Come detto le “Skills” sono le abilità, cioè degli attacchi speciali che consumano SP, mentre “Equipment” è l’equipaggiamento, cioè l’armatura, l’arma e via dicendo che il personaggio “indossa”; nelle abilità “Learn” vuol dire impara, quindi aggiunge la “Skill” selezionata sotto, mentre “Forget” rimuove tale abilità all'”Actor”; per l’equipaggiamento invece selezionare l’area da modificare e indicando con cosa modificarla, senza dimenticare di selezionare anche l'”Actor”, con “(none)” la svuota, c’è però da fare una precisazione, se l’equipaggiamento scelto non è presente nell’inventario non verrà equipaggiato, se invece ha qualcosa equipaggiato e si seleziona “(none)” ciò che ha viene mandato nell’inventario.
Change Actor Name, Class, Graphic – “Change” vuol dire cambiare, “Actor” i personaggi usabili dal giocatore; “Name” è il nome, a differenza di “Name Input Processing” non è il giocatore a decidere che nome dare ma si scrive direttamente nel codice il nome da dargli, utile magari se si vuole tenere momentaneamente segreto il nome di un personaggio, una volta reso noto lo si cambia anche nelle info; “Class” è classe, in base alla classe cambia praticamente tutto tranne le statistiche, la classe decide cosa può equipaggiarsi, le skills, resistenze e debolezze, tutto gestito nel database; “Graphic” è grafica, cioè come appare il personaggio, “Character” è il suo aspetto su mappa mentre “Battler” in battaglia.

– EVENTI BATTAGLIA –

Ci sono gli eventi su mappa, quelli comuni e ora spieghiamo quelli battaglia, perchè i prossimi comandi si dovranno utilizzare in questi eventi.
Prima di tutto si gestiscono in “Database -> Troops”, ogni truppa ha i suoi eventi, dove i comandi che è possibile scegliere sono gli stessi (ovviamente gran parte saranno inutili qui), in “Condition” specificare quando attivare i comandi, se “Don’t Run” non si avvierà, utile se magari avete eventi ma volete testare la battaglia (con “Battle Test”, appunto) senza di essi; è possibile avviarli ogni tot turni, specificando il turno in cui deve iniziare; oppure se un membro della truppa o party abbia una certa percentuale di HP; in fine c’è come condizione un switch evento; è possibile avere attive tutte le condizioni, in tal caso si avvierà solo se tutte sono vere.
Ma ora torniamo ai comandi evento:

Change Enemy HP, SP, State, Enemy Recover All – Similmente come le loro controparti per il… party (scusate gioco di parole), stavolta invece si riferiscono ai nemici (Enemy), “Entire Troop” appunto intende tutti i componenti della truppa nemica.
Enemy Apparence, Transform – Con “Enemy Apparence” si dovrà selezionare quale nemico dovrà unirsi alla truppa, mentre “Enemy Transform” trasformerà un nemico in un altro nemico, si dovrà selezionare prima chi trasformare in seguito in chi trasformarlo.
Show Battle Animation – Letteralmente “Visualizza Animazione Battaglia”, fiamme, esplosioni e via dicendo, gestite in “Database -> Animation”; si dovrà scegliere se sui nemici o sui alleati, nel menù a tendina poi specificare chi, in seguito scegliere l’animazione da visualizzare; specifico che sarà puramente visiva, se volete che dia effetti veri e propri o li applicate attraverso comandi tipo “Change Actor/Enemy HP” o uno dei prossimi potrebbe facilitarvi di molto la cosa.
Deal Damage – Semplicemente chi danneggiare, cioè diminuire gli HP, tra uno dei combattenti, anche qui si dovrà selezionare chi, sia tra i nemici che alleati, danni decisi attraverso un numero specifico o valore variabile.
Force Action, Abort Battle – Entrambi i comandi “forzano” a far accadere una certa cosa, “Abort Battle” terminerà la battaglia mentre con “Force Action” potete costringere a uno dei combattenti di fare una certa azione, scegliendo chi dove c’è scritto “Battler”, cosa dove c’è scritto “Action”, poi contro chi dove c’è scritto “Action Target”, “Random” casuale mentre “Last Target” chi ha colpito nel turno precedente; “Timing” specifica quando, se “Normal Sequence” si rispetterà l’ordine del turno, mentre “Now” lo farà immietamanete quando il comando verrà letto.
Call Menu, Save Screen, Game Over, Return to Tile Screen – Sono finiti i comandi battaglia, arrivano quelli che ho definito di sistema, nello stesso ordine: apre il menù, apre la schermata di salvataggio, avviene il game over, torna al menù principale, dove c’è “New Game”, “Continue” e “Shutdown”; i primi 2 funzioneranno anche se menù o salvataggio disattivato con “Change Save/Menu Access” mentre con gli ultimi 2 potrete ricominciare a giocare dall’ultimo salvataggio.
Script – Eccoci finalmente all’ultimo comando; come già visto in parti precedenti questo comando permette di scrivere una quantità limitata di righe di script, in certi casi può aiutare, come appunto abbiamo visto come chiamare un script attraverso un evento.

– CONCLUSIONE –

Con questo, finalmente, dovrebbe essere tutto, certo ci sarebbero cose da approfondire ma è già stato tutto molto lungo, in alcuni casi ho ridotto anche perchè era inutile spiegare cose più volte; ho ancora dubbi sul prossimo argomento da trattare nella guida, se avete suggerimenti/richieste scrivete pure un commento… alla prossima!

Guida RPG Maker XP Script #5 – Classi & SottoClassi


Salve e benvenuti in questa nuova parte della guida, inizio a scriverla una settimana dopo l’eppifania ma dato che mi piace prendermela comoda non so quando la finirò quindi potrebbe sembrare strano quello che sto per dire… avete passato un buon natale? E a capodanno avete fatto attenzione? Si, insomma, i soliti convenevoli, si tratta pur sempre del primo contenuto del blog di quest’anno.

Nella parte precedente abbiamo iniziato col vedere le prime cose concrete, ora inizieremo ad approfondire un pò l’una un pò l’altra, sia teoria (che può servire per capire meglio) ma soprattutto la pratica, iniziando a dare per scontate alcune cose per accelerare. Spiegherò nello specifico cosa sono le classi e le sottoclassi, essendo l’argomento principale va per la terza volta ripetuta una cosa che dissi per far capire meglio come gestire gli script: una classe va considerato un edificio mentre i def le sue stanze… aggiungiamo però che una sottoclasse vuol dire che gli edifici sono legati, ma solo in un senso, cioè una sottoclasse può “sfruttare” anche le stanze (quindi i def) della classe a cui è legato ma non il contrario; nello specifico col termine “script” si intendono le varie classi e sottoclassi che vanno a gestire una determinata cosa, per fare un esempio, se provate a capire come funziona il sistema di battaglia preinserito noterete che sfrutta una moltitudine di classi.

– CLASSE –

Come al solito facciamo alcuni passi indietro spiegando una cosa alla volta, per bene, iniziamo col approfondire il concetto “classe”. A livello di codice una classe è racchiusa tra il codice “class” al codice “end”, quest’ultimo è presente molto spesso quindi non fate confusione, l’ultimo “end” è della classe, gli altri sono dei def o condizioni (ricordo che anche gli input sono condizioni) ed esistono classi sia passive (def initilize) sia attive (def main).

Ciò che so è totalmente da autoditatta, le basi le ho imparate studiando gli script preinseriti (anche se avevo comunque una piccola cultura di javascript) poi cazzeggiando un pò ho approfondito; ebbene ho proprio intenzione di spiegare alcune cose prendendo come punto di riferimento gli script preinseriti.

Apriamo quindi “Script Editor” e vediamo cosa c’è: un gruppo di classi che iniziano con la parola “Game” (Gioco), un gruppo con “Sprite” e giusto 2 con “Spriteset” (gli sprite sono le immagini dei personaggio o altro), poi “Window” (Finestra), “Arrow”, (Freccia), “Interpreter” (giusto per completezza ma per ora ignoratelo), “Scene” (Scena, come abbiamo visto nella parte precedente) poi si conclude con “Main” (che deve sempre trovarsi in fondo a tutti).

– “Main” in verità non contiene un classe ma solo un codice che si avvia prima di ogni altra cosa, ha lo scopo di vedere se tutto è regolare all’interno delle classi.
– In seguito ci sono le classi “Scene”, senza le quali sarebbe impossibile fare qualsiasi cosa, il gioco non esisterebbe senza tali e contengono tutte “def main”; “Scene_Title” è quella che viene avviata per prima di base, si tratta della schermata di titolo, quella dove vedete le opzioni “New Game”, “Continue” e “Shutdown”, prepara anche tutto ciò che serve all’interno del gioco. Tornando alle generiche “Scene”, durante tutto il gioco non saranno attive più di 1 conteporaneamente, allo stesso tempo però non sarà possibile continuare con nessuna di loro attive (ricordate che sto spiegando prendendo in considerazione solo quelle preinserite).
– Quelle “Window”, come suggerisce, gestiscono le finestre e soltando le finestre, in base ovviamente a determinati input o condizioni varie; sono tutte sottoclassi ma questo lo vedremo dopo.
– Le classi “Game” gestiscono i dati di gioco, ci starebbe una marea di cose da spiegare ma meglio evitare, col tempo capirete da soli con ovviamente vari incipit e esempi su come utilizzarle; tanto per anticipare qualcosa, tutto ciò che contiene il database è possibile estrarlo proprio attraverso queste classi.
– Per tutte le altre, tranne “Interpreter”, vengono sfruttate all’interno di una battaglia o altri casi complessi da spiegare in poche parole ma come “Game” vedremo a tempo debito.

Abbiamo dato una spolverata generale ma, sempre vedendo le classi preinserite, alcune sono ripetute più volte con l’aggiunta di numeri, 1, 2, 3… ma se andate a vedere il nome della classe è in verità uguale per tutte… cosa? Riguardo a quando dissi che non è possibile creare più classi con lo stesso nome, come lo spiego questo? Beh, lo spiego così: “def initialize” o “def main” è presente solo in 1 di loro, per la precisione quello presente più in alto in lista, se sarebbero classi diverse vorrebbe dire che quelle successive alla prima non sono scritte correttamente ma in verità, appunto, appartengono alla stessa classe ma per motivi d’ordine si è preferito scrivere i vari def separatamente ma dando lo stesso nome alla classe, si fa capire al programma che vanno considerati come un unica classe o edificio, un pò come avere il capanno degli attrezzi in giardino, appartiene alla stessa abitazione anche se separato dalle mura; ah, questo da non confondere con le sottoclassi che sono cose diverse.

– SOTTOCLASSE –

Prima di approfondire alcuni dettagli andiamo a dare una spolverata anche all’argomento “sottoclasse”; le sottoclassi sono strutturate allo stesso modo di una classe, def main o initialize e via dicendo, solamente per un piccolo (visivamente) dettaglio, di fianco a “class” c’è il nome della classe, giusto? Ma, nelle sottoclassi, c’è il nome di un’altra classe divisi però da un “<“, cioè “class sottoclasse < classe” e come anticipato questo fa in modo che la sottoclasse possa utilizzare i def della classe specificata come se fossero suoi, riguardo a ciò vediamo ora nei dettagli.

– DEF –

É arrivato il momento di spiegare per bene cosa sono questi def, alcune cose dovreste già averle capite ma immagino non totalmete; tornando alla solita frase, i def li possiamo considerare come stanze delle classi, ogni classe ha le sue stanze, come in tutte le abitazione c’è, mister ovvio, una stanza d’entrata in questo caso può essere di 2 tipologie, main o initialize, in base a loro la classe viene gestita diversamente, tanto che, se si entra da main si dovrà uscire sempre da essa, se invece si entra da initialize si uscirà li dove ci si trova finito ciò che si è fatto, è come se l’idraulico dopo aver fatto il suo lavoro esca dalla finestra più vicina a lui; ci sono alcune eccezioni, è possibile avere una classe sia con initialize che main, cosa accade in questi casi? Appena avviata parte initialize poi però main prende le “redini”, quindi è da chiamare comunque con “$scene =”.

Detto ciò, come richiamare un def (cioè far avvenire ciò che il codice al suo interno descrive)? Semplicemente scrivere il nome del def, ma questo è diverso per initialize e main che come detto sono l’entrata e l’entrata serve solo a entrare, appunto, o gestire i movimenti all’interno della classe; ma qual’è di specifico il nome del def? Similmente come una classe, un def è racchiuso tra la scritta “def” e “end”, il suo nome si trova subito dopo “def”, ovviamente non attaccato ma con uno spazio.
Come anticipai tutti i def all’interno di una classe devono avere un nome diverso, lo stesso non vale con classi diverse, per esempio classe1 ha def1, classe1 non potrà avere un ulteriore def chiamato “def1”, o almeno potrebbe ma quello più in alto sovrascrive tutti gli altri (solo durante la “lettura” del codice ma restano scritti), insomma il punto è che invece classe2 potrà senza problemi avere un def chiamato “def1”, senza creare complicanze.
Ma è possibile richiamare un def di una classe diversa da quella attuale? Certo che si; come detto per chiamare una classe si usa “NomeClasse.new” (aggiungere prima “$scene = ” per cambiare classe def main attiva), per richiamare invece un def della classe si fa “NomeClasse.new.nomedef” (in minuscolo perchè così conviene scriverli i nomi dei def).

– ARGOMENTI –

Forse è una traduzione di “arguments” troppo letterale ma serve giusto per avere una parola italiana, per una più facile comprensione (ehm… chi ha detto “def”?), ma cosa sono? Davanti al nome di alcuni def c’è una parentesi con delle scritte a loro interno, in caso di più di 1 divise da una virgola, quelli presenti in main o initialize vanno considerati come appartenenti alla classe; queste scritte non sono altro che variabili pretese, nel senso che servono per forza per la riuscita del codice, infatti se mancano, o scritte di più del necessario, esce un messaggio di errore che finisce con una parentesi del tipo “(n of m)”, dove “n” è il numero di “argomenti” scritti mentre “m” quelli necessari.
Ma ora vorreste sapere come specificarli, no? Semplicemente quando chiamate un def con argomenti, nel codice di richiamo dovete aggiungere una parentesi con il numero di valori necessari, divisi da una virgola, per esempio “nomedef(x, y)”, dove ovviamente “x” e “y” sono solo d’esempio; come detto però, in caso di main o initialize con argomenti, vanno considerati appartenenti alla classe, infatti in questo caso vanno specificati al richiamo della classe “NomeClasse.new(x, y)”, in caso invece di richiamo def di una classe diversa “NomeClasse.new.nomedef(x, y)”; volendo si può direttamente utilizzare un array che ha il giusto numero di valori, facendo “nomedef(array)”.
In alcuni casi gli argomenti hanno già un valore scritto nel codice, del tipo “(a=0)”, in tal caso vuol dire che “a” prenderà quel valore se non gli viene dato nessuno al momento del richiamo.

– RETURN –

In tal caso preferisco non tradurre dato che mi riferisco proprio al codice “return”, nella parte precedente della guida l’ho spiegato in modo grossolano ma ora vedremo nei dettagli.

Volendo si potrebbe tradurre con “ritorna” ma ritorna dove? Nella sezione del codice “visitato” in precedenza; segue un esempio per far capire bene:

class Classe
_def initialize
__def1
__def2
_end
_def def1
__return
__def3
_end
_def def2
_end
_def def3
_end
end

I trattini bassi servono solo per ordine, ignorateli quindi nel senso pratico (intendo non scriveteli anche voi in un codice). Insomma, un codice scritto in questo modo, il def3 è messo li giusto per, viene si richiamato dal def1 ma anche no… vediamo con ordine:
“Classe.new” per chiamare questa classe; si va nel def1 fino a “return”, quindi si torna alla sezione precedente, in questo caso il def initialize ma non all’inizio ma prosegue avviando il codice dopo il richiamo del def1; così facendo si chiama il def2 e così si conclude la classe… ecco che il def3 viene del tutto ignorato dato che si trova dopo il return del def1.
Spero che con questo sia chiaro il funzionamento del return, anche se ci sono altre cosette da specificare.

Tornando a parlarle degli “argomenti”, in alcuni casi vengono specificati dopo un return, anche se senza parentesi ma infatti la funzione è diversa, serve solo per introdurre la cosa con cose già spiegate, simili. Vediamo lo stesso esempio di prima con alcune modifiche:

class Classe
_def initialize
__a = def1
__def2
_end
_def def1
__b = 1
__return b
__def3
_end
_def def2
_end
_def def3
_end
end

Cosa è cambiato? C’è un “a = def1” e un’altra variabile “b”, che prende il valore 1 e specificata nel return, cosa comporta ciò? Con “a = def1” il def1 viene comunque chiamato agendo allo stesso modo se non ci fosse “a = “, ciò che cambia è quel “return b”, che praticamente fa “tornare”, o prendere, il valore di “b” ad “a”, dato che “b” gli viene dato come valore 1, a sua volta “a” diventa uguale a 1.

– RICAPITOLANDO –

Come al solito ricapitolare aiuta a capire meglio, però avendolo spiegato in modo principalmente teorico ora lo faremo in modo pratico, andando ad aggiornarne il script su cui stiamo lavorando nella guida con le cose “nuove”: prima cosa stavolta non useremo solo 1 classe ma ben 2, una “scene” e l’altra “window”, che come abbiamo visto aiuta ad avere maggiore ordine.

class Scene_Guida_Blog
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make title graphic
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.title($data_system.title_name)
    # Make window
    @fin = Window_Guida_Blog.new
    @txt = "..."
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of command window
    @fin.dispose
    # Dispose of title graphic
    @sprite.bitmap.dispose
    @sprite.dispose
  # end main
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # input
    update_command
    # fin update
    @fin.refresh(@txt)
  # end update
  end
  #--------------------------------------------------------------------------
  # * Update Command
  #--------------------------------------------------------------------------
  def update_command
    # If X button was pressed
    if Input.press?(Input::X)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # txt
      @txt = "Input.press? X"
      return
    end
    # If Y button was pressed
    if Input.trigger?(Input::Y)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # txt
      @txt = "Input.trigger? Y"
      return
    end
    # If Z button was pressed
    if Input.repeat?(Input::Z)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # txt
      @txt = "Input.repeat? Z"
      return
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Map.new
      return
    end
  # end update_command
  end
# end Scene_Guida_Blog
end

Inziamo col vedere “Scene_Guida_Blog”, nella parte pratica non è cambiato nulla dall’ultima volta che lo abbiamo visto, l’ho solamente adattato ai nuovi argomenti spiegati, partendo col cambiare nome quindi ricordate di cambiarlo anche dove viene richiamata scrivendo “$scene = Scene_Guida_Blog.new”.

class Window_Guida_Blog < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 640, 120)
    self.contents = Bitmap.new(width-32, height-32)
    refresh
  # end initialize
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(txt = "...")
    self.contents.clear
    self.contents.draw_text(0, 0, 640-32, 120-32, "#{txt}", 1)
  # end refresh
  end
# end  Window_Guida_Blog
end

Ecco “Window_Guida_Blog” che gestisce la finestra allo stesso modo, con la differenza che lo fa in una classe a parte; come vediamo “refresh” nel “scene” viene richiamato specificando un “argomento”, che di base vale “…” ma cambia se gli viene dato un valore diverso.
Scrivendo “self” si riferisce alla finestra, senza specificare il nome datogli perchè appunto in questa classe non ha nome ma è la classe in se; “super” fa riferimento alla classe di cui questa è sottoclasse, quidi “Window_Base”, questo non fa altro che sostituire il codice “Window_Base.new” visto in precedenza, volendo potreste comunque utilizzarlo.
In questa classe vedete che “width” e “height” sono scritti da soli senza nemmeno “self.”, questo perchè il programma capisce già che si fa riferimento alle misure specificate in “super(…)”.

Per il resto credo che si possa concludere qui, ci sono ancora tantissime cose da dire ma mi toccherà spiegare argomenti diversi e lunghi quindi meglio pensarci in un ulteriore parte della guida; quindi non ci resta che salutarci, buona fortuna se state già lavorando a un gioco.

Guida RPG Maker XP Script #4 – Condizioni & Input


Ed eccoci con una nuova parte di questa guida, dopo aver dato una spolverata generale in quelle precedenti, finalmente iniziamo a scriptare qualcosa di funzionante, per ora di livello intermedio poi vedremo in seguito qualcosa di avanzato; insomma, l’ultima volta siamo rimasti così:

#==============================================================================
# ** Guida_Finestra
#------------------------------------------------------------------------------
#  Questo serve come guida a costruire una finestra.
#==============================================================================
 
class Guida_Finestra
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    @Fin = Window_Base.new(0, 0, 640, 120)
    @Fin.contents = Bitmap.new(@Fin.width-32, @Fin.height-32)
    @Fin.contents.draw_text(0, 0, 640-32, 120-32, "Guida_Finestra", 0)
    # Restore BGM and BGS
    $game_system.bgm_play($game_system.playing_bgm)
    $game_system.bgs_play($game_system.playing_bgs)
    # Update map (run parallel process event)
    $game_map.update
    # Switch to map screen
    $scene = Scene_Map.new
  end
end

Come anticipai, questo script una volta richiamato (con “$scene = Guida_Finestra.new” essendo “main”), fa apparire la Finestra poi subito si conclude, a causa di ciò la Finestra sparisce dopo una manciata di secondi… bene, avendo ricapitolato passiamo oltre.

– CONDIZIONI –

Un ulteriore concetto da capire prima di proseguire sono le “condizioni”, ovviamente a livello script non va preso alla lettera ma quasi; cosa sono le condizioni? “Per far questo deve accadere quest’altro”, vediamo ora nello specifico le più comuni.

if – La condizione “se” è decisamente quella più banale da capire, è strutturata in questo modo:

if *condizione*
*soluzione*
end

“if” e “end” sono le uniche cose che devono essere sempre presenti, il resto dipende da cosa volete ottenere; la condizione è ovviamente cosa deve accadere per far avvenire ciò che viene specificato nell'”if”; la soluzione appunto è ciò che deve avvenire. Se volete che invece la soluzione avviene SE la condizione NON è vera allora scrivete “if not” invece di “if”; volendo esistono anche “else” o “elsif”, vediamo come utilizzarli:

if *condizione*
*soluzione*
elsif *condizione2*
*soluzione2*
else
*soluzione3*
end

Come vedete, “elsif” va prima di “else”, questo perchè la soluzione di “else” avviene se e solo se sia la condizione di “if” che quella di “elsif” non sono vere; così come la soluzione di “elsif” avviene solo se la condizione di “if” è falsa MA quella di “elsif” è vera, in tal caso la soluzione di “else” non viene presa in considerazione; in fine se la condizione di “if” è vera avvia direttamente la propria soluzione, ignorando le 2 successive; cosa avviene con più “elsif”? La condizione veritiera presente più in alto è quella che viene presa in considerazione, saltando tutte quelle successive anche se sono vere.

case – “case” prende in considerazione una Variabile, in base ai possibili valori della Variabile accettati accadono determinate cose, lo si può fare con qualsiasi tipo di Variabile anche se viene logico pensare che per quelle binarie o vuote tanto vale utilizzare “if” dato che la prima può avere come valore solamente “true” o “false” mentre la seconda solamente “nil”, per controllare, sempre nella seconda, ovviamente se una Variabile ha già aquisito un valore o meno; ma vediamo il codice di questo tipo di condizione:

case *nomeVariabile*
when *valore*
*soluzione*
when *valore2*
*soluzione2*
when *valore3*
*soluzione3*
end

In questo caso vengono presi in considerazione 3 possibili valori della Variabile specificata con “case”, ovviamente avviene la soluzione specificata nel “when” del valore; se la Variabile non ha nessuno dei valori specificati allora questo codice viene totalmente ignorato, da “case” a “end”.

while/until – Queste 2 tipi di condizioni sono molto simili tra loro, li possiamo considerare dei “loop”, cioè la soluzione viene ripetuta finchè… cambia leggermente in base a quale dei 2 viene utilizzato, quindi vediamoli con calma; prima cosa il codice è:

while *condizione*
*soluzione*
end

Se preferite “until” va scritto allo stesso modo con ovviamente la differenza che “until” va scritto invece di “while”. Con “while” la soluzione si ripete finchè la condizione è vera, mentre con “until” finche NON è vera; per abitudine ho sempre utilizzato “while” ma in casi particolari potrebbe essere invece più comodo “until”.
Va inoltre specificato che la condizione viene letta prima della soluzione, quindi se dopo un tot di volte la condizione vale, poi però qualcosa nella soluzione cambia una Variabile in modo che la condizione non sia più valida, allora il loop si ferma ma non prima che la soluzione attuale si concludi.

for … in – “Per ogni… all’interno di… fai…”, anche in questo caso è un loop che però si ripete per ogni elemento presente in una lista, o Array, se volete prendere in considerazione un intervallo specifico, potete fare per esempio “in 3..10”, per prendere in considerazione solo gli indici 3 fino al 10; solitamente invece di 2 puntini vengono utilizzati 3, l’unica differenza è che i 3 puntini intendono “escludi l’ultimo valore”, tornando all’esempio di prima, se scrivete invece “in 3…10”, vuol dire dall’indice 3 a quello PRIMA del 10, di conseguenza il 9, i 3 puntini sono decisamente consigliabili se vi interessano tutti gli indici, altrimenti come vi sentite di fare; in ogni caso vediamo nello specifico come va scritta questa condizione:

for *indice* in *lista/intervallo*
*soluzione*
end

L’indice deve essere “rappresentato” con una Variabile, che aumenterà da sola di 1 ad ogni ciclo senza bisogno di specificarlo, a differenza degli altri loop, solitamente alla Variabile gli viene dato come nome “index” o “i” ma va bene qualsiasi, o meglio quasi ma non mi sembra il caso di ripetere cose già dette.
Per quanto riguarda la lista da specificare, se avete dato un’occhiata ai codici preinseriti in RPG Maker XP, viene spesso utilizzato per fare un’azione per ogni nemico o compagno in squadra, in tal caso la Variabile indice prende come valore proprio il nemico o compagno, nel senso che si riferisce proprio a lui ma per fare le cose più chiare vi consiglio una cosa del genere:

for i in 0…lista.size
lista[i]
end

“0…lista.size” cioè: 0 si intende il primo valore, poi se ricordate la differenza di 2 o 3 puntini potreste trovarvi in dissacordo ma va spiegato che quel “.size” intende il numero di valori presenti in lista, se per esempio ci sono 4 valori, l’ultimo avrà come indice 3, ecco perchè 3 puntini, se 2 cercherà l’indice 4 ma non essendoci si bloccherà dando errore, se poi volete per forza utilizzare 2 puntini scrivete “0..lista.size-1”; beh, poi nella soluzione mettete “lista[i]” dove ritenete opportuno estrarre l’elemento della lista, in base ovviamente a cosa volete fare.

loop do – Vabbè, credo che ormai avete capito come funziona una condizione, ai righi successivi va scritta la soluzione e, una volta conclusa, va un “end” al rigo subito successivo (vanno anche bene alcune righe vuote o con commento, cioè con un # all’inizio) per comunicarlo al programma; insomma questo “loop do” è il loop più semplice, concettualmente parlando, ma nel RGSS è sconsigliabile utilizzarlo tranne per un “def main” come si può appunto vedere nei script preinseriti.
Non c’è nulla di particolare da dire su tale loop, tranne che ripete relativamente all’infinito la propria soluzione, l’unica cosa che può fermarlo è un “break”, tale codice può fermare anche gli altri loop spiegati in precedenza, anche se la condizione non è stata avverata, utile per esempio se volete cercare un certo valore in una lista, magari una lista con centinaia di valori e quello desiderato si trova al centro o l’inizio, perchè sprecare tempo extra? Utilizzate “break” sfruttando un “if”, ok che si rispiarmierà giusto una frazione di secondo o massimo un secondo ma è consigliabile in certe situazioni per non appesantire troppo il PC.

Disuguaglianze – Prima di concludere la spiegazione delle condizioni vanno spiegate alcune cose che vanno bene con tutte o quasi; una fra tante, come abbiamo visto nel “for … in”, nelle condizioni si possono anche fare calcoli matematici, non approfondirò avendolo già fatto nella parte della guida delle Variabili ma ci sono altre cose sempre matematiche da specificare, ho preferito farlo dopo aver spiegato le varie tipologie di condizioni per comodità, vi sarete probabilmente chiesto “come faccio a speficare cosa voglio in una condizione?”, ebbene grazie alle disuguaglianze cioè minore, maggiore, ecc… ; vediamole con calma:

< – Questo è il simbolo di minore, posto normalmente a sinistra della Z sulla tastiera. Per esempio “Variabile < X”, la condizione è vera se il valore, ovviamente numerico, della Variabile è minore del numero specificato apposta della “X”, va anche bene una Variabile, sempre numerica, con ciò si intende che è falso se invece è uguale a “X” o maggiore.
> – Questo invece è il simbolo di maggiore, stesso pulsante del minore tenendo però premuto SHIFT. Similmente al minore, la soluzione è vera se è maggiore di “X” mentre falsa se minore o uguale.
== – Per scrivere il simbolo dell’uguale, tenete premuto SHIFT mentre premete il pulsante 0 sulla tastiera, non dalla zona che sembra una calcolatrice ma quello sopra alle lettere, se però la vostra tastiera non è di layout QWERTY italiano si troverà altrove. Non ho sbagliato a scriverlo 2 volte, perchè se scritto 1 sola volta va a modificare il valore della Variabile anche se scritto come condizione, quindi serve scriverlo 2 volte per far dire invece se è uguale o meno; ovviamente con questo simbolo si accetta uno e uno soltando valore, non solo matematico.
!= – Per scrivere il punto esclamativo, SHIFT e 1, sempre quello sopra alle lettere. L’essatto opposto del doppio uguale, si accetta qualsiasi valore diverso da quello specificato, sia matematico che non.
<= e >= – Li ho scritti insieme per far prima ma vanno scritti singolarmente, “<=” e “>=”, cioè minore uguale e maggiore uguale, per esempio “Variabile <= X” vuol dire che viene accettato sia un valore uguale a “X” sia minore, così come viene invece respinto un valore maggiore; similmente se utilizzate “>=”, viene accettato un valore uguale o maggiore e rifiutato uno minore.
Utilizzandoli entrambi in una stessa condizione, poi vedremo in seguito come avere più ipotesi in una stessa condizione, si può per esempio specificare un’area, io li utilizzo spesso per identificare se il giocatore si trova in una certa area della mappa, sfruttando ovviamente le coordinate X e Y.

– IPOTESI MULTIPLE –

Andiamo ora a spiegare le ipotesi multiple, riferendomi sempre alle condizioni, utilizzabili principalmente con “if”, negli altri complicano di molto le cose ma possono comunque essere usate.
Ma cosa sono nello specifico? Praticamente vanno prese in considerazione più ipotesi in una certa condizione, tale condizione è verà se l’intero ambaradam di ipotesi è vera, “questo e quello”, “questo o quello”, “questo e quello o quell’altro” e via dicendo, vediamo come al solito con calma.

Prima di tutto non basta scrivere direttamente le ipotesi ma bisogna specificare il “legame” che deve essere preso in considerazione; “questo e quello”? “E” va scritto o “and” o “&&”; “questo o quello”? In quest’altro caso “o” va scritto “or” o “||” (SHIFT e pulsante a sinistra dell’1); ovviamente più ipotesi ci sono in ballo più è facile far confusione ma spesso bisogna rischiare, provare e riprovare, finchè non trovate le ipotesi e legami che portano a ciò che volete; seguono alcuni esempi per far capire bene:

a == 1 && b > 3 – In caso di ipotesi multiple legate tutte da un “&&” o “and”, la condizione risulta veritiera se TUTTE le ipotesi sono vere; in questo caso se “a” è uguale a 1 E “b” maggiore di 3, di conseguenza se è vera solo 1 la condizione risulta “false”.
a == 1 || b > 3 – Se invece le ipotesi sono tutte legate da “||” o “or”, allora la condizione viene accettata anche se è vera una singola ipotesi, il che vuol dire anche se sono vere tutte, ne basta 1 ma va bene anche più; in questo caso quindi, se “a” è uguale a 1 ma “b” è, per esempio, -1, la prima è vera ma la seconda no, visto che c’è “||” la condizione risulta “true”.
a == 1 && b > 3 || c != “z” – Qui è presente sia “&&” che “||” nella stessa condizione, le cose si fanno decisamente meno scontate, in casi come questi, con ipotesi legate in modo diverso, è consigliabile utilizzare le parentesi tonde per rendere chiara la condizione desiderata.
Se fate a == 1 && (b > 3 || c != “z”), per risultare vera la condizione “a” deve essere 1 E “b” maggiore di 3… oppure “c” diverso da “z”; nel senso, mettendo le parentesi in questo modo, viene accettata se è vera la prima ipotesi e una delle ultime 2, ovvimente anche se lo sono entrambe.
Se invece fate (a == 1 && b > 3) || c != “z” allora risulterà vera se le prime 2 ipotesi sono vere oppure basta che sia vera solamente la terza.

Per concludere una condizione deve essere considerata una Variabile binaria, può essere “true” o “false”; con questo dovrebbe essere tutto ciò che serve per capire le condizioni, almeno per quanto riguarda genericamente, ogni caso potrà “costringervi” a imparare cose nuove, infatti in futuro ho anche in mente di spiegare almeno gran parte di questi casi particolari ma per ora no; se vi state chiedendo come gestire invece le “soluzioni” alle condizioni, beh, li è programmazione pura, le condizioni servono solo per limitare l’attivazione di un certo codice solo in determinate circostanze, circostanze che per ora non vedremo ma in futuro decisamente.

– INPUT –

Un’altro argomento molto importante da capire per creare il vostro gioco sono gli input, anch’essi li possiamo considerare condizioni in un certo senso; per fortuna (o no?) c’è relativamente poco da spiegare a riguardo ma poco non vuol dire non importante, gli input sono letteralmente ciò che fa muovere il gioco… e giocatore.

Genericamente gli input è ciò che tu, giocatore, invii al gioco attraverso la testiera, volendo anche il mouse ma è solo una veloce anticipazione di ciò che spiegherò arrivati ai livelli avanzati; su RPG Maker XP c’è però una quantità limitata, ma poco limitante, di input, oltre alle classiche frecce direzionali c’è una certa quantità di input attivabili anche con pulsanti diversi dalla tastiera, nel senso che avete più scelte sul pulsante da premere per un certo input, vediamo quali sono:

Input.dir4 – L’input che fa riferimento alle frecce direzionali, gli altri danno come valore “true” o “false” in caso vengano premuti o meno, in questo caso invece ben 4 valori matematici diversi in base alla freccia premuta, escluso se non è premuta nessuna vale 0; 2, 4, 6, 8, nello stesso ordine: giù, sinistra, destra, su, se ne premete più in conteporanea comunque ci sarà almeno un miliardesimo di secondo tra un input all’altro, verrà preso in considerazione solo il secondo, tranne se ne premete più di 2.
A – Per inviare questo input bisogna premere SHIFT oppure Z.
B – Per inviare questo input bisogna premere ESC (in alto a sinistra), 0 posto nella zona simil calcolatrice oppure X; inoltre è quell’input messo di base per anullare un’azione o aprire il menù.
C – Per inviare questo input bisogna premere SPAZIO, INVIO o C; inoltre è l’input per interagire con NPC, menù e via dicendo.
X – Per inviare questo input bisogna premere A.
Y – Per inviare questo input bisogna premere S.
Z – Per inviare questo input bisogna premere D.
L – Per inviare questo input bisogna premere Q oppure il pulsante per andare alla pagina successiva in un documento di testo.
R – Per inviare questo input bisogna premere W oppure il pulsante per andare alla pagina precedente in un documento di testo.

Se preferite giocare con un gamepad dovete come prima cosa controllare che numero corrisponde a ogni pulsate del gamepad, controllate nelle impostazioni di input del vostro PC, cambia in base al sistema operativo quindi non saprei, mi dispiace, se spiego come faccio io ci sarà solo una percentuale di voi che potrà farlo allo stesso modo quindi è inutile; insomma, quando riuscite a trovare il numero corrispondente a ogni pulsante, basta dire questo: escluso l’input direzionale che dovrete utilizzare l’analogico (o stick) o la croce direzione del gamepad, l’input A corrisponde al pulsante 1, il B al 2 e così via, con lo stesso ordine in cui ve li ho messi sopra. Volendo potete anche cambiare il pulsante, sia tastiera che gamepad, che corrisponde a un certo input, premendo F1 sia in Playtest che avviando il gioco dal file exe, sarà possibile farlo comunque in modo limitato ma si, possibile.

Ma a livello di codice come gestire e creare azioni attraverso gli input? L'”Input.dir4″ viene gestito diversamente, cioè così:

case Input.dir4
when 2
*soluzione*
when 4
*soluzione*
when 6
*soluzione*
when 8
*soluzione*
end

Viene solitamente utilizzato in un “case” e come già detto i 4 valori corrispondono alle frecce direzionali ma non devono per forza eseguire quell’azione li, anche se è già presente tra gli script standard per far muovere il giocatore ma se farete giochi avanzati vi potrà comunque servire saperlo.
Volendo però, potete gestire gli input delle frecce direzionali come vedremo subito dopo, invece di A, B, ecc…, dovrete scrivere in CAPS (quindi tutte le lettere in maiuscolo) la direzione in inglese, quindi: UP, LEFT, RIGHT o DOWN.
Per tutti tranne “Input.dir4” (avendo visto sopra) dovrete fare così:

if Input.trigger?(Input::A)
*soluzione*
end

Ovviamente sostituendo “A” con l’input desiderato e non fate confusione, tra gli input ce n’è uno che è richiamato col pulsante A ma l’input si chiama “X”, nel codice dovete scrivete il nome dell’input non il pulsante della tastiera; l’input viene trattato come condizione, come anticipato, ma volendo anche come ipotesi, nel senso che, potete per esempio fare in modo che l’input viene accettato solo se una certa Variabile ha un certo valore, utilizzando appunto il metodo spiegato nelle ipotesi multiple.
Mentre cos’è quel “Input.trigger?”? Oltre a dir4 e dir8 (aggiunge anche gli angoli a dir4 ma ve lo sconsiglio se siete principianti) esistono altri 3 tipi di input: “press”, “trigger” e “repeat”; “press” agirà finchè l’input è in pressione, andrà insomma in loop la sua soluzione finche lo si preme; “trigger” invece agirà solamente al momento della premuta, per avviarlo di nuovo bisognerà rilasciarlo e ripremere, così tutte le volte che lo riterrete opportuno; infine “repeat” è simile a “press” ma ci sarà un intervallo di tempo maggiore tra uno e l’altro “ciclo” della sua soluzione.
Può inoltre essere utile sapere la priorità tra questi tipi di input, “press”, “trigger” e “repeat”; mentre è in pressione l’input “press”, gli altri 2 (ovviamente devono avere un input diverso) vengono del tutto ignorati, bisognerà rilasciare “press” e subito dopo premere l’altro; “trigger” essendo di input singolo viene ovvio pensare che viene scavalcato dagli altri 2; poi c’è “repeat”, se si preme un input di questa tipologia poi, tenendolo premuto quindi in loop, si preme uno invece “press”, quest’ultimo avrà la priorità, stranamente succede lo stesso anche se si preme uno “trigger”, anche se quest’ultimo non andrà in loop come gli altri 2; quest’ultime informazioni è quasi impossibile che vi saranno utili ma proprio quel quasi mi spinge a spiegarlo lo stesso.

– RICAPITOLANDO –

E… beh, dovrebbe essere tutto ma prima di lasciarvi voglio mantenere la promessa di spiegare come rendere fissa la finestra del codice postato inizialmente, per l’occasione ho modificato il nome della Variabile finestra mettendo semplicemente l’iniziale minuscola, ho anche cambiato il nome dello script (o sarebbe giusto dire classe), così come nella lista a sinistra (anche se non neccessario), insomma questo codice che posterò sarà anche un ricapitolo di gran parte delle cose spiegate in questa guida, principalmente gli input ma essendo anch’esse condizioni… vabbè, non perdiamoci in altre chiacchiere.

class Guida_Blog
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make title graphic
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.title($data_system.title_name)
    # Make window
    @fin = Window_Base.new(0, 0, 640, 120)
    @fin.contents = Bitmap.new(@fin.width-32, @fin.height-32)
    @txt = "..."
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of command window
    @fin.dispose
    # Dispose of title graphic
    @sprite.bitmap.dispose
    @sprite.dispose
  # end main
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # input
    update_command
    # fin update
    @fin.contents.clear
    @fin.contents.draw_text(0, 0, 640-32, 120-32, "#{@txt}", 1)
  # end update
  end
  #--------------------------------------------------------------------------
  # * Update Command
  #--------------------------------------------------------------------------
  def update_command
    # If X button was pressed
    if Input.press?(Input::X)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # txt
      @txt = "Input.press? X"
      return
    end
    # If Y button was pressed
    if Input.trigger?(Input::Y)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # txt
      @txt = "Input.trigger? Y"
      return
    end
    # If Z button was pressed
    if Input.repeat?(Input::Z)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # txt
      @txt = "Input.repeat? Z"
      return
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Map.new
      return
    end
  # end update_command
  end
# end Guida_Blog
end

Questo è a tutti gli effetti un script completo, anche se elementale pur sempre completo, con annessi anche i vari commenti per rendere più chiara la costruzione del script, cose che comunque faccio sempre, non per la guida; ora però studiamolo un pò, avendo già imparato gran parte delle cose ci sarà poco da aggiungere quindi tranquilli.

La prima cosa da notare è certamente che oltre a “main” ho aggiunto altri 2 “def”, “udpate” e “update_command”, dovreste ormai sapere che “main” deve essere chiamato per forza così (o comunque in alternativa a “initialize”, per script però di passaggio), mentre gli altri 2 come volete ma dato che nei script preinseriti ci sono “def” con utilizzo simile che si chiamano così, è meglio avere punti di riferimento, chiamando allo stesso modo “def” con l’utilizzo simile o uguale in script diversi; se poi volete chiamarli diversamente fate attenzione a cambiare anche dove il “def” viene richiamato, per esempio “update” viene richiamato nella riga numero 22, mentre “update_command” è chiamato nella 42° riga.
Richiamare un “def” è come richiamare un script “initialize”, è di passaggio ma può passare più volte, infatti “loop do” presente in “def main” va appunto a richiamare “update” all’infinito, però come vedere c’è un “break” all’interno della condizione “if $scene != self”, che vuol dire ferma tutto se la “scena” non è più questa, infatti se ricordate per richiamarlo abbiamo usato “$scene = Guida_Blog.new” (aggiornando ovviamente col nome della classe cambiato), poi vediamo in che modo la scena non è più questa; insomma, richiamato “update” a sua volta invece gestisce tutti gli altri “def”, le quali dicono al programma cosa fare in base a determinate condizioni.
Ricapitolando, “main” da il via gestendo principalmente la parte grafica/visiva, “update” invece gestisce tutto il resto.

Ehm… ho detto che sarei stato breve ma la prima cosa invece non lo è stato, questo perchè è la prima volta che tratto l’argomento, con le altre sarò più rapido… ma appunto tagliamo corto; la nostra amata finestra stavolta è presente nelle righe 10 e 11, per quanto riguardo la creazione, mentre viene inserito il testo alla 45°, ma bisogna notare che alla riga precedente viene cancellato tutto il suo contenuto per evitare che si accavali.
Il contenuto è “#{@txt}”, virgolette comprese (nel codice almeno), in questo caso la Variabile è già di testo quindi non sarebbero neccessarie ne virgolette ne “.to_s”, ma per abitudine ormai utilizzo sempre questo trucco per non preoccuparmi se è una Variabile stringa o meno; ricordando però, le virgolette va una all’inzio e l’altra alla fine dell’INTERO contenuto della finestra, mentre per ogni Variabile va fatto #{Variabile}, volendo potete anche fare calcoli ma devono essere all’interno delle parentesi graffe e se dovreste aver bisogno di virgolette all’interno di virgolette, per evitare di far confondere il codice, lasciate virgolette quelle a fine e inizio mentre tutte le altre sostituitele con un aprostofo “‘”.
Per aggiungere più righe alla finestra dovrete riscrivere “@fin.contents.draw_text(…)” facendo ovviamente attenzione a mettere il contenuto in posizioni diverse.

Ed eccoci arrivati al “def” che gestisce gli input, volendo li potete gestire dove vi pare ma per un script così elementare va più che bene così. Avrete capito che il testo da visualizzare nella finestra viene “deciso” dalla Variabile che ho chiamato “@txt”, ne ho messi di tutti e 3 i tipi così potete sperimentare voi stessi per capire bene la differenza, nel mio caso vanno semplicemente a cambiare valore alla Variabile, che a sua volta va a cambiare contenuto alla finestra.
Poi ho anche messo un codice che fa sentire un suono quando un input viene riconosciuto cioè “$game_system.se_play($data_system.decision_se)”, così facendo, se non fa il suono vuol dire che l’input non è andato.

Fra i vari input c’è anche “if Input.trigger?(Input::B)”, è quello che ho scelto per uscire da questa schermata, a dire il vero usare l’input B per uscire da una schermata fa proprio parte degli standard ma ovviamente scegliete quello che preferite; ma qual’è il codice specifico che fa uscire da questa schermata? “$scene = Scene_Map.new”, come anticipai anche la mappa di gioco è un script “main”, poi abbiamo imparato che per richiamare un script di questo tipo serve “$scene =”, ecco spiegato quel “if $scene != self” che blocca il loop, si cambia “scena” di conseguenza la scena attiva non è più questa.
Poi tutto quello presente dopo “loop do”, prima dell'”end” di “main”, serve per stabilizzare il gioco e cancellare tutte le finestre della schermata usando “.dispose”, se invece si facesse “.contents.dispose” si cancella solo il contenuto ma la finestra rimane, da non confondere con “.contents.clear”, con quest’ultimo lo si svuota ma c’è ancora.

Se poi avete provato lo script, avrete visto uno sfondo, ebbene se non viene specificato alcun sfondo sarà nero, per farlo basta utilizzare i codici presenti nelle righe 7 e 8; a sinistra dell’uguale è il nome della Variabile, quindi potete dargli il nome che volete, ovviamente a livello di codice non cambia solo per il fatto che per interagirci dovrete ricordarvi il nome dato; mentre a destra dell’uguale dovete riscrivere allo stesso modo, tranne “RPG::Cache.title($data_system.title_name)”, in questo caso ho messo lo stesso sfondo della schermata di titolo (quella che esce appena avviate il gioco), che potete cambiare da “Database -> System”, se volete utilizzare uno sfondo vostro ricordate che le misure sono 640×480 e inseritelo nella cartella “Titles”, o “Pictures”, all’interno a sua volta nella cartella “Graphics”, del progetto o direttamente in quella principale del programma, è consigliabile nella prima, poi sostituite “$data_system.title_name” col nome della vostra immagine (se l’avete messa nella cartella “Titles”, altrimenti leggete il prossimo paragrafo), tra virgolette perchè qui non ci sono essendo una Variabile, se invece cambiate direttamente lo sfondo dal database va bene mantenere lo stesso codice.
RPG::Cache.title(“nomeimmagine”) può servire anche in altri casi (che non spiegherò in questa parte della guida), l’importante è sapere alcune cose a riguardo: “RPG::Cache.” all’inizio va sempre scritto, poi in questo caso segue “title”, ricordate la cartella “Graphics” con all’interno la cartella “Titles”? Titles è il plurale di title (non tutti i plurali inglesi basta aggiungere la “s”, tanto per specificare), ebbene sostituite quel “title” con la stessa logica, in base in quale cartella si trova l’immagine desiderata.
Beh, poi non dimenticate di eliminare lo sfondo dopo il loop di “main”, come viene fatto nelle righe 33 e 34.

Prima di concludere avrete notato i vari “return” è sicuramente vi sarete chiesti a cosa servono, ebbene servono per “tornare” alla sezione precedente… aspettate, è banale ma complesso da spiegare: in questo dal “def update” viene richiamato il “def upade_command”, poi in una condizione input ecco un “return” dopo che un certo input fa la sua funzione; perchè proprio alla fine? Perchè dopo che “return” viene letto, tutto il resto del “def” non viene più preso in considerazione e si ritorna, sempre in questo caso, nel “def update” per continuare andando a fare ciò che viene specificato subito dopo il richiamo del “def upade_command”.
Vedremo nei dettagli più avanti, per ora vi basta sapere questo.

– CONCLUSIONE –

Insomma… dovrebbe essere tutto, almeno per ora, di certo potete già creare vari tipi di script con quello imparato fino a ora, anche se nulla di complesso è già qualcosa di concreto. Ebbene è momento di salutarci, grazie come sempre e alla prossima.

Guida RPG Maker XP Script #3 – Basi Scripting & Windows


Salve e benvenuti in questa nuova parte della guida, vi sta piacendo? Vi è utile? Spero ovviamente di si ma basta con i convenevoli. Dopo aver spiegato le basi è momento finalmente di mettere mano al progetto e iniziare a lavorare alla creazione del gioco dei vostri sogni; se non avete attualmente aperto il programma sul vostro progetto, cliccate su “Open Project” (se preferite potete trovarlo anche su “File”), andate nella cartella dov’è presente il vostro progetto e trovate il file “Game.rxproj”, “Game.exe” invece avvia il gioco NON come progetto quindi NON modificabile, quando passerete il gioco a qualcuno questo sarà il file da “doppio cliccare” per giocare, senza bisogno di avere RPG Maker XP, ricordandovi sempre di inserire nelle cartelle del progetto tutti i file che utilizzerete per evitare che quel qualcuno abbia problemi; giusto per dare un’altra informazione utile, una volta aperto il progetto potete andare su “Game -> Open Game Folder”, traducibile in “Apri Cartella Di Gioco”, quindi credo sia inutile specificare cosa fa.

Ma bando alle chance e andiamo nel vivo della guida, stavolta l’argomento è “Windows”, ovviamente non mi riferisco al sistema operativo della Microsoft ma bensì alle “Finestre” da creare grazie a codici specifici in base alle proprie esigenze; in un gioco tutto è guidato da codici, da ciò che si vede a ciò che si fa, RPG Maker XP offre già una base solida su cui iniziare ma il discorso non cambia, tutti i codici di questa base solida sono pre inseriti in “Script Editor” a progetto appena creato, poi in base al tipo di gioco che si vuole creare, alcuni di essi nemmeno li sfrutterete in alcuni casi; comunque prima di vedere come creare e visualizzare una finestra serve conoscere le basi di come creare uno script.

Iniziamo? Iniziamo! Ora possiamo finalmente aprire “Script Editor” e cosa ci ritroveremo?


Caaalmi, non spaventatevi, a fine di questa guida giuro che tutto ciò che state vedendo in questo momento non vi spaventerà più ma anzi, lo comprenderete a pieno ma ovviamente va fatto un passo alla volta. Prima di tutto, come anticipai nell’introduzione, la lista a sinistra sono i vari script presenti nel progetto, ogni progetto ha i propri script, se create uno script in un progetto non sarà presente in altri a meno che non lo inseriate personalmente, così come, se eliminerete uno script base volendo lo potete recuperare da altri progetti o al massimo creandone uno nuovo di proposito… quanti errori risolti così facilmente ho fatto, lo stesso vale per gli script modificati; mentre a destra è lo script selezionato dalla lista di sinistra, a proposito di quest’ultima, va pensata come una cartella con all’interno i vari “file” con gli script a suo interno, in questo caso i vari file possono anche avere tutti lo stesso nome e non per forza deve centrare col contenuto ma ovviamente è consigliabile fare ciò, specifico per fare capire che ciò che c’è scritto a sinistra serve solo a voi e non al programma.
Una cosa da sapere prima di iniziare è, se cliccate col destro del mouse (o sinistro se li avete invertiti) su un elemento a sinistra, usciranno vari comandi utili: Insert, Cut, Copy, Paste, Delete e Find; Insert inserirà un nuovo elemento sopra a quello selezionato; con Cut, Copy e Paste, potete Tagliare, Copiare o Incollare l’intero script, utile se volete ordinare un pò o prenderne uno da un progetto a un altro; Delete per eliminare lo script, attenzione che così facendo non sarà più recuperabile, se vi capita di farlo per errore la cosa migliore da fare è uscire dal progetto, chiudendo magari il programma, senza salvare, ricordando che “Playtest” salverà in automatico; in fine c’è Find, serve per cercare in TUTTI gli script un determinato testo, dalla lista specificherà il nome e la riga dov’è presente e cliccando dove volete andare poi su “Jump” sotto vi “teletrasporterà” li, senza neanche bisogno di andarlo a cercare.

– BASI SCRIPTING –

Ora credo sia il caso di scriptare qualcosa.


Tendendo selezionato Main ho cliccato su Insert, una cosa assolutamente da ricordare è che Main deve trovarsi sotto a TUTTI gli script, il mio script l’ho chiamato “Guida_Finestra” e inserito quello che vedete sopra, che ora spiegherò.
Prima di tutto, vedete quelle righe che iniziano con un “cancelletto”, o hashtag “#”, come potete vedere vengono automaticamente colorate di verde, c’è un motivo? Sono chiamati “commento” e servono a “spiegare” il codice, a livello di codice vengono saltati quindi non preoccupatevi e scrivete tutto ciò che ritenete opportuno da, magari, ricordare, una volta che riprenderete il codice in mano, ricordando però che va messo a ogni singola riga di commento.
Ricordate quando dissi/scrissi che la Classe va considerata un edificio e i Def le sue stanze? Beh, questa cosa continua a essere utile per capire ciò che spiegherò di seguito; ora vediamo “tecnicamente” cosa ho fatto:

– Come anticipato, è consigliabile dare un nome allo script che sia esplicativo, io nel dubbio do sempre lo stesso nome del “Class” ma ricordo che non è importante per il codice, quello serve solo a chi scriverà/leggerà il codice.
– Al programma SERVE capire quando una cosa inizia e quando finisce, in questo caso ci sono solo 2 cose, “Class” e 1 “Def”, che ho chiamato rispettivamente “Guida_Finestra” e “main”, per fargli capire poi quando finiscono basta un semplice “end” (fine), se non scriverete “end” si bloccherà il programma ma tranquilli, non dovrebbe causare danni a meno che se nello stesso momento il vostro PC dia altri problemi (giusto per mettere le mani avanti sotto ogni casualità); attenzione però che ogni elemento del codice va messo accapo di quello precedente altrimenti li considererà come se fosserò lo stesso elemento, dando ovviamente errori di lettura, come al solito ci sono eccezioni a questo che vedremo a tempo debito; mentre per quanto riguarda lo spazio dal bordo sinistro, quello serve solo per ordine visivo, quando premerete “invio” per andare accapo il programma cercherà di prevedere lo spazio corretto, se non vi sta bene quello dato potete sempre cancellare come fareste con un file testo qualsiasi, per aggiungerlo invece dovete premere il tasto “Tab”, posto solitamente sopra al “Caps Lock” (o “pulsante col catenaccio”).
– Perchè “Guida_Finestra” per la Classe e “main” per il Def? Il primo potete dargli il nome che volete facendo però attenzione, un pò come per le Variabili, di farlo diverso da tutti gli altri, non fate però confusione col nome della Classe e nome dello script (lista a sinistra), il primo come detto devono essere sempre diversi mentre il secondo vanno bene anche tutti uguali (sconsigliabile ma possibile); mentre per il Def, solo il primo non potete sceglierlo, va per forza “main” o “initialize” (spiegherò subito dopo), tutti gli altri come vi pare, purchè siano tutti diversi quelli presenti nella propria Classe, quindi va bene dare lo stesso nome di uno presente in un’altra Classe.
– “main” o “initialize” questo è il problema… o forse no? Ovviamente questo dipende dallo script che volete creare; “main” se volete creare una vera e propria schermata, che si chiuderà solo a traverso un determinato codice, per esempio il menù di gioco è uno script “main” (almeno quello standart di RPG Maker XP), lo stesso vale per il menù di inizio gioco e via dicendo, insomma utilizzate “main” se volete creare uno script in “loop” finchè non viene fermato da un codice (questo lo vedremo ovviamente), inoltre va ricordato che è possibile tener attivo 1 solo script “main” alla volta, lo stesso gironzolare nella mappa di gioco è “main”; se invece “initialize” il discorso è molto più semplice, gli script “initialize” sono quelli script che potremo definire di passaggio, poi possono passare più volte ma non vanno in loop a parte casi particolari ma con loop troppo lunghi (in senso di tempo) facilmente si bloccherà il programma, come già detto si può tener attivo un singolo script “main” alla volta, mentre per quelli “initialize” il discorso è un pò complicato da spiegare, per far capire in modo facile: se viene “richiamato” uno “main” quello precedente si stopperà, mentre lo stesso non vale con uno “initialize” che più che stopparsi in questo caso potremo dire che va momentaneamente in pausa finchè l’altro script “initialize” chiamato non finisce di fare le sue cose.

– RICHIAMO SCRIPT –

Abbiamo visto le basi teoriche e pratiche per capire come creare uno script ma ovviamente siamo ancora lontani da avere le conoscenze adatte per crearne uno completo, tanto per iniziare, come richiamare uno script? Ovviamente non basta averlo presente nella lista (anche se… no, no, è sconsigliabile fare in quel modo) ma serve un codice per dire al programma “avvia questo script”, come? Semplicemente $scene = NomeClasse.new per uno “main” o solamente NomeClasse.new per uno “initialize”, ovviamente sostituendo quel “NomeClasse” con la Classe che desiderate richiamare; questo lo si può fare sia all’interno di uno script sia in un Evento posto nella mappa, col comando “Script”.
Dato che all’interno di uno script basta solamente scriverlo, potreste aver problemi invece se lo volete richiamare attraverso Evento, quindi spieghiamo con calma come fare:


Prima cosa chiudete Script Editor, poi selezionate il Layer Eventi (il cubo), fate doppio click dove volete posizionare l’Evento (nel mio caso subito sotto alla posizione del giocatore).


Le impostazioni che vedete, ora come ora non vi serviranno tutte… doppio click sul riquadro subito sotto “Graphic:” per scegliere appunto la grafica, cioè ciò che appare visivamente, io ho scelto “104-Civilian04”; tra le opzioni subito sotto ora è importante solamente sapere i “Trigger”, che vuol dire “come avviarlo?”, vediamoli velocemente:

Action Button – Si avvierà quando il giocatore lo “toccherà” e cliccherà il pulsante azione (invio, spazio o “C”).
Player Touch – Si avvierà quando il giocatore tenterà di occupare il suo spazio.
Event Touch – Come Player Touch ma anche nel caso opposto, cioè anche se l’evento tenterà di occupare lo spazio del giocatore.
Autorun – Si avvierà bloccando tutto il resto andando in loop; esistono tanti modi per stopparlo, per esempio col comando “Erase Event” (“Cancella Evento” posto nella colonna a sinistra della prima pagina).
Parallel Process – Simile a “Autorun” con la differenza che non bloccherà il resto.

Chiusa questa parentesi, doppio click nel grosso riquadro dove c’è “@>”, si aprirà la lista dei vari comandi Evento, quello interessato è “Script”, posto nell’ultima (la 3°) pagina in fondo alla colonna a destra, questo serve per poter scrivere script anche negli Eventi ma con un numero caratteri limitato quindi conviene comunque Script Editor, se non per cose brevi come queste; beh, potete finalmente scrivere il codice per richiamare lo script, in questo caso “$scene = Guida_Finestra.new”… MA PRIMA… se tenterete di richiamarlo ora non avrete alcuna reazione dato che lo script come ve l’ho mostrato prima è solamente uno scheletro di script vuoto, quindi vediamo di aggiungergli qualcosa per vedere se funziona il richiamo o no; ovviamente prima di tutto non confondetevi e cliccate su “OK” per evitare di ricostruire l’Evento da 0.

#==============================================================================
# ** Guida_Finestra
#------------------------------------------------------------------------------
#  Questo serve come guida a costruire una finestra.
#==============================================================================

class Guida_Finestra
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    print("prova")
    # Restore BGM and BGS
    $game_system.bgm_play($game_system.playing_bgm)
    $game_system.bgs_play($game_system.playing_bgs)
    # Update map (run parallel process event)
    $game_map.update
    # Switch to map screen
    $scene = Scene_Map.new
  end
end

Nel Def main ho aggiunto un pop-up con messaggio che appare al richiamo dello script, tutto quello che segue stoppa lo script, dato che è “main” e non “initialize” altrimenti andrebbe avanti all’infinito non dandovi la possibilità di chiudere il programma, nel caso vi accada andate nel “Gestione Attività” del vostro PC per forzare la chiusura; cooomunuque, se vi apparirà il messaggio pop-up (in questo caso “prova”, vi apparirà senza virgolette, un pò come una Variabile testo) al click sull’evento allora avete richiamato corettamente lo script, altrimenti rivedete con calma i vari passaggi: creare un Evento col comando script “$scene = Guida_Finestra.new” con trigger “Action Button”; assicuratevi di mantere le modifiche all’Evento cliccando su “OK”; modificate, prima o dopo la creazione di tale Evento, lo script come mostrato sopra.

– WINDOWS –

E ora vediamo finalmente come creare una Window… o Finestra se preferite.

@Fin = Window_Base.new(0, 0, 640, 120)
@Fin.contents = Bitmap.new(@Fin.width-32, @Fin.height-32)
@Fin.contents.draw_text(0, 0, 640-32, 120-32, "Guida_Finestra", 0)

L’ho sostituito a “print(“prova”)”, per farvi capire come posizionare il codice in modo corretto, ora spieghiamo le 3 righe:

@Fin = Window_Base.new(0, 0, 640, 120) – Quello a sinistra dell’uguale, “@Fin”, è il nome che ho voluto dare alla Finestra, è una Variabile quindi valgono le regole già dette quando ho spiegato le Variabili; mentre a destra è effettivamente il valore della Variabile, essendo però una Variabile particolare vanno rispettate alcune regole, “Window_Base.new” serve per far capire che si vuole creare una Variabile Finestra, quindi va scritto esattamente così.
Mentre “(0, 0, 640, 120)”, per spiegarlo in modo comodo riscriviamo così: (xo, yo, x, y), la “x” intende l’ordine orrizontale, sinistra e destra, mentre la “y” intende l’ordine verticale, sopra e sotto, invece l’aggiunta della “o” intende “origine” (ora vediamo) e va considerato che “x” e “y” valgono entrambe 0 all’angono alto sinistro; con “origine”, “xo” e “yo”, si intende la posizione della Finestra, per la precisione dell’angolo alto sinistro di tale, mentre i valori “x” e “y” intendono la grandezza della Finestra, prendete in considerazione che su RPG Maker XP lo schermo è grande 640×480, potete anche farla più grande ma viene ovvio pensare che non si vedrà tutta se lo fate.
@Fin.contents = Bitmap.new(@Fin.width-32, @Fin.height-32) – “Window_Base” da, sembra una battuta, la base della Finestra, un pò come se per disegnare prendete, giustamente, prima un foglio poi ci create il disegno sopra, sarà banale ma in programazione non va dato nulla per scontato, il programma vuole che specificate ogni minima cosa, infatti questo codice non è ancora arrivato al “disegno” ma da un “corpo” alla Finestra, per prepararla a ricevere contenuti, “.contents” potremo dire che da un ulteriore livello o grado alla Variabile @Fin.
“Bitmap.new(@Fin.width-32, @Fin.height-32)” va semplicemente a specificare quando spazio si vuole occupare nella Finestra, in questo caso ho voluto specificare che mi serve tutto lo spazio possibile, quei “-32” vanno a sottrarre i bordi, che sono 16 per lato; “width” e “height” a loro volta vogliono dire larghezza e altezza.
@Fin.contents.draw_text(0, 0, 640-32, 120-32, “Guida_Finestra”, 0) – Arriviamo finalmente a inserire contenuto a questa beneamata Finestra, testo per la precisione, volendo si possono aggiungere anche immagini ma per ora voglio giusto dare il concetto generale; in questo caso nessun “=” ma direttamente una parentesi, che segue comunque il tipo di contenuto, “draw_text”, per determinare cosa e come.
“(0, 0, 640-32, 120-32, “Guida_Finestra”, 0)” similmente al codice iniziale, “Widow_Base.new(…)”, i primi 2 numeri specificano la posizione mentre i 2 che subito seguono la grandezza che occuperà ma in questo caso tali numeri non prenderanno in considerazione lo schermo ma bensì la Finestra, se per esempio questa stessa Finestra invece che metterla a “0, 0” la metterei a “0, 50”, lo “0, 0” di “draw_text” non cambia la posizione rispetto alla Finestra dato che appunto fa riferimento al contenuto di quest’ultima anche se più precisamente al contenuto preso in considerazione nella seconda riga, “Bitmap.new(…)”, che è sempre consigliabile, se non casi molto particolari, specificare tutto lo spazio possibile, come fatto da me.
Andando invece al 5° elemento di questa riga, “Guida_Finestra”, è proprio il contenuto da visualizzare, può essere anche numerico o qualsiasi altro tipo specificato nelle Variabili, con la differenza che, qualsiasi altro che non sia testo va convertito in stringa con “.to_s”; in fine c’è un ulteriore elemento da notare, in questo caso è 0 ma può essere anche 1 o 2, non è obbligatorio e se non viene specificato vale come se fosse 0, ma che differenza fa? 0 il testo si allinea a sinistra, 1 centrato mentre 2 a destra.

Per ricapitolare rimettiamo il codice completo:

#==============================================================================
# ** Guida_Finestra
#------------------------------------------------------------------------------
#  Questo serve come guida a costruire una finestra.
#==============================================================================

class Guida_Finestra
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    @Fin = Window_Base.new(0, 0, 640, 120)
    @Fin.contents = Bitmap.new(@Fin.width-32, @Fin.height-32)
    @Fin.contents.draw_text(0, 0, 640-32, 120-32, "Guida_Finestra", 0)
    # Restore BGM and BGS
    $game_system.bgm_play($game_system.playing_bgm)
    $game_system.bgs_play($game_system.playing_bgs)
    # Update map (run parallel process event)
    $game_map.update
    # Switch to map screen
    $scene = Scene_Map.new
  end
end

Senza dimenticare come richiamarlo da Evento con “$scene = Guida_Finestra.new”.
Ora invece del messaggio pop-up dovrebbe apparire la Finestra appena costruita, sempre se avete fatto tutto correttamente… ma che succede?! La Finestra sparisce dopo un tot di tempo, che abbiamo sbagliato? … niente, ora vi spiego: quando una Finestra appare ha, anche se non credo sia proprio essatto nel gergo, una scadenza, dopo la quale sparisce, per evitare ciò bisogna tenerla sempre attiva però… per ora volevo giusto darvi delle basi solide, ci siamo già persi troppo in chiacchiere, nella prossima parte vedremo questo nel dettaglio e altro; come al solito grazie per essere qui e alla prossima.

Guida RPG Maker XP Script #2 – Variabili


Dopo l’introduzione, che nel caso l’avreste saltata vi consiglio di leggerla a meno che non sappiate già le basi del programma, quest’altra parte della guida la possiamo considerare a tutti gli effetti la prima, iniziando a vedere le funzioni più importanti nei dettagli, da conoscere prima di creare uno script. Ero indeciso se iniziare con gli Eventi o le Variabili, essendo entrambi importanti da sapere, ma ho scelto le seconde essendo questa guida basata sullo scripting, peggio che vada per gli Eventi spiegherò tutto ciò che serve a tempo debito… iniziamo?



Rimetto la schermata di progetto appena creato perchè può servire come punto di riferimento, infatti vi ricordo che per lavorare agli script bisogna cliccare sull’icona cerchiata ma come anticipato ora parleremo delle Variabili, quindi non metteteci ancora mano per ora.

Una Variabile ha sia un nome che un valore, questi due elementi poi si diramano in tante possibilità, scegliere le “possibilità” adatte a cosa si vuole fare è alla base dello scripting, come anticipato; inutile andare nei minimi dettagli, si allungherebbe solo il brodo ma state sicuri che spiegherò tutto ciò che c’è da sapere.

– NOME –

Il nome non è altro che un “identificativo”, per dire al programma “voglio questa Variabile”, non è possibile creare due Variabili con lo stesso nome a meno che non siano di “validità” diversa (spiegherò cosa intendo), proprio come accade ai nomi dei file sul PC anche se non proprio ma per dare dei riferimenti per far capire almeno le basi; se per esempio create una Variabile di nome “A” e gli date come valore “a”, se poi create un’altra variabile chiamata “A” ma gli date come valore “b”, quella precedente verrà sovrascritta, quindi alla fine vi ritroverete con “A = b”, di conseguenza è da ricordare che, nel caso ci siano più Variabili con lo stesso nome, quella che alla fine del codice rimarrà sarà quella scritta in fondo a tutte… vabbè che ci possono essere eccezioni in base a come le gestite ma per ora vi basta sapere questo; va inoltre ricordato che il nome di una Variabile non accetterà spazi, nel caso potete sempre utilizzare “_” invece dello spazio, non accetterà neanche punteggiatura, come punto, virgola, ecc… ne fatta SOLO di numeri.

– VALIDITÀ –

Cosa intendo con “validità”? Immagino che non sia il termine tecnico ma di certo fa capire il concetto, esistono ben 3 validità per una Variabile, globali, di instanza e locali, per far capire al programma che validità si ha intenzione di dare a una Variabile: se globale il nome deve iniziare con “$” (simbolo del dollaro), se di instanza invece “@” (chiocciola, come per le email) e se invece la Variabile deve essere locale non va aggiunto alcun che al nome; un’altra cosa da specificare è che è conveniente evitare di scrivere il nome di una Variabile, che non sia globale, con l’iniziale maiuscola, questo per evitare bug o simili… ora però spiego la differenza pratica di queste 3:

Globale – Una volta che il programma legge dal codice una variabile globale, quella valerà ovunque, in qualsiasi script leggerà di seguito, questo vuol dire che, se per esempio create una Variabile “$A = a”, tale Variabile esisterà e manterrà il valore “a” anche in altri script; nel caso non vi è abbastanza chiaro, va sottolineato che non basta scriverla in un punto a caso per farla “esistere” ovunque ma ciò accadrà solamente se il codice dov’è presente verrà letto… ma torneremo su questo nei dettagli prossimamente.
Di istanza – Una Variabile di istanza valerà solo per lo script dov’è presente, avete presente la schermata “Script Editor”? Bene, la lista a sinistra sono tutti gli script presenti nel progetto, quest’ultimi sono racchiusi in una “Class” (Classe), ebbene una Variabile di istanza esisterà solo nella propria “Classe”, sempre una volta letta dal programma… beh, esistono anche sotto classi e altre eccezioni che, mi scuso per la ripetitività, vedremo prossimanete.
Locale – Ogni validità di Variabile va sempre più dentro al codice ed è più restrittiva, infatti per ques’ultima vanno leggermente anticipate delle cose sugli script; come già detto ogni script è denominato da una Classe, va ora aggiunto che ogni Classe si divide in vari “Def” (non so come si potrebbe tradurre in italiano ma non è importante… immagino), ecco qui dov’è limitata l’esistenza di una Variabile locale.

Per ricapitolare i Def li possiamo immaginare come delle stanze e le Classi come degli edifici, una Variabile globale valerà per tutti gli edifici, una di istanza solo per l’edificio dove si trova, mentre una locale solo nella stanza dove si trova.

– VALORE –

Credo che la questione nomi Variabile sia abbastanza chiara, certo ci sono alcuni concetti solamente accenati ma per ora non dategli peso e concentriamoci sul capire come gestire il valore di una Variabile.
Andiamo prima a grandi linee poi vediamo i dettagli; una Variabile può avere un valore numerico, cioè matematicamente accettato, un valore di testo (o alfanumerico) che possono essere lettere e/o numeri, in fine esiste anche il valore “binario”, del tipo “si o no”, “maschio o femmina” ma nel caso di RPG Maker “true o false” ovvero “vero o falso”, quest’ultimo lo si può anche chiamare “Switch” più che Variabile… ci sarebbe però da precisare che è possibile creare una Variabile vuota, senza valore, in tal caso il valore (se lo si può chiamar così) sarà “nil”.
Un valore di una Variabile testo va scritto tra virgolette, per intenderci meglio fare un esempio: A = “a”; è inoltre possibile, entro certi limiti, convertire un valore numerico a testo e viceversa, così come rendere testo un valore binario o vuoto, in che modo? Vediamo.

– CONVERSIONE –

Esistono 3 tipi di conversione di un valore: Integer, Float e String; Integer sono i numeri interi, cioè senza virgola (che però va scritto un punto invece della virgola, come nelle calcolatrici), nel caso si faccia un calcolo e il risultato è un numero con la virgola, se la Variabile che prende questo risultato è Integer (com’è di base una Variabile numerica nel RGSS), viene automaticamente arrotondato per difetto, cioè “virgola” e numeri dopo di essa vengono eliminati; Float a sua volta è una Variabile numerica che però accetta i numeri decimali (quelli dopo la virgola); infine c’è il valore String, cioè stringa che si intende un testo.
Ma ora vorrete di certo sapere che codice bisogna usare per convertire, ebbene è “.to_i”, sostituendo “i” con “f” o “s” in base alla conversione desiderata, e va messo subito dopo il valore che è consigliabile metterlo tra parentesi per evitare errate letture del codice da parte del programma, per esempio: A = (20).to_s. Da ricordare, se un valore testo viene convertito in Integer o Float, se contiene solo numeri va bene altrimenti diventerà sempre 0.

– VALORE A CATENA –

Un’altra cosa che può essere utile sapere è quello che a me piace chiamare “valore a catena”, se per esempio vi servono 3 Variabili che devono valere 0, che fate? Li scrivete una alla volta occupando quindi 3 righe di codice? E invece no, cioè potreste ma potreste anche rispiarmiare scrivendo direttamente: a = b = c = 0, così facendo si sono create ben 3 Variabili, “a”, “b” e “c” che valgono 0 rispiarmiando prezioso spazio nel codice; praticamente dite al programma “crea una Variabile di nome a che ha lo stesso valore bella Variabile di nome b che ha lo stesso valore della Variabile di nome c che vale 0”; con questo capite anche che potete creare una Variabile che sia uguale a un’altra variabile esistente, per esempio a = b, se invece la Variabile “b” non esiste “a” avrà valore “nil”.

– MATEMATICA –

Eh già, la tanto odiata (non da me, tanto per dire) matematica, volenti o dolenti, bisognerà affrontarla per scriptare essendo alla base di tutto, questo sarà possibile proprio grazie alle Variabili.

Per le Variabili di testo sarà un semplice “lega questo testo a quest’altro”, per esempio: a = “abc”+”def”, alla fine verrà fuori a = “abcdef”, mentre per le Variabili Integer o Float è da fare un discorso più elaborato ma per ora non scenderemo nei dettagli.

– Con questo linguaggio di programmazione è possibile utilizzare ogni tipo di operatore matematico, da quelli che ci insegnano alle elementari a quelli di ingegneria aerospaziale… ma io mi fermerò a quelli delle medie. C’è l’addizione “+”, la sottrazione “-“, la moltiplicazione “*”, la divisione “/” (da non confondersi con la barra obliqua opposta), la potenza “**” e in fine per la radice quadrata basta fare la potenza alla 0.5; esiste anche un operatore un pò particolare “%”, fa la divisione ma da come risultato il resto, del tipo: 6%3 = 0 o 8%3 = 2.
– Ora mettiamo caso che esiste già una Variabile di nome “a” che vale “3”, se scriverete nel codice a += 1, finirà poi col valere “4”, perchè quel “+=” va a modificare direttamente la Variabile posta a sinistra, in questo caso sommando col risultato posto a destra, anche nel caso non ci sia solamente un numero; lo stesso si può fare con gli altri operatori matetatici.
– Come già detto, un numero Integer arrotonda per difetto, quindi se volete arrotondare un valore Float per difetto basta convertirlo in Integer, “.to_i”, se invece vorreste arrotondare il numero per eccesso? “.ceil”, questo può essere utile, per esempio, per capire la percentuale di PS (Punti Salute) rimasti a un determinato personaggio, dato che per difetto quando mancano pochi PS la percentuale segnata potrebbe essere 0 facendo capire erroneamente che non ne ha più, ecco perchè sarebbe utile utilizzare l’arrotondamento per eccesso; per essere precisi, si dovrebbe fare così: (PS/PSMax).ceil.
– A scuola ci insegnano che vanno utilizzate parentesi tonde (), quadre [] e graffe {}, no? Qui invece andranno solo le tonde, almeno matematicamente parlando; mentre per quanto riguarda il discorso che ci insegnano sempre a scuola, cioè si fanno prima le moltiplicazioni e divisioni, in caso di più operatori, l’RGSS rispetterà questa regola… va specificato in caso vogliate fare lunghi calcoli.

– ARRAY –

Gli “Array” sono anch’essi una Variabile che però possiede più valori, ci starebbero tante cose da dire su tale ma per ora non voglio appensatire il discorso già lungo di suo, andando a dire solo le cose importanti.
Prima di tutto, gli Array avranno più valori ma invece il nome è singolo, però attenzione, come detto sono anch’essi delle Variabili quindi se prima create una Varibile poi un Array, o viceversa, con lo stesso nome, la prima svanirà sovrascritta dalla seconda; per i valori possono essere una quantità anche infinita (nei limiti del PC) e non per forza tutti dello stesso tipo (numero, testo, ecc…).

Come si crea un’Array? Per fare un esempio: a = [1, “z”, true]; per invece richiamare un determinato valore, il primo ha un “index” (indice) 0 e non 1 come verrebbe da pensare, bisogna per esempio fare: a[1], riprendendo l’Array del precedente esempio, dato che i valori sono 1, “z”, e true, all’indice 1 c’è “z” quindi verrà estrapolato tale valore; se invece si scrive solo il nome dell’Array, il programma leggerà tutti i valori attaccati, tornando all’Array esempio di prima, in questo caso verrebbe fuori “1ztrue”, ovviamente convertendo in String: a.to_s, se poi si desiderasse aggiungere qualcosa che li distanzia, in questo esempio uno spazio: (a*” “).to_s, si avrà “1 z true”, quest’ultima cosa può essere molto utile durante i test, difficilmente a gioco completo.

Prima di concludere il discorso Array vediamo in poche parole (si fa per dire, capite quindi quando ho detto che ci starebbe tantissimo da dire?) tutto ciò che serve per avere un quadro generale.

– Volete creare un’Array con un numero specifico di valori e tutti uguali (magari modificandone alcuni successivamente)? a = Array.new(n, x), sostuite “n” con la quantità di valori desiderata, mentre “x” col valore, se non ci specifica quest’ultimo, a = Array.new(n), si andrà a creare un’Array con tutti valori vuoti, cioè “nil”.
– Sempre sul discorso creare automaticamente un’Array senza scrivere ogni minimo valore c’è a =* (“a”..”b”), che va a creare un’Array con valori dalla “a” alla “b” in ordine alfabetico, ovviamente sono d’esempio, potete mettere le lettere che volete, anche “b” poi “a” per un ordine inverso, stesso discorso vale se inserite 2 numeri.
– Per aggiungere un valore ad un’Array già creata (in questo esempio, di nome “a”) esistono 3 metodi, che aumentano di conseguenza la lunghezza dell’Array: a.push(x), il valore “x” verrà aggiunto alla fine (index massimo); a.unshift(x), il valore “x” verrà aggiunto all’inzio (index 0); a.insert(i, x), anche qui la “x” va sostituita al valore che si vuole inserire, la “i” sta per index quindi in quale indice inserirlo, se per esempio a.insert(2, “x”) “x” andrà al posto del valore attualmente su index 2, facendo scavalcare l’indice a tutti i successivi; con quest’ultimo è anche possibile aggiungerne di più conteporaneamente, per esempio a.insert(i, x, y, z), all’indice “i” si aggiungerà “x” mentre “y” e “z” subito quelli successivi.
– Discorso simile nel eliminare i valori: a.pop elimina l’ultimo valore dell’Array; a.shift elimina invece il primo; a.delete(x) eliminerà tutti i valori uguali a “x”; a.delete_at(i) (essendo sottolineato non si nota il trattino basso, cioè “delete_at”) eliminerà invece il valore presente all’indice “i”, facendo arretrare tutti quelli successivi.
– Esistono anche metodi per ordinare i valori di un’Array, per esempio “reverse” o “reverse!” (si, cambia solo che c’è il punto esclamativo), come suggerisce, si invertono l’ordine dei valori dell’Array, “gli ultimi saranno i primi” praticamente; cosa cambia con o senza punto esclamativo? Senza semplicemente è momentaneo, se magari vi serve momentaneamente (appunto) per, che so, un testo… effettivamente è difficile che vi servirà farlo solo momentaneamente (quindi SENZA punto esclamativo) ma giusto per informazione; c’è poi “sort! {|a, b| a – b}” che ordinerà numericamente, viene quindi ovvio pensare che funziona solo con Array con solo valori solo numerici; se cercate lo stesso di prima ma che ordini al contrario allora “sort! {|a, b| b – a}”, senza bisogno di aggiungergli anche “reverse!”; se invece vi serve un ordinamento alphabetico, utilizzabile solo con array contenente solo testo, allora fate “sort! {|a, b| a <=> b}”, dove “<=>” andrà a sostituire “-“.

– CONCLUSIONE –

Beh, credo sia il caso di chiudere qui il discorso Variabile e derivanti, vedremo i dettagli a tempo debito, quando inizieremo ad applicarle in un codice; come al solito spero seguirete il resto della guida intando grazie per essere qui.

Guida RPG Maker XP Script #1 – Introduzione


Salve, non ci sentiamo da tempo, eh? Saltiamo i soliti e ripetitivi convenevoli per passare a spiegare ciò per cui sono qui a scrivere tutto ciò… avete mai sentito parlare di RPG Maker? Se no e volete avere le “carte” per creare un vostro gioco, non per forza RPG (o GDR, Gioco Di Ruolo, in italiano) come suggerisce il nome, allora siete nel posto giusto, datemi giusto il tempo di completare questa guida… ma cosa importante, molti pensano che il programma faccia il 99% del lavoro e basta solo pensare, invece non è affatto così proprio per questo sono qui, io ebbi molte difficoltà da autodidatta quindi voglio condividere con voi ciò che ho imparato ma nulla mi vieta, giustamente, di imparare cose nuove e arricchire tale guida in futuro.
Inziamo con un pò di teoria, giusto le basi per capire di cosa stiamo parlando se siete qui da completi “ignoranti” sull’argomento, saltando “storia” come invece fanno di solito in queste guide, che noia, se sono interessato alla storia la cerco, no? Ma se siete qui immagino che siete interessati a ben altro, o no? Insomma di RPG Maker ne esistono vari: 2000, 2003, XP, VX… e altri, inutile fare la lista se tanto ne dimenticherò almeno 1; i primi 2 hanno un concetto di script ben diverso, la guida che scriverò sarà incentrata sulla versione XP, quelli successivi da quando ne so non sono molto diversi, cambia solo il linguaggio di programmazione e quindi la stesura del codice… ma andiamo con calma; specificando che io non sono espertissimo nel utilizzare termini specifici, quindi mi baserò comunque più sulla pratica che teoria. Quale linguaggio usa l’XP? Una sorta di Ruby ma poco modificato, in parte ricorda il Ruby On Rails (sempre in base a quel poco che so su quest’ultimi)… insomma, il linguaggio su cui si baserà questa guida si chiama RGSS, è ovviamente una “sigla” ma come detto la teoria non è la mia specialità e senza dubbio nella pratica non serve saperlo… ah, prima di iniziare sul serio mi sembra giusto specificare che RPG Maker XP non è gratuito, costa circa 25€ ma mettono sconti abbastanza spesso, infatti io l’ho preso a circa 7€ approfittando di questi sconti.

La prima cosa da fare è creare un nuovo progetto, vi ritroverete una schermata come questa; tranne il cerchio rosso che ho messo io per anticipare dove si dovranno gestire gli script, quelli già presenti o aggiungerne di propri; poi ovviamente il nome del progetto, nel mio caso ho deciso di chiamarlo “Guida”, potete anche metterne uno provvisorio e modificarlo in seguito, poi magari spiegherò come e dove.



Per concludere l’introduzione è il caso di specificare l’utilizzo delle varie icone, questa guida ci centralizzerà sugli script ma andremo a vedere anche altre funzioni; partendo da sinistra, si inzia con le “funzioni” (ripeto che non sono bravissimo nei termini) per il progetto in se:

New Project – Beh, se siete arrivati a tale schermata vuol dire che già sapete a cosa serve, creare un nuovo progetto.
Open Project – Per aprire un progetto già esistente.
Save Project – Per salvare le modifiche al progetto.

Seguono poi i classici Cut (Taglia, CTRL+X), Copy (Copia, CTRL+C), Paste (Incolla, CTRL+V) e Delete (Elimina, “canc” che si trova poco avanti a F12), riferendosi agli Eventi (poi vedremo) sulla mappa.

Undo – Annulla l’ultima modifica fatta sulla mappa, che siano Eventi o la mappa stessa.

Quelli che ora seguono sono i Layer (Strati) della mappa, i primi 3 sono principalmente visivi, poi l’ultimo, il cubo, Events per aggiungere/modificare gli Eventi già nominati, per ora è solo un introduzione quindi preferisco non scendere in dettagli.

Per i 3 Layer ci sono vari strumenti, che saranno inutilizzabili se si lavora con gli Eventi:

Pencil – La matita serve per modificare solamente 1 cella della mappa alla volta.
Rettangle – Per modificare la mappa creando forme a rettangolo/quadrato.
Ellipse – Per modificare la mappa creando forme circolari o elissi.
Flood Fill – Funziona come il secchiello di Paint andando a modificare aree di mappa.
Select – Per selezionare una parte di mappa, la quale può essere semplicemente spostata oppure tagliata, copiata, incollata o eliminata.

Ecco poi i vari zoom per visualizzare la mappa, quello più a sinistra è quello più “vicino” e quindi fa visualizzare un’area di mappa minore, poi l’area visualizzata cresce con i zoom più a destra.

I prossimi sono quelli principali da interagire per creare un gioco ben fatto o quanto meno originale.

Database – Cliccando qui si aprirà una schermata a più schede, dov’è possibile vedere le varie cose inserite nel gioco, sarebbe troppo lungo da spiegare ma andando avanti nella guida capirete bene la funzione di ognuno di loro.
Materiarls – Qui sarà possibile visualizzare i vari file audio e immagini principali del progetto, quelli col pallino blu sono presenti solamente nella cartella principale del programma RPG Maker XP, mentre il pallino rosso indica che sono presenti nella cartella del progetto stesso; se volete passare il progetto a qualcuno assicuratevi che tutti i file “sfruttati” abbiano il pallino rosso.
Script Editor – E beh, questa guida si baserà proprio su tale sotto menù, dove potrete visualizzare/modificare i vari script del progetto.
Sound Test – Questo semplicemente per ascoltare musica e suoni presenti, anche qui vale la regola dei pallini blu e rossi.
Playtest – Ultimo ma non per importanza, quando dovrete testare il progetto, anche qui ci starebbero tante cose da specificare ma evito essendo questa solo un introduzione che serve giusto per darvi un’idea generale.

Prima di concludere, vedete quel quadrato con scritto “S”? E’ un Evento ma particolare, è il “Player’s Starting Position” ovvero la posizione iniziale del giocatore, il personaggio comandato dal giocatore, per cambiarla dovete avere il Layer Eventi attivo e cliccare col destro del mouse (o sinistra se avete invertito i pulsanti) nel punto dove volete posizionarlo. Ebbene… questo dovrebbe essere tutto, spero che sia tutto chiaro e… alla prossima parte della guida, grazie!

Un disegno da raccontare #1 – Spirpa


(Tranquilli, stavolta le solite lamentele durano poco passando poi a spiegare l’articolo)

E vabbè, come al solito mi faccio tanti propositi “Mi occuperò di questo blog con più impegno”, ma puntualmente… niente o poco rispetto a come vorrei, volete sapere il vero problema di tutto ciò? Non certo mancanza d’idee, a voglia se fosse un problema di idee potrei anche scrivere 1 cosa al giorno (anche se mi scoccia fare sempre le stesse cose), il problema è che se non mi sento abbastanza ispirato non me la sento di scrivere, voglio che abbia un minimo di qualità, non solo contenuto ma anche la resa deve essere decente, quanto meno, tant’è che gli ultimi 2 scritti pubblicati non mi sono piaciuti ma pur di mettere qualcosa… ecco poi un’idea, visto che non scrivo per mancanza d’ispirazione, perchè non descrivere un ispirazione passata? Ovviamente non presente nel blog, o nel caso la vedrei da punti diversi e/o aggiungendo dettagli, comunque ho pensato a quella che si potrebbe definire “rubbrica” del blog, “Un disegno da raccontare”, l’idea mi è venuta proprio ieri mentre non riuscivo a dormire a causa del caldo, pensando che in quest’ultimo periodo sto riscoprendo la passione del disegno, non che l’avevo persa ma solo messa da parte, la sto anche arricchendo con i disegni digitali, infatti vedrete quasi sempre disegni digitali; ho ragionato sul nome più accattivante giusto 10 minuti, questo mi sembra perfetto, spero piaccia pure a voi. Vabbè, non perdiamoci in chiacchiere, iniziamo!

Link al DeviantArt: http://monmaltron.deviantart.com/art/Spirito-Dell-Arpa-Spirpa-688262674

Il tutto inizia un pò di tempo fa, quando i dinosauri calpestavano le nostre terre… aspettate, no, non così passato… ehm, non ricordo precisamente ma almeno 10 anni fa, a fine di quest’anno ne farò 27, preciso però che il disegno che vedete pubblicato sopra l’ho fatto di recente, è la sua storia che inizia tempo fa (non in mezzo ai dinosauri).

Io, mia sorella minore e 2 gugini (circa l’età di mia sorella), spesso ci mettavano a disegnare per il gusto di farlo, un giorno eravamo particolarmente ispirati da un disegno visto di recente su “ArtAttack” (programma TV pieno di carta igienica e vinavil) dove spiegavano come fare un pubblico “minimal” (cioè con meno dettagli possibili ma che si capisce cos’è) per un concerto, mentre loro fecero il classico Festivalbar (immagino sappiate cos’è, nel caso… ha a che fare con la musica) io, essendo da sempre affascinato da creature mitologiche e/o di fantasia, feci il “Festivalmonster” cioè un concerto dove sia chi cantava che chi suonava erano mostri (anche se attualmente preferisco chiamarli/e “creature”), persino le guarde del corpo, praticamente gli unici umani presenti erano proprio il pubblico, se si possono definire umani vabbè, gran parte di questi mostri erano umanoidi un pò deformati (per far capire senza scendere nei dettagli, non ricordandoli), ma ricordo di aver messo in mezzo a loro chiocciole (lumache col guscio) giganti con alcuni dettagli del corpo diversi, ma non chiedetemi perchè, dato che non c’è; tra i vari mostri che cantavano (se ricordo bene, 2) e suonavano vari strumenti (almeno 5), ricordo che mi piacque in particolar modo chi utilizzava una chittarra elettrica, con la tipica posizione di chi è alle prese con una scivolata con le gambe piegate e sguardo verso il cielo, questo accese in me un spunto che mi spinse a creare tanti mostri che centrano almeno un minimo con la musica, o che comunque sapessero suonare o cantare.

Tra triangoli con faccia e arti che suonavano il traingolo (si, c’è un strumento musicale chiamato “triangolo”), serpenti che avevano il microfono sulla punta della coda, uccelli che agitavano delle campanelle buttando aria con le ali, un violino vivente che si suonava da solo tenendo per mano… mi sfugge come si chiama quella bacchetta che serve per suonare il violino e tante altre cose sensa senso ma simpatiche a modo loro, ecco che arriva lei (ha un aspetto chiaramente femminile)… conoscendo una musica adatta a lei (almeno per me)…

Inizialmente avevo fatto una banale, ormai ripetitiva, arpa che con delle mani si suonava da sola, poi mi balza un vaghissimo ricordo nella mia testa, ricco di malinconia di tempi passati della mia infanzia (avrò avuto massimo 8 anni): ero alla TV a guardare un anime (cartone animato giapponese, precisando che allora non sapevo questa distinzione), c’era un ragazzo che fissava l’orrizzonte in spiaggia di sera, ad un tratto sente una musica soave e non resiste seguendo questa musica, arriva in una sorta di deposito della spiaggia pieno di oggetti vecchi ed impolverati, la musica sembra provenire proprio da li così si guarda intorno, ecco che vede un’arpa che sembra che suoni da sola, le corde vibrano ma non vede nessuno quando ecco che appare uno spirito di una ragazza, indossa una lunga veste chiara e suona l’arpa con un aria molto malinconica, il ragazzo ne rimase così affascinato che si sentì molto bene… purtroppo non ricordo altro, ho si altri ricordi ma così offuscati che mi fanno aver il dubbio che sia stato un sogno, sarà così? Se no però sarei curioso di rivedere l’anime dato che proprio non ricordo; com’è è la situazione, ho trasmesso gli stessi sentimenti nel mio disegno o almeno ci ho provato, il primo pieno d’ispirazione ed emozione di una lunga serie, avendo scritto una storia dove sono presenti molte creature lei non poteva mancare, ho deciso di chiamarla “Spirpa” unendo le parole “spirito” e “arpa” ricordando appunto quella scena dell’anime che vi ho raccontato, se mai capiterà qualcuno qui che ha letto quella mia storia (non ho detto il nome della storia ma del personaggio) si renderà conto che la scena raccontata mi ha ispirato davvero tanto, cercando di ricostruirla in parte nella mia storia dove si incontra Spirpa, con le dovute differenze ovviamente; il disegno che vedete sopra essendo l’ultimo ovviamente rispetta più di tutti l’idea iniziale, anche se dopo averlo finito ho notato alcuni errori di prospettiva ma da comunque un bel impatto, non trovate? Soprattutto ora che conoscete la sua storia… secondo voi quella scena l’ho davvero sognata o è reale? Se il primo caso… wow! Che cosa magnifica… anche se un pò inquietante.

Ok, non credo ci sia altro da aggiungere, mi sono emozionato anche nel descrivere le emozioni che mi hanno portato a crearla, a voi hanno fatto lo stesso effetto o almeno simile? Ho anche messo la musica adatta per accrescere l’emozione… vabbè, è finita qui, al prossimo “Un disegno da raccontare” o altro, grazie e ciao a tutti!