videogames development

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

// 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

// 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

// 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

Unity3D – Mouse – Drag Rigid Body

Drag Every Rigid Body in the scene using Mouse.

Create a scene with:

1. Main Camera

2. Cube, name it and use it as ground
– Box Collider

3. Sphere
– Box Collider
– Rigid Body
4. Capsule
– Box Collider
– Rigid Body

5. Empty Object
– DragRigidBody.js

// Attach this script to an Empty Object in the scene

var spring = 50.0;
var damper = 5.0;
var drag = 10.0;
var angularDrag = 5.0;
var distance = 0.2;
var attachToCenterOfMass = false;

private var springJoint : SpringJoint;

function Update ()
{
	// Make sure the user pressed the mouse down
	if (!Input.GetMouseButtonDown (0))
		return;

	var mainCamera = FindCamera();
		
	// We need to actually hit an object
	var hit : RaycastHit;
	if (!Physics.Raycast(mainCamera.ScreenPointToRay(Input.mousePosition),  hit, 100))
		return;
	// We need to hit a rigidbody that is not kinematic
	if (!hit.rigidbody || hit.rigidbody.isKinematic)
		return;
	
	if (!springJoint)
	{
		var go = new GameObject("Rigidbody dragger");
		var body : Rigidbody = go.AddComponent ("Rigidbody") as Rigidbody;
		springJoint = go.AddComponent ("SpringJoint");
		body.isKinematic = true;
	}
	
	springJoint.transform.position = hit.point;
	if (attachToCenterOfMass)
	{
		var anchor = transform.TransformDirection(hit.rigidbody.centerOfMass) + hit.rigidbody.transform.position;
		anchor = springJoint.transform.InverseTransformPoint(anchor);
		springJoint.anchor = anchor;
	}
	else
	{
		springJoint.anchor = Vector3.zero;
	}
	
	springJoint.spring = spring;
	springJoint.damper = damper;
	springJoint.maxDistance = distance;
	springJoint.connectedBody = hit.rigidbody;
	
	StartCoroutine ("DragObject", hit.distance);
}

function DragObject (distance : float)
{
	var oldDrag = springJoint.connectedBody.drag;
	var oldAngularDrag = springJoint.connectedBody.angularDrag;
	springJoint.connectedBody.drag = drag;
	springJoint.connectedBody.angularDrag = angularDrag;
	var mainCamera = FindCamera();
	while (Input.GetMouseButton (0))
	{
		var ray = mainCamera.ScreenPointToRay (Input.mousePosition);
		springJoint.transform.position = ray.GetPoint(distance);
		yield;
	}
	if (springJoint.connectedBody)
	{
		springJoint.connectedBody.drag = oldDrag;
		springJoint.connectedBody.angularDrag = oldAngularDrag;
		springJoint.connectedBody = null;
	}
}

function FindCamera ()
{
	if (camera)
		return camera;
	else
		return Camera.main;
}

Unity3D – GetButtonDown – Timer

Create a scene with:

– GUIText

– EmptyObject and attach the script Timer.js:

#pragma strict

// Attach this script to a Empty GameObject in the scene

var currentTimeText : GUIText; // Assign a GUI Text in Inspector
var startTime = 0; // start time of the timer
var timeTaken : float; // Result sample -> 17.89256

function Start(){
} // -------------------------------------------------------------------- END Start()
 
function Update () {
// Take the time when you press Fire1 Button
if (Input.GetButtonDown ("Fire1")) { //Fire1 -> CTRL Left or Left Mouse Button
    Timer();     
}
	
} // -------------------------------------------------------------------- END Update()

function Timer(){
var timeTaken = startTime + Time.time; // refresh every 1/60 sec = 0,01666 sec                                      
currentTimeText.text = timeTaken.ToString (); // Result sample -> 17.89256
} // -------------------------------------------------------------------- END Timer()

      

Assign the GUIText variable in Inspector