Video Games Development

Unity3D – Play a sound in sync with a countdown

Unity3D – Play a sound in sync with a countdown

Create a scene with:

– Main Camera

– Cube, attach the script:


#pragma strict

// AudioCountDown() variables START ################################################################
var pinPulled : boolean = false;
var fuse : float = 8.5; // the grenade explodes x seconds after the pin is pulled
var fuseTimer : float = 0;
var grenadeBeep : AudioClip;
var slowInterval : float = 1.0; // slow speed SFX
var fastInterval : float = 0.2; // fast speed SFX for last seconds
private var nextTime : float = -1; // declare this variable outside any function so every function can acces 
// AudioCountDown() variables END ##################################################################

function Start () {
} // END Start

function Update () {
		AudioCountDown();// call the audio for the CountDown	
}// END Update

function OnMouseDown ()
{
        // When you click over the object
        pinPulled = true; // the grenade pin will be pulled
        Debug.Log('Pin Pulled!');
}// END OnMouseDown()

function AudioCountDown(){
	// Audio CountDown START ##################################################################
	//If a grenade's pin has been pulled, start the countdown
	if (pinPulled) {
	   fuseTimer -= Time.deltaTime;
	}
	else { // pin in place: reset fuseTimer and nextTime
	   fuseTimer = fuse;
	   nextTime = fuseTimer - slowInterval; // set time for 1st tick
	}
	 
	if (fuseTimer <= nextTime) { // it's time to tick:
	   if (fuseTimer < 3.0){ // if entered fast range (last second), use fast interval
	       nextTime -= fastInterval;
	   } else { // otherwise beep at slow interval
	       nextTime -= slowInterval;
	   }
	   audio.clip = grenadeBeep;
	   audio.Play(); // call Play only once
	}
	// Audio CountDown END  ####################################################################
}// END AudioCountDown()

Inspector> DRAG AND DROP the Bomb-Detonator SFX over var grenadeBeep

Play, click over the cube to start the SFX CountDown

For italian people: come funziona?
1. la variabile pinPulled viene settata true, corrisponde al togliere la sicura alla granata

2. fuseTimer è il conto alla rovescia che si attiva se pinPulled è true infatti:


//If a grenade's pin has been pulled, start the countdown
	if (pinPulled) {
	   fuseTimer -= Time.deltaTime;
	}
	else { // pin in place: reset fuseTimer and nextTime
	   fuseTimer = fuse;
	   nextTime = fuseTimer - slowInterval; // set time for 1st tick

3. fuseTimer una volta attivato viene scalato di 1 secondo alla volta 

fuseTimer -= Time.deltaTime;

4. se è passato almeno un secondo…

if (fuseTimer <= nextTime)

5. avvia l’effetto sonoro

           audio.clip = grenadeBeep;
	   audio.Play(); // call Play only once

6. se il countdown è agli ultimi 3 secondi il suono sarà emesso più velocemente

if (fuseTimer <= nextTime) { // it's time to tick:
	   if (fuseTimer < 3.0){ // if entered fast range (last second), use fast interval
	       nextTime -= fastInterval;
By |Unity3D, Video Games Development|Commenti disabilitati su Unity3D – Play a sound in sync with a countdown
Read More

Unity3D – Walking Footsteps – SFX – JavaScript

Unity3D – Walking Footsteps – SFX – JavaScript

Create a scene with:

– Main Camera -> Audio Listener component
– Cube -> Audio Source component
-> WalkSfx.js


#pragma strict

// Audio var START -------------------------------
var footsteps : AudioClip[]; // Assign in Inspector
private var step : boolean = true; 
var audioStepLengthWalk = 0.58f;
// Audio var END --------------------------------- 

function Start () {
}// END Start

function Update () {
    Debug.Log(step);// show step status
    
    // move START --------------------------------
    var horiz : float = Input.GetAxis("Horizontal");
	transform.Translate(Vector3(horiz,0,0));
	// move END ----------------------------------

	// AudioPlay START ---------------------------
	if (Input.GetAxis("Horizontal") && step)
	{	
	    Walk();
	}
	// AudioPlay END -----------------------------
}// END Update()

// ###############################################
// Audio functions START #########################
function Walk(){
	audio.clip = footsteps[Random.Range(0, footsteps.Length)];
	audio.volume = 1.0f;
	audio.Play();
	WaitForFootStepsCoroutine(audioStepLengthWalk);// wait time -> audioStepLengthWalk
}// END Walk()

function WaitForFootStepsCoroutine (stepsLength : float){
	step = false; 
	yield WaitForSeconds(stepsLength); 
	step = true;
}// WaitForFootStepsCoroutine()
// Audio functions END ############################
// ################################################

Inspector> Assign 4 different Audio Clip to var footsteps

Play

For italian people: come funziona?

1. if (Input.GetAxis(“Horizontal”) && step) -> se premo i tasti dello spostamento e la variabile step è TRUE
2. viene avviata la funzione Walk();
3. Walk():
– seleziona dall’array una clip random, ce ne servono almeno 4 o il suono risulterà noioso
– setta il volume -> audio.volume = 1.0f;
– avvia l’audio -> audio.Play();
– avvia WaitForFootStepsCoroutine(), inviando audioStepLengthWalk
4. WaitForFootStepsCoroutine():
– audioStepLengthWalk = stepsLength
– step = FALSE per evitare che -> if (Input.GetAxis(“Horizontal”) provochi la riproduzione della clip sonora ad ogni frame
– yield WaitForSeconds(stepsLength); -> mantiene step = FALSE per i secondi di stepsLength -> poi step = TRUE
5. con step = TRUE -> riparte if (Input.GetAxis(“Horizontal”) && step) per avviare una nuova clip audio

By |Unity3D, Video Games Development|Commenti disabilitati su Unity3D – Walking Footsteps – SFX – JavaScript
Read More

Unity 3D – Key Sequence Input – Basics – JavaScript

Unity 3D – Key Sequence Input – Basics – JavaScript

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

Attach this script to a Gameobject in the scene

(KeyCode.) Sequence of 2 Keys – Basic

KeySequenceInput.js


// Key Sequence Input Controller
// Attach this script to a Gameobject in the scene

private var firstDown : boolean = false; // false at the beginning, I have no typed yet
private var allDown : boolean = false;   // false at the beginning, I have no typed yet
 
function Update() {

// Key sequence input controller START ######################
if(Input.GetKeyDown(KeyCode.UpArrow)) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 
if(firstDown) {
if(Input.GetKeyDown(KeyCode.RightArrow)) {
// highlight the button or play a sound
allDown = true;   //3. return true if you push first and second key
}                 
}

//4. if first and second key are true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Do Something...
firstDown = false; // reset variables
allDown = false;   
}
// Key sequence input controller END ########################

}

Play the game and type the keys: UpArrow – RightArrow

(KeyCode.) Sequence of 4 keys – Basic


// Key Sequence Input Controller
// Attach this script to a Gameobject in the scene

private var firstDown : boolean = false;  // false at the beginning, I have no typed yet
private var secondDown : boolean = false; // false at the beginning, I have no typed yet
private var thirdDown : boolean = false;  // false at the beginning, I have no typed yet
private var allDown : boolean = false;    // false at the beginning, I have no typed yet
 
function Update() {

// Key sequence input controller START ######################
if(Input.GetKeyDown(KeyCode.UpArrow)) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 

if(firstDown) {
if(Input.GetKeyDown(KeyCode.RightArrow)) {
// highlight the button or play a sound
secondDown = true;//3. return true if you push first and second key
}                 
}

if(secondDown) {
if(Input.GetKeyDown(KeyCode.DownArrow)) {
// highlight the button or play a sound
thirdDown = true; //4. return true if you push first and second key and third
}                 
}

if(thirdDown) {
if(Input.GetKeyDown(KeyCode.LeftArrow)) {
// highlight the button or play a sound
allDown = true;  //5. return true if you push first and second key and third and fourth
}                 
}

//4. if all sequence is true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Do Something...
firstDown = false; // reset variables
secondDown = false;
thirdDown = false;
allDown = false;   
}
// Key sequence input controller END ########################

}

Play the game and type the keys: UpArrow – RightArrow – DownArrow – LeftArrow

(KeyCode.) Sequence of 4 keys – Basic + CountDown


// Key Sequence Input Controller
// Attach this script to a Gameobject in the scene

private var firstDown : boolean = false;  // false at the beginning, I have no typed yet
private var secondDown : boolean = false; // false at the beginning, I have no typed yet
private var thirdDown : boolean = false;  // false at the beginning, I have no typed yet
private var allDown : boolean = false;    // false at the beginning, I have no typed yet

private var endTime : float; // countdown variable

function Start()
{
    endTime = Time.time + 3; // countdown variable: 3 seconds to type the right sequence!
}
 
function Update() {

    // COUNTDOWN START #########################
    var timeLeft : int = endTime - Time.time; 
    // We do not need negative time
    if (timeLeft < 0){ 
        timeLeft = 0;
    	        firstDown = false;   // reset variables, You Fail!
		secondDown = false;
		thirdDown = false;
		allDown = false;
		// Retry or Abort...
		}
    // COUNTDOWN END ###########################

// Key sequence input controller START ######################
if(Input.GetKeyDown(KeyCode.UpArrow)) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 

if(firstDown) {
if(Input.GetKeyDown(KeyCode.RightArrow)) {
// highlight the button or play a sound
secondDown = true;//3. return true if you push first and second key
}                 
}

if(secondDown) {
if(Input.GetKeyDown(KeyCode.DownArrow)) {
// highlight the button or play a sound
thirdDown = true; //4. return true if you push first and second key and third
}                 
}

if(thirdDown) {
if(Input.GetKeyDown(KeyCode.LeftArrow)) {
// highlight the button or play a sound
allDown = true;  //5. return true if you push first and second key and third and fourth
}                 
}

//4. if all sequence is true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Next Level...
firstDown = false; // reset variables
secondDown = false;
thirdDown = false;
allDown = false;   
}
// Key sequence input controller END ########################

}

(KeyCode.) Sequence of 4 keys – Basic + CountDown – Separate function()


// Key Sequence Input Controller
// Attach this script to a GameObject in the scene

private var firstDown : boolean = false;  // false at the beginning, I have no typed yet
private var secondDown : boolean = false; // false at the beginning, I have no typed yet
private var thirdDown : boolean = false;  // false at the beginning, I have no typed yet
private var allDown : boolean = false;    // false at the beginning, I have no typed yet

private var endTime : float;

function Start()
{
    endTime = Time.time + 3; // 3 seconds to type the right sequence!
}// End Start()
 
function Update() {
	KeySequenceControl(); // call the function to control the sequence

}// End Update()

// KeySequenceControl() START ##################################################################
function KeySequenceControl(){

    // COUNTDOWN START #########################
    var timeLeft : int = endTime - Time.time; 
    // We do not need negative time
    if (timeLeft < 0){ 
        timeLeft = 0;
    	        firstDown = false;   // reset variables, You Fail!
		secondDown = false;
		thirdDown = false;
		allDown = false;
		// Retry or Abort...
		}
    // COUNTDOWN END ###########################

// Key sequence input controller START ######################
if(Input.GetKeyDown(KeyCode.UpArrow)) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 

if(firstDown) {
if(Input.GetKeyDown(KeyCode.RightArrow)) {
// highlight the button or play a sound
secondDown = true;//3. return true if you push first and second key
}                 
}

if(secondDown) {
if(Input.GetKeyDown(KeyCode.DownArrow)) {
// highlight the button or play a sound
thirdDown = true; //4. return true if you push first and second key and third
}                 
}

if(thirdDown) {
if(Input.GetKeyDown(KeyCode.LeftArrow)) {
// highlight the button or play a sound
allDown = true;  //5. return true if you push first and second key and third and fourth
}                 
}

//4. if all sequence is true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Next Level...
firstDown = false; // reset variables
secondDown = false;
thirdDown = false;
allDown = false;   
}
// Key sequence input controller END ########################
}// KeySequenceControl() END ####################################################################

(Input Manager) Sequence of 4 keys – Basic + CountDown – Separate function()

Control Keys using Unity3D Input Manager, so end users can setup keys:

(Input.GetKeyDown(KeyCode.UpArrow) -> (Input.GetKeyDown(“up”)


// Key Sequence Input Controller
// Attach this script to a GameObject in the scene

private var firstDown : boolean = false;  // false at the beginning, I have no typed yet
private var secondDown : boolean = false; // false at the beginning, I have no typed yet
private var thirdDown : boolean = false;  // false at the beginning, I have no typed yet
private var allDown : boolean = false;    // false at the beginning, I have no typed yet

private var endTime : float;

function Start()
{
    endTime = Time.time + 3; // 3 seconds to type the right sequence!
}// End Start()
 
function Update() {
	KeySequenceControl(); // call the function to control the sequence

}// End Update()

// KeySequenceControl() START ##################################################################
function KeySequenceControl(){

    // COUNTDOWN START #########################
    var timeLeft : int = endTime - Time.time; 
    // We do not need negative time
    if (timeLeft < 0){ 
        timeLeft = 0;
    	        firstDown = false;   // reset variables, You Fail!
		secondDown = false;
		thirdDown = false;
		allDown = false;
		// Retry or Abort...
		}
    // COUNTDOWN END ###########################

// Key sequence input controller START ######################
if(Input.GetKeyDown("up")) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 

if(firstDown) {
if(Input.GetKeyDown("right")) {
// highlight the button or play a sound
secondDown = true;//3. return true if you push first and second key
}                 
}

if(secondDown) {
if(Input.GetKeyDown("down")) {
// highlight the button or play a sound
thirdDown = true; //4. return true if you push first and second key and third
}                 
}

if(thirdDown) {
if(Input.GetKeyDown("left")) {
// highlight the button or play a sound
allDown = true;  //5. return true if you push first and second key and third and fourth
}                 
}

//4. if all sequence is true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Next Level...
firstDown = false; // reset variables
secondDown = false;
thirdDown = false;
allDown = false;   
}
// Key sequence input controller END ########################
}// KeySequenceControl() END ####################################################################

(Input Manager) Sequence of 4 keys – Basic + CountDown – Separate sequence variables


// Key Sequence Input Controller
// Attach this script to a GameObject in the scene

// Right Sequence
var firstKey  : String = "up";
var secondKey : String = "right";
var thirdKey  : String = "down";
var fourthKey : String = "left";

private var firstDown : boolean = false;  // false at the beginning, I have no typed yet
private var secondDown : boolean = false; // false at the beginning, I have no typed yet
private var thirdDown : boolean = false;  // false at the beginning, I have no typed yet
private var allDown : boolean = false;    // false at the beginning, I have no typed yet

private var endTime : float;

function Start()
{
    endTime = Time.time + 3; // 3 seconds to type the right sequence!
}// End Start()
 
function Update() {
	KeySequenceControl(); // call the function to control the sequence

}// End Update()

// KeySequenceControl() START ##################################################################
function KeySequenceControl(){

    // COUNTDOWN START #########################
    var timeLeft : int = endTime - Time.time; 
    // We do not need negative time
    if (timeLeft < 0){ 
        timeLeft = 0;
    	        firstDown = false;   // reset variables, You Fail!
		secondDown = false;
		thirdDown = false;
		allDown = false;
		// Retry or Abort...
		}
    // COUNTDOWN END ###########################

// Key sequence input controller START ######################
if(Input.GetKeyDown(firstKey)) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 

if(firstDown) {
if(Input.GetKeyDown(secondKey)) {
// highlight the button or play a sound
secondDown = true;//3. return true if you push first and second key
}                 
}

if(secondDown) {
if(Input.GetKeyDown(thirdKey)) {
// highlight the button or play a sound
thirdDown = true; //4. return true if you push first and second key and third
}                 
}

if(thirdDown) {
if(Input.GetKeyDown(fourthKey)) {
// highlight the button or play a sound
allDown = true;  //5. return true if you push first and second key and third and fourth
}                 
}

//4. if all sequence is true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Next Level...
firstDown = false; // reset variables
secondDown = false;
thirdDown = false;
allDown = false;   
}
// Key sequence input controller END ########################
}// KeySequenceControl() END ####################################################################

(Input Manager) Sequence of 4 keys – Basic + CountDown – Arrays


// Key Sequence Input Controller
// Attach this script to a GameObject in the scene
     
    // array START #######################
    var i : int = 0; // array index start value
    var sequenceKey = new Array (); 
    // Right Sequence
    sequenceKey[0] = "up";
    sequenceKey[1] = "right";
    sequenceKey[2] = "down";
    sequenceKey[3] = "left";
    // array END #########################

private var firstDown : boolean = false;  // false at the beginning, I have no typed yet
private var secondDown : boolean = false; // false at the beginning, I have no typed yet
private var thirdDown : boolean = false;  // false at the beginning, I have no typed yet
private var allDown : boolean = false;    // false at the beginning, I have no typed yet

private var endTime : float;

function Start()
{
    endTime = Time.time + 3; // 3 seconds to type the right sequence!
}// End Start()
 
function Update() {
	KeySequenceControl(); // call the function to control the sequence

}// End Update()

// KeySequenceControl() START ##################################################################
function KeySequenceControl(){

    // COUNTDOWN START #########################
    var timeLeft : int = endTime - Time.time; 
    // We do not need negative time
    if (timeLeft < 0){ 
        timeLeft = 0;
    	        firstDown = false;   // reset variables, You Fail!
		secondDown = false;
		thirdDown = false;
		allDown = false;
		// Retry or Abort...
		}
    // COUNTDOWN END ###########################

// Key sequence input controller START ######################
if(Input.GetKeyDown(sequenceKey[0])) {
// highlight the button or play a sound
firstDown = true; //1. return true if you push first key
}
                  //2. if the first key is true 

if(firstDown) {
if(Input.GetKeyDown(sequenceKey[1])) {
// highlight the button or play a sound
secondDown = true;//3. return true if you push first and second key
}                 
}

if(secondDown) {
if(Input.GetKeyDown(sequenceKey[2])) {
// highlight the button or play a sound
thirdDown = true; //4. return true if you push first and second key and third
}                 
}

if(thirdDown) {
if(Input.GetKeyDown(sequenceKey[3])) {
// highlight the button or play a sound
allDown = true;  //5. return true if you push first and second key and third and fourth
}                 
}

//4. if all sequence is true do someting...
if(allDown) {
Debug.Log ("Sequence OK!"); // Debug Code
//Next Level...
firstDown = false; // reset variables
secondDown = false;
thirdDown = false;
allDown = false;   
}
// Key sequence input controller END ########################
}// KeySequenceControl() END ####################################################################
By |Unity3D, Video Games Development|Commenti disabilitati su Unity 3D – Key Sequence Input – Basics – JavaScript
Read More

Unity 3D – Key Sequence Input – Advanced – JavaScript

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

By |Unity3D, Video Games Development|Commenti disabilitati su Unity 3D – Key Sequence Input – Advanced – JavaScript
Read More

Unity3D – Mouse – Drag Rigid Body

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;
}
By |Unity3D, Video Games Development|Commenti disabilitati su Unity3D – Mouse – Drag Rigid Body
Read More