Unity 3D – Key Sequence Input – Advanced – JavaScript

NOTA BENE: in tutti gli script seguenti la sequenza VERRA’ RESETTATA in caso di errore!

Attach this script to a Gameobject in the scene

Sequence of 4 Keys – Advanced

KeySequenceInput.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// La sequenza di tasti corretta, per allungarla aggiungere altri elementi all'array
private var konamiCode = ["UpArrow", "RightArrow", "DownArrow", "LeftArrow"]; // combinazione da eseguire
private var currentPos : int = 0; // il valore iniziale dell'indice dell'array
private var inKonami : boolean = false; // è false perchè può diventare true solo con la sequenza corretta di tasti
  
// Controlla quali tasti sono correntemente premuti INIZIO ########################################
// Questa funzione controlla TUTTO l'input utente, infatti non vi sono altri GetKey nel codice!
function OnGUI () {
    var e : Event = Event.current;
    // if è un evento da tastiera AND
    // c'è un input da tastiera o mouse AND
    // inKonami è falso AND
    // è diverso da None
    // invia a konamiFunction() il valore del tasto rilevato
    if (e.isKey && Input.anyKeyDown && !inKonami && e.keyCode.ToString()!="None") {
        konamiFunction (e.keyCode);
    }
}
// Controlla quali tasti sono correntemente premuti FINE ###########################################
  
function Update () {
    if (inKonami) { // se la variabile inKonami è true,
        //Sequenza corretta, fai qualcosa...
        Debug.Log("Right Sequence!");
    }
}// END Update()
  
// Controlla la sequenza INIZIO #####################################################################
function konamiFunction (incomingKey) {// riceve il valore del tasto rilevato
  
    // converte il valore in stringa e lo inserisce in una variabile
    // la conversione è necessaria per confrontarla con le stringhe contenute nell'array
    var incomingKeyString = incomingKey.ToString();
     
    // se il tasto corrisponde alla sequenza INIZIO
    if(incomingKeyString==konamiCode[currentPos]) {
        print("Unlocked part "+(currentPos+1)+"/"+konamiCode.length+" with "+incomingKeyString);
        currentPos++; // incrementa l'indice dell'array per verificare il tasto successivo
  
        if((currentPos+1)>konamiCode.length){
            // se l'indice dell'array+1 è > della lunghezza dell'array
            // ricordarsi che il valore iniziale dell'indice è 0
            // tutta la sequenza è corretta perchè sono arrivato a verificare anche l'ultimo keyCode della sequenza
            //  assegna true alla variabile inKonami
            print("You master Konami.");
            inKonami=true;
            currentPos=0; // resetta l'indice dell'array, resetta la sequenza
        }
    // altrimenti se il tasto non corrisponde alla sequenza   
    } else {     
        print("You fail Konami at position "+(currentPos+1)+", find the ninja in you.");
        currentPos=0; // resetta l'indice dell'array, resetta la sequenza
    }
  
}// END konamiFunction()
// Controlla la sequenza FINE ######################################################################

Play and input UpArrow – RightArrow – DownArrow – LeftArrow

Sequence of 4 Keys – Advanced – CountDown

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
// La sequenza di tasti corretta, per allungarla aggiungere altri elementi all'array
private var konamiCode = ["UpArrow", "RightArrow", "DownArrow", "LeftArrow"]; // combinazione da eseguire
private var currentPos : int = 0; // il valore iniziale dell'indice dell'array
private var inKonami : boolean = false; // è false perchè può diventare true solo con la sequenza corretta di tasti
  
private var endTime : float; // countdown variable
private var endGame : boolean = false; // verifica la fine del gioco
 
function Start()
{
    endTime = Time.time + 3; // countdown variable: 3 seconds to type the right sequence!
}
  
// Controlla quali tasti sono correntemente premuti INIZIO ########################################
// Questa funzione controlla TUTTO l'input utente, infatti non vi sono altri GetKey nel codice!
function OnGUI () {
    var e : Event = Event.current;
    // if è un evento da tastiera AND
    // c'è un input da tastiera o mouse AND
    // inKonami è falso AND
    // è diverso da None AND
    // endGame è false -> continua a inviare i codici dei tasti solo finchè la partita è in corso
    // invia a konamiFunction() il valore del tasto rilevato
    if (e.isKey && Input.anyKeyDown && !inKonami && e.keyCode.ToString()!="None" && !endGame) {
        konamiFunction (e.keyCode);
    }
}
// Controlla quali tasti sono correntemente premuti FINE ###########################################
 
// COUNTDOWN START #########################
function CountDown () {
     
    var timeLeft : int = endTime - Time.time;
    // We do not need negative time
    if (timeLeft < 0){
        timeLeft = 0;
        Debug.Log("End of Time"); // tempo scaduto
        currentPos=0; // resetta l'indice dell'array, resetta la sequenza
        endGame = true; // finisce il gioco
        // Retry or Abort...
        }
     
}// END CountDown()
// COUNTDOWN END ###########################
  
