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!
