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.