function Update () {
 
    CountDown (); // ho solo x secondi per digitare la sequenza
 
    if (inKonami) { // se la variabile inKonami è true,
        // Sequenza corretta, fai qualcosa...
        Debug.Log("Right Sequence!");
    }
}// END Update()
  
// Controlla la sequenza INIZIO #####################################################################
function konamiFunction (incomingKey) {// riceve il valore del tasto rilevato
  
    // converte il valore in stringa e lo inserisce in una variabile
    // la conversione è necessaria per confrontarla con le stringhe contenute nell'array
    var incomingKeyString = incomingKey.ToString();
     
    // se il tasto corrisponde alla sequenza INIZIO
    if(incomingKeyString==konamiCode[currentPos]) {
        print("Unlocked part "+(currentPos+1)+"/"+konamiCode.length+" with "+incomingKeyString);
        currentPos++; // incrementa l'indice dell'array per verificare il tasto successivo
  
        if((currentPos+1)>konamiCode.length){
            // se l'indice dell'array+1 è > della lunghezza dell'array
            // ricordarsi che il valore iniziale dell'indice è 0
            // tutta la sequenza è corretta perchè sono arrivato a verificare anche l'ultimo keyCode della sequenza
            //  assegna true alla variabile inKonami
            print("You master Konami.");
            inKonami=true;
            currentPos=0; // resetta l'indice dell'array, resetta la sequenza
        }
    // altrimenti se il tasto non corrisponde alla sequenza   
    } else {     
        print("You fail Konami at position "+(currentPos+1)+", find the ninja in you.");
        currentPos=0; // resetta l'indice dell'array, resetta la sequenza
    }
  
}// END konamiFunction()
// Controlla la sequenza FINE ######################################################################

Play and input UpArrow – RightArrow – DownArrow – LeftArrow within 3 seconds

Come funziona?
1. function OnGUI () … Event.current -> rileva gli input dell’utente e li invia a

2. function konamiFunction (incomingKey) -> riceve gli input per verificare la correttezza della sequenza
a. scorre l’array konamiCode[] per confrontarlo con la sequenza inviata da function OnGUI ()
b. se errata resetta la sequenza e bisogna ricominciarla da capo
c. se è corretta assegna ‘true’ alla variabile booleana inKonami

3. function Update()
a. controlla se ‘inKonami’ è vera -> la sequenza è corretta
b. richiama CountDown()

4. CountDown() fa scorrere il tempo da 3 a 0 secondi
a. finchè c’è tempo non fa nulla
b. se scade il tempo resetta la sequenza e assegna ‘true’ alla variabile booleana endGame

5. OnGUI () … Event.current … quando la variabile endGame è ‘true’ termina l’invio dei dati, infatti li spedisce solo finchè è falsa … !endgame
Quindi:
– !endgame -> false
– endgame -> true

Sequence of 4 Keys – Advanced – CountDown – Infinite Sequencer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// La sequenza di tasti corretta, per allungarla aggiungere altri elementi all'array
// e correggere la generazione casuale della sequenza -> var randomCode = ...
private var konamiCode = ["UpArrow", "RightArrow", "DownArrow", "LeftArrow"]; // combinazione da eseguire
private var currentPos : int = 0; // il valore iniziale dell'indice dell'array
private var inKonami : boolean = false; // è false perchè può diventare true solo con la sequenza corretta di tasti
  
private var endTime : float; // countdown variable
private var endGame : boolean = false; // verifica la fine del gioco
 
private var sequenceNum : int = 0; // numero di sequenza completata con successo
 
function Start()
{
    endTime = Time.time + 30; // countdown variable: 30 seconds to type the right sequence!
    Debug.Log("First Sequence is " + konamiCode[0] + " " + konamiCode[1] + " " + konamiCode[2] + " " + konamiCode[3]);
}
  
// Controlla quali tasti sono correntemente premuti INIZIO ########################################
// Questa funzione controlla TUTTO l'input utente, infatti non vi sono altri GetKey nel codice!
function OnGUI () {
    var e : Event = Event.current;
    // if è un evento da tastiera AND
    // c'è un input da tastiera o mouse AND
    // inKonami è falso AND
    // è diverso da None AND
    // endGame è false -> continua a inviare i codici dei tasti solo finchè la partita è in corso
    // invia a konamiFunction() il valore del tasto rilevato
    if (e.isKey && Input.anyKeyDown && !inKonami && e.keyCode.ToString()!="None" && !endGame) {
        konamiFunction (e.keyCode);
    }
}
// Controlla quali tasti sono correntemente premuti FINE ###########################################
 
// COUNTDOWN START #########################
function CountDown () {
     
    var timeLeft : int = endTime - Time.time;
    // We do not need negative time
    if (timeLeft < 0){
        timeLeft = 0;
        Debug.Log("End of Time"); // tempo scaduto
        currentPos=0; // resetta l'indice dell'array, resetta la sequenza
        endGame = true; // finisce il gioco
        // Retry or Abort...
        }
     
}// END CountDown()
// COUNTDOWN END ###########################
  
function Update () {
 
    CountDown (); // ho solo x secondi per digitare la sequenza
 
    if (inKonami) { // se la variabile inKonami è true,
        // Sequenza corretta, fai qualcosa...
        Debug.Log("Right Sequence!");
        inKonami=false; // reset variable
         
        // QUI aggiungere SFX, Time, Coins e così via... +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         
        // crea una nuova sequenza casuale INIZIO ----------------------------------------------------------------
        var randomCode = ["UpArrow", "RightArrow", "DownArrow", "LeftArrow"]; // tasti ammessi nella combinazione, il primo ha indice 0 l'ultimo 3
        var irndFirst   : int = Random.Range(0, 3); // first index random
        var irndSecond  : int = Random.Range(0, 3); // second index random
        var irndThird   : int = Random.Range(0, 3); // third index random
        var irndFourth  : int = Random.Range(0, 3); // fourth index random
        // Multidimensional Array! Yeah!
        konamiCode = [randomCode[irndFirst], randomCode[irndSecond], randomCode[irndThird], randomCode[irndFourth]];
        // crea una nuova sequenza casuale FINE -------------------------------------------------------------------
        // visualizza la nuova sequenza
        sequenceNum++; // incrementa il numero di sequenze completate con successo     
        Debug.Log("Sequence number " + sequenceNum + " is " + konamiCode[0] + " " + konamiCode[1] + " " + konamiCode[2] + " " + konamiCode[3]);
         
        // QUI variare il materiale degli oggetti utilizzati come rappresentazione grafica dei bottoni ++++++++++++
         
    }// END inKonami
     
}// END Update()
  
// Controlla la sequenza INIZIO #####################################################################
function konamiFunction (incomingKey) {// riceve il valore del tasto rilevato
  
    // converte il valore in stringa e lo inserisce in una variabile
    // la conversione è necessaria per confrontarla con le stringhe contenute nell'array
    var incomingKeyString = incomingKey.ToString();
     
    // se il tasto corrisponde alla sequenza INIZIO
    if(incomingKeyString==konamiCode[currentPos]) {
        print("Unlocked part "+(currentPos+1)+"/"+konamiCode.length+" with "+incomingKeyString);
        // QUI aggiungere SFX positivo +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        currentPos++; // incrementa l'indice dell'array per verificare il tasto successivo
  
        if((currentPos+1)>konamiCode.length){
            // se l'indice dell'array+1 è > della lunghezza dell'array
            // ricordarsi che il valore iniziale dell'indice è 0
            // tutta la sequenza è corretta perchè sono arrivato a verificare anche l'ultimo keyCode della sequenza
            //  assegna true alla variabile inKonami
            print("You master Konami.");
            inKonami=true;
            currentPos=0; // resetta l'indice dell'array, resetta la sequenza
        }
    // altrimenti se il tasto non corrisponde alla sequenza   
    } else {     
        print("You fail Konami at position "+(currentPos+1)+", find the ninja in you.");
        // QUI aggiungere SFX negativo +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        currentPos=0; // resetta l'indice dell'array, resetta la sequenza
    }
  
}// END konamiFunction()
// Controlla la sequenza FINE ######################################################################

Come funziona?
1. function OnGUI () … Event.current -> rileva gli input dell’utente e li invia a konamiFunction()

2. function konamiFunction (incomingKey) -> riceve gli input per verificare la correttezza della sequenza
a. scorre l’array konamiCode[] per confrontarlo con la sequenza inviata da function OnGUI ()
b. se errata resetta la sequenza e bisogna ricominciarla da capo
c. se è corretta assegna ‘true’ alla variabile booleana inKonami

3. function Update()
a. controlla se ‘inKonami’ è vera -> la sequenza è corretta
– resetta a ‘false’ inKonami altrimenti OnGUI() non può funzionare per controllare una nuova sequenza
– con un array multidimensionale crea una nuova sequenza random
– conteggia il numero di sequenze riuscite con successo
b. richiama CountDown()

4. CountDown() fa scorrere il tempo da 30 a 0 secondi
a. finchè c’è tempo non fa nulla
b. se scade il tempo resetta la sequenza e assegna ‘true’ alla variabile booleana endGame

5. OnGUI () … Event.current … quando la variabile endGame è ‘true’ termina l’invio dei dati, infatti li spedisce solo finchè è falsa … !endgame
Quindi:
– !endgame -> false
– endgame -> true