mercoledì 8 aprile 2015

Enigma a codice in AGS

Ciao ragazzi,

nel video relativo al ciclo while promisi una puntata su come creare un enigma a codice. Purtroppo però nelle ultime settimane non ho avuto modo di registrarlo.
Avevo però il tutorial pronto da tempo e mi dispiaceva farvi attendere oltre, quindi alla fine ho deciso di farlo in forma scritta così da non dover ancora aspettare il momento giusto per registrare.

Non appena avrò il tempo per farlo, caricherò comnque una versione video di questo tutorial sul canale youtube.

Prima di cominciare, breve premessa per le parti di codice che vedrete.
Le righe in neretto rappresenteranno le nuove righe di codice aggiunte rispetto allo script mostrato in precedenza.

function room_RepExec()

 
}

function room_RepExec()

  if(enigmaRisolto == true)
  {
    Display("Bravo!");
    Display("Bravissimo!");
    Display("Sei un genio!");
    Display("Ma come hai fatto?!");
    Display("Ok basta, non fa ridere...");
  }
}

I tre puntini invece indicheranno che in quel punto è presente del codice che però per quell'esempio non è importante mostrare ancora, questo per non rendere troppo lunghi gli esempi di codice.

function room_RepExec()

  if(enigmaRisolto == true)
  {
    ... //I Display dell'esempio precedente
    
    cEgo.ChangeRoom(2); //Nuova riga di codice
  }
}

Alla fine dell'articolo troverete comunque tutti gli script completi.
Bene ragazzi, cominciamo!

Innanzi tutto, apriamo il nostro progetto in AGS. Può essere un gioco nuovo o esistente nel caso vogliate inserire in esso l'enigma.

Il mio progetto prevede una sola stanza con una porta chiusa elettronicamente. A destra della porta c'è un tastierino numerico sul quale digitare un codice per sbloccarla.
Eccola qua:


Sul tastierino è posto un Hotspot chiamato hTastiera (blu) e sulla porta un altro chiamato hPorta (verde).


Ok, preparata la stanza cominciamo col creare la GUI che rappresenta il tastierino numerico. La chiamerò gTastiera.

Questa GUI contiene i seguenti elementi:

  • lTastiera: una Label per visualizzare il codice man mano che viene digitato dall'utente;
  • bNum0...bNum9: nove pulsanti per i numeri da 0 a 9;
  • bBackSp: un tasto per cancellare una cifra alla volta il codice partendo da destra, esattaamente come il tasto Backspace della tastiera del nostro pc.
  • bEsci: un pulsante per uscire dall'enigma;

Questa GUI contiene il minimo indispensabile per permettere all'utente di provare a risolvere l'enigma e uscire da esso nel caso avesse ancora bisogno di cercare ulteriori elementi per risolverlo.

Impostiamo la proprietà Visibility come Normal, initially off dato che all'inizio del gioco questa GUI non deve essere visibile.


Ora iniziamo a dare vita all'enigma scrivendo il codice per l'Hotspot del tastierino e per gli elementi della GUI.

Dato che questa GUI comparirà quando l'utente interagisce sul tastierino di fianco alla porta, entriamo nell'evento Interact hotspot di hTastiera e inseriamo il codice per rendere visibile gTastiera.

function hTastiera_Interact()
{

  gTastiera.Visible = true;
}

Ok, il tastierino compare, ma ovviamente se proviamo a premere un qualsiasi pulsante nulla accade. Ce ne occuperemo dopo.

Ora è venuto il momento di capire come, dal lato della programmazione, determinare la risoluzione dell'enigma.
La soluzione più semplice (che come accade spesso in programmazione non è comunque l'unica) è quella di confrontare il codice inserito dall'utente con un codice scelto da noi.

Se i due codici combaciano, l'enigma è risolto, la GUI scompare da sola e la porta si sblocca.
Altrimenti non succede nulla, la GUI rimarrà visibile dandoci la possibilità di provare altri codici o di uscire per cercare ulteriori indizi su come risolvere l'enigma.

Per operare questo confronto ci serviremo di due variabili: codiceUtente che conterrà il codice inserito dall'utente, e codiceEnigma conterrà il codice da noi scelto e che l'utente dovrà digitare per andare avanti nel gioco.
Entrambe le variabili saranno di tipo String e saranno globali poichè necessiteranno di essere lette e scritte anche fuori dalla Room.

Potreste chiedervi come mai due variabili che contengono numeri vengano dichiarate String invece che int. Il perchè è presto detto: sebbene entrambe le variabili contengono numeri, con questi numeri non abbiamo bisogno di compiere alcuna operazione aritmetica, avremo invece bisogno di trattarle come "parole".

Potrete infatti utilizzare il metedo che sto per spiegarvi anche per enigmi di codici alfabetici e alfanumerici in quanto in tutti i casi il codice sarà comunque una stringa, un parola.
Inoltre, dichiarare queste variabili come stringhe ci permettarà di utilizzare alcune funzioni che si adattano perfettamente al nostro scopo.

Andiamo quindi in Global variables e creiamo le due variabili. Per creare una variabile globale basterà cliccare sulla tabella (vuota, se il gioco è nuovo) delle variabli globali e selezionare Add new variable....

La prima variabile avrà come nome codiceUtente, sarà di tipo String e non avrà alcun valore predefinito, sarà vuota poichè popolata mano a mano che il giocatore digita il codice.



La seconda variabile avrà come nome codiceEnigma, anch'essa di tipo String e avrà come valore predefino un codice numerico di quattro cifre, nel mio caso 7514.




Volendo, potreste anche avere un codice più corto o più lungo di quattro cifre. Tuttavia per ora sarebbe meglio che vi atteniate al mio esempio. Una volta capito il meccanismo, poi, potrete modificare i miei script per adattarli al vostro enigma.



Bene, ora è venuto il momento di rendere funzionali i tasti numerici di gTastiera.
Ogni tasto permetterà l'inserimento di una cifra che andrà a comporre il codice di quattro cifre.

Quando un tasto numerico verrà premuto, la cifra corrispondente verrà visulaizzata in lTastiera, che fungerà da display del nostro tastierino numerico.

Facciamo quindi doppio click sul tasto numero del numero 1 (bNum1) per entrare nel suo evento OnClick.

function bNum1_OnClick(GUIControl *control, MouseButton button)
{

}

Riepilogando, abbiamo la variabile codiceUtente che conterrà il codice inserito dal giocatore, variabile che verrà popolata man mano che l'utente digita il codice.
Ad ogni pressione di un tasto numerico, dunque, viene aggiunta una cifra a codiceUtente.

Le stringhe in AGS dispongono di una funzione che fa proprio al caso nostro, trattasi della funzione Append.

Per aggiungere quindi la cifra corrispondente al numero del tasto scriviamo:

function bNum1_OnClick(GUIControl *control, MouseButton button)
{

  codiceUtente = codiceUtente.Append("1");
}

Ovvero, codiceUtente viene impostata come codiceUtente con l'aggiunta del numero 1.
Se bNum1 sarà premuto per immettere la prima cifra del codice, codiceUtente (che in quel caso sarà vuota), diventerà 1.
Se bNum1 sarà premuto per immettere la terza cifra del codice (avendo precedentemente premuto bNum0 e bNum6), codiceUtente diventerà 061.

Quindi Append aggiunge una cifra in coda a quelle precedenti.

Ok, ora la variabile codiceUtente comincia ad essere popolata una cifra per volta, ma come visualizzare questo codice in tempo reale man mano che viene digitato?

Basterà impostare la proprietà Text di lTastiera come uguale a codiceUtente.

function bNum1_OnClick(GUIControl *control, MouseButton button)
{

  codiceUtente = codiceUtente.Append("1");
  lTastiera.Text = codiceUtente;
}

Facciamo lo stesso per tutti gli altri tasti numerici cambiando soltanto la stringa tra le parentesi della funzione Append in modo che rispecchi il numero sul tasto premuto.
So che è un pò tedioso ripetere le stesse righe di codice per altre nove volte, ma per ora non ho trovato soluzione migliore.

Bene, i tasti numerici ora funzionano e  possiamo vedere le cifre comparire sul display del nostro tastierino.


Veniamo al tasto bBackSp. Per cancellare una cifra per volta partendo da destra ci avvarremo di una funzione simile ad Append chiamata Truncate.
Truncate chiede come argomento un numero intero che rappresenta la lunghezza della stringa una volta operata la troncatura.
Ad esempio il codice:

String colore = "Verde Smeraldo";
colore.Truncate(3);
Display("%s", colore);

ci farà vedere a video la stringa "Ver", ovvero le prime 3 lettere della stringa "Verde Smeraldo".
La stringa colore è stata quindi troncata eliminando i caratteri dal quarto in giù.

Entriamo quindi nell'evento OnClick di bBackSp.

function bBackSp_OnClick(GUIControl *control, MouseButton button)
{
 
}

E inseriamo:

function bBackSp_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Truncate(codiceUtente.Length - 1);
  lTastiera.Text = codiceUtente;

}

Quando il giocatore preme bBackSp codiceUtente viene troncato lasciando un numero di caratteri uguale alla lunghezza di codiceUtente meno 1:

codiceUtente.Length - 1

Se codiceUtente in quel momento è lungo 4 (ad esempio, 0567), premendo bBackSp esso viene troncato in modo da lasciare solo le prime 3 cifre (4 - 1 = 3, ovvero 056) e così via se bBackSp viene premuto più volte.
Dopodichè mostriamo sul display del nostro tastierino il codice troncato aggiornando la proprietà Text di lTastiera.

Ok, tutto bello ma... ci sono dei bug!
Il codice di sicurezza è composto da 4 cifre, ma nulla vieta al giocatore di immetterne di più, anche 1000!



Inoltre, il giocatore può premere quante volte vuole il tasto Backspace anche quando si sono già cancellate tutte le cifre del codice, cosa che porta a un errore in AGS, in quanto la funzione Truncate non può troncare una stringa che è già di per sè lunga zero cifre.


Dobbiamo quindi disabilitare i tasti numerici quando la lunghezza del codice digitato (codiceUtente) arriva a 4 cifre e abilitare il tasto Backspace solo se codiceUtente è di almeno una cifra.

Dato che questo controllo deve essere operato in tempo reale - ovvero AGS deve costantemente tenere d'occhio la lunghezza di codiceUtente per capire se abilitare o disabilitare i tasti - questo controllo deve avvenire nell'evento Repeatedly execute della stanza in cui si trova l'enigma.

Andiamo quindi in Repeatedly execute della stanza.

function room_RepExec()
{


}

Cominciamo con il tasto bBackSp. Come detto poco fa, questo tasto deve essere abilitato solo se il codice digitato è di almeno una cifra. Il che tradotto in codice è:

function room_RepExec()

  if(codiceUtente.Length > 0)
  {
    bBackSp.Enabled = true;
  }
  else
  {
    bBackSp.Enabled = false;
  }
}

Come ricorderete, codiceUtente.Length altro non è che la lunghezza in caratteri del codice immesso dal giocatore.
Adesso quando il codice digitato è di 0 cifre il tasto Backspace verrà disabilitato, cosa che riconosceremo dal fatto che il tasto sarà di un grigio più chiaro.

Backspace abilitato

Backspace disabilitato

Ora veniamo ai tasti numerici. Anche qui, ricordando quando detto prima, se la lunghezza del codice arriva a 4 cifre, questi tasti verranno disabilitati. In altre parole i tasti devono essere abilitati solo se la lunghezza di codiceUtente è inferiore a 4.

Il che in codice diventa:

function room_RepExec()

  ...

  if(codiceUtente.Length < 4)
  {
    //Abilito i tasti
  }
  else
  {
    //Disabilito i tasti
  }

}

Ho omesso di proposito il codice per abilitare e disabilitare i tasti perchè devo fare una premessa.
I tasti, come avete visto con bBackSp si abilitano e disabilitano mediante la proprietà Enabled.
bBackSp è un tasto solo, quindi sia per abilitarlo che per disabilitarlo ce la siamo cavati con una riga di codice.

La faccenda è diversa se dobbiamo abilitare o disabilitare dieci tasti numerici. Dovremmo scrivere dieci righe sia per abilitarli tutti che viceversa.

function room_RepExec()

  ...

  if(codiceUtente.Length < 4)
  {
    bNum0.Enabled = true;
    bNum1.Enabled = true;
    bNum2.Enabled = true;
    bNum3.Enabled = true;
    bNum4.Enabled = true;
    bNum5.Enabled = true;
    bNum6.Enabled = true;
    bNum7.Enabled = true;
    bNum8.Enabled = true;
    bNum9.Enabled = true;
  }
  else
  {
    bNum0.Enabled = false;
    bNum1.Enabled = false;
    bNum2.Enabled = false;
    bNum3.Enabled = false;
    bNum4.Enabled = false;
    bNum5.Enabled = false;
    bNum6.Enabled = false;
    bNum7.Enabled = false;
    bNum8.Enabled = false;
    bNum9.Enabled = false;
  }


È leggitimo procedere in questo modo e non c'è nulla di sbagliato, ma c'è un modo per accorciare notevolmente il codice.

Vi ricordate gli array e il ciclo while? Ecco una situazione in cui possiamo utilizzarli.

Tutti i controlli inseriti in una determinata GUI possono essere richiamati sia nel modo classico, ovvero scrivendo il loro nome (bNum5, bEsci, lTastiera e così via), sia richiamando l'array Controls abbinato a quella GUI.

Nel nostro caso, i controlli della GUI gTastiera possono essere raggiunti attraverso l'array Controls di gTastiera, richiamabile scrivendo gTastiera.Controls.

In questo array ogni cella è occupata da un controllo della GUI. L'indirizzo a cui e situato ogni controllo è dato dalla proprietà ID del controllo stesso.

Ad esempio, bNum7 ha un ID pari a 6. Quindi nella cella numero 6 dell'array Controls di gTastiera troviamo bNum7.
In codice potremmo dire che in gTastiera.Controls[6] troviamo bNum7.


Gli ID vengono dati in base all'ordine in cui i controlli vengono da noi inseriti nella GUI e partono da 0, per cui se avrò inserito per primo bNum1 e poi bNum2, essi avranno rispettivamente come ID 0 e 1.

Nel mio caso i tasti numerici sono stati i primi elementi ad essere inseriti nella GUI dunque nell'array Controls occupano le celle da 0 a 9.

Il ciclo while per abilitarli e disabilitarli a questo punto dovrebbe apparirvi sensato:

function room_RepExec()

  ...

  if(codiceUtente.Length < 4)
  {
    int i = 0;

    while(i <= 9)
    {
      gTastiera.Controls[i].Enabled = true;
      i++;

    }
  }
  else
  {   

    int i = 0;
    while(i <= 9)
    {
      gTastiera.Controls[i].Enabled = false;
      i++;

    }
  }
}

La variabile i inizializzata a 0 e incrementata a ogni giro del ciclo permette di riferirci giro dopo giro ad una cella specifica dell'array.

Adesso i tasti del tastierino numerico si bloccheranno quando il codice digitato arriva a una lunghezza di 4 cifre.

Tasti numerici abilitati

Raggiunte 4 cifre: tasti numerici disabilitati
Bug risolti!

Occupiamoci del tasto Esci che ci farà uscire dall'enigma, rimuovendo la GUI dallo schermo.
Entriamo nell'evento OnClick di bEsci e inseriamo gTastiera.Visible = false.

function bEsci_OnClick(GUIControl *control, MouseButton button)
{
  gTastiera.Visible = false;
}

La GUI verrà così rimossa dallo schermo. C'è però un piccolo bug.
Mettiamo che, tentando di risolvere l'enigma immetta un paio di cifre. Poi, non riuscendo a risolverlo, esca dalla GUI senza cancellare alcuna cifra.
Poco dopo voglio provare nuovamente a risolverlo e interagisco di nuovo con il tastierino di fianco alla porta richiamando così la GUI.
Noterete che le cifre immesse dall'ultimo tentativo sono ancora lì, sulla Label della GUI.
Questo perchè precedentemente avevamo impostato lTasitera in modo che mostrasse il valore di codiceUtente.

Al nuovo richiamo di gTastiera, la Label lTastiera continuerà giustamente a mostrare il valore di codiceUtente che è quello da noi assegnatoli nel tentativo precedente di risolvere l'enigma.

Quindi, una volta premuto bEsci dobbiamo, oltre a rimuovere la GUI, svuotare la variabile codiceUtente e aggiornare la proprietà Text di lTastiera in modo che rispecchi il valore aggiornato di codiceUtente, ovvero vuoto.

function bEsci_OnClick(GUIControl *control, MouseButton button)
{
  gTastiera.Visible = false;
  codiceUtente = "";
  lTastiera.Text = codiceUtente;

}

Ad ogni nuovo tentativo di risolvere l'enigma, lTastiera sarà pulita.

Ora, occupiamoci di confrontare il codice immesso dal giocatore con quello da noi scelto per determinare la risoluzione dell'enigma.
A tal proposito possiamo sfruttare l'if che abilita e disabilita i tasti numerici scritto in precedenza.

Se vi ricordate, i tasti numerici vengono disabilitati quando codiceUtente raggiunge i 4 caratteri di lunghezza e questo è anche il momento migliore per confrontare il codice immesso dal giocatore con quello che abbiamo scelto noi.

Annidiamo in questo braccio dell'if il seguente if:

function room_RepExec()

  ...

  if(codiceUtente.Length < 4)
  {
    ...
  }
  else
  {   

    int i = 0;
    while(i <= 9)
    {
      gTastiera.Controls[i].Enabled = false;
      i++;

    }
    
     if(codiceUtente == codiceEnigma)
     {
       Display("Porta sbloccata");         
       codiceUtente = "";
       gTastiera.Visible = false;
     }

  }
}

Con questo if chiediamo se il codice immesso dall'utente è lo stesso scelto da noi programmatori per l'enigma.
Se la risposta è si, ovvero se la condizione risulta true mostreremo la scritta "Porta sbloccata", svuoteremo la variablie codiceUtente e faremo scomparire la GUI del tastierino.


Svuotare la variabile codiceUtente, anche se a prima vista non si direbbe, è molto importante. Perchè? Perchè se non lo facessimo essa continuerebbe sia ad avere una lunghezza uguale a 4 - facendoci così entrare nell'else del if - sia ad essere uguale a codiceEnigma, facendoci entrare addirittura nell'if annidato ed eseguendo le righe al suo interno.
Cosa che causerebbe il continuo riproponimento della scritta "Porta sbloccata" nel mio caso.

C'è un ultimo aspetto da prendere in considerazione.

Anche dopo la risoluzione dell'enigma, qualora il giocatore cliccasse sull'Hotspot del tastierino, la GUI gTatstiera comparirebbe nuovamente, cosa che non ci serve più ora che l'enigma è stato risolto.

Per risolvere questo problema basterà creare una variabile booleana che nel mio casao sarà enigmaRisolto e che avrà il valore iniziale di false dato che l'enigma all'inizio del gioco non è risolto.
Quando l'utente clicca sull'Hotspot del tastierino verrà eseguito un if che controllerà il valore di enigmaRisolto.
Se essa è true, ovvero l'enigma è già stato risolto, faremo dire a Ego la frase: <<Ho già sbloccato la porta!>>. Se invece è false mostreremo la GUI dando la possibilità all'utente di rsolvere l'enigma.

Non è necessario dichiararla globale, in quanto essa verrà solamente utilizzata nella Room dove si trova anche l'enigma.

Dichiariamo quindi questa variabile alla prima riga della pagina degli script della Room in modo da renderla accessibile a tutti gli eventi della pagina.

bool enigmaRisolto = false;

Ora facciamola entrare in azione. Il suo valore cambierà in true nel momento in cui l'enigma sarà risolto.
Andiamo allora nell'if che confronta codiceUtente con codiceEnigma e iseriamo il cambio di valore di enigmaRisolto.

function room_RepExec()

  ...

  if(codiceUtente.Length < 4)
  {
    ...
  }
  else
  {   

    int i = 0;
    while(i <= 9)
    {
      gTastiera.Controls[i].Enabled = false;
      i++;

    }
    
     if(codiceUtente == codiceEnigma)
     {
       Display("Porta sbloccata");

       enigmaRisolto = true;         
       codiceUtente = "";
       gTastiera.Visible = false;
     }

  }
}

Inseriamo infine un if che controlla il valore di questa variabile all'interno dell'evento Interact di hTastiera per dare o meno l'accesso all'enigma come spiegato in precedenza.

function hTastiera_Interact()
{

  if(enigmaRsolto == false)
  {   
    gTastiera.Visible = true;
  }
  else
  {
    cEgo.Say("Ho già risolto l'enigma!");
  }
}

Possiamo anche sfruttare engimaRisolto con l'Hotspot sulla porta blindata (hPorta) per permettere o meno il cambio di stanza.
Con un if possiamo controllare il valore di questa variabile. Se è false Ego dirà: <<La porta sembra bloccata elettronicamente.>>, viceversa andremo avanti col gioco (ad esempio un cambio di stanza o l'inizio di una cutscene).

function hPorta_Interact()
{
  if(enigmaRisolto == false)
  {
    cEgo.Say("La porta sembra bloccata elettronicamente.");
  }
  else
  {
    cEgo.ChangeRoom(2);
  }
}

Bene ragazzi, il succo del tutorial è questo, spero vi sia piaciuto e che vi sia stato utile.
Da qui in poi potrete modificare, espandere e rendere anche più complesso l'enigma.

Come già detto più volte, potete anche utilizzare questo metodo per un codice alfabetico o alfanumerico.
Basterà scegliere un valore diverso per codiceEnigma, creare una GUI con tasti sia numerici che alfabetici e adattare l'if e i cicli while che controllano l'abilitazione/disabilitazione dei tasti, nonchè quello che confronta codiceUtente con codiceEnigma.

Ecco gli script completi.

Script della stanza:

bool enigmaRisolto = false;

function hTastiera_Interact()
{
  if(enigmaRisolto == false)
  {
    gTastiera.Visible = true;
  }
  else
  {
    cEgo.Say("Ho gia' risolto l'enigma!");
  }
}

function hPorta_Interact()
{
  if(enigmaRisolto == false)
  {
    cEgo.Say("La porta sembra bloccata elettronicamente.");
  }
  else
  {
   cEgo.ChangeRoom(2);
  }
}

function room_RepExec()
{
  if(codiceUtente.Length > 0)
  {
    bBackSp.Enabled = true;
  }
  else
  {
    bBackSp.Enabled = false;
  }

  if(codiceUtente.Length < 4)
  {
    int i = 0;
    while(i <= 9)
    { 
      gTastiera.Controls[i].Enabled = true;
      i++;
    }
  }
  else
  {
    int i = 0;
    while(i <= 9)
    {
      gTastiera.Controls[i].Enabled = false;
      i++;
    }
   
    if(codiceUtente == codiceEnigma)
    {
      Display("Porta sbloccata");
      enigmaRisolto = true;
      codiceUtente = "";
      gTastiera.Visible = false;
    }
  } 
}

Script della GUI:

function bNum1_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("1");
  lTastiera.Text = codiceUtente;
}

function bNum2_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("2");
  lTastiera.Text = codiceUtente;
}

function bNum3_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("3");
  lTastiera.Text = codiceUtente;
}

function bNum4_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("4");
  lTastiera.Text = codiceUtente;
}

function bNum5_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("5");
  lTastiera.Text = codiceUtente;
}

function bNum6_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("6");
  lTastiera.Text = codiceUtente;
}

function bNum7_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("7");
  lTastiera.Text = codiceUtente;
}

function bNum8_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("8");
  lTastiera.Text = codiceUtente;
}

function bNum9_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("9");
  lTastiera.Text = codiceUtente;
}

function bNum0_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Append("0");
  lTastiera.Text = codiceUtente;
}

function bBackSp_OnClick(GUIControl *control, MouseButton button)
{
  codiceUtente = codiceUtente.Truncate(codiceUtente.Length - 1);
  lTastiera.Text = codiceUtente;
}

function bEsci_OnClick(GUIControl *control, MouseButton button)
{
  gTastiera.Visible = false;
  codiceUtente = "";
  lTastiera.Text = codiceUtente;
}

Se avete domande scrivetemi sotto questo articolo, sotto il video da cui questo articolo è linkato o al mio indirizzo email: triventrive@gmail.com.
Vi ringrazio per essere arrivati fin qui e non mi dilungo oltre.

A presto!