unity3d

Unity – Spaceship Shooting Game – JS – Game Over

MAIN TOP MENU> GameObject> Create Empty, rename it ‘Display Text’, Inspector> Transform> gear icon> Reset

MAIN TOP MENU> GameObject> Create Other> GUI Text, rename it ‘Restart Text’> Text ‘Restart’

MAIN TOP MENU> GameObject> Create Other> GUI Text, rename it ‘Game Over Text’> Text ‘Game Over’

Hierarchy: Display Text (father)
– Score Text (child)
– Restart Text (child)
– Game Over Text (child)

Game Controller empty object has GameController.js:

#pragma strict

var hazard : GameObject;
var spawnValues : Vector3;
var hazardCount : int;
var spawnWait : float;
var startWait : float;
var waveWait : float;

// GUI Text da assegnare da Inspector
var scoreText : GUIText;
var restartText : GUIText;
var gameOverText : GUIText;

// variabili per il game over, restart, sono booleane VERO O FALSO
private  var gameOver : boolean;
private  var restart : boolean;

private  var score : int;

function Start () {
    // gameover falso all'inizio 
    gameOver = false;
    // restart falso all'inizio
    restart = false;
    // GUIText Restart è vuoto all'inizio
    restartText.text = "";
    // GUI Text Game Over è vuoto all'inizio
    gameOverText.text = "";
    score = 0;
    UpdateScore ();
    StartCoroutine (SpawnWaves ());
}

function Update () {
    // se restart è vero, vedi sopra che è una variabile booleana
    // questo dato è inviato dalla riga - if (gameOver)
    if (restart)
    {
        // resta in ascolto del tasto R da tastiera
        // se viene attivato
        if (Input.GetKeyDown (KeyCode.R))
        {
            // ricarica il livello
            Application.LoadLevel (Application.loadedLevel);
        }
    }
}

function SpawnWaves () {
    yield WaitForSeconds (startWait);
    while (true)
    {
        for ( var i : int= 0; i < hazardCount; i++)
        {
             var spawnPosition : Vector3= new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);
             var spawnRotation : Quaternion= Quaternion.identity;
            Instantiate (hazard, spawnPosition, spawnRotation);
            yield WaitForSeconds (spawnWait);
        }
        yield WaitForSeconds (waveWait);

        // se gameOver è vero, vedi sopra che è una variabile booleana
        if (gameOver)
        {
            // scrivi a video 
            restartText.text = "Press 'R' for Restart";
            // setta restart a vero
            restart = true;
            // interrompi il gioco
            break;
        }
    }
}

function AddScore (newScoreValue : int) {
    score += newScoreValue;
    UpdateScore ();
}

function UpdateScore () {
    scoreText.text = "Score: " + score;
}

// la funzione GameOver() viene richiamata da DestroyByContact.js
function GameOver () {
    // scrivi a video Game Over!
    gameOverText.text = "Game Over!";
    // setta la variabile booleana a vero
    gameOver = true;
}

Inspector, you have to assign:
– Score Text (GUIText)
– Restart Text (GUIText)
– Game over Text (GUIText)

Asteroid prefab has DestroyByContact.js:

#pragma strict

var explosion : GameObject;
var playerExplosion : GameObject;
var scoreValue : int;
private var gameController : GameController;

function Start ()
{
    // Richiama l'oggetto Game Controller e il suo script GameController.js INIZIO
    var gameControllerObject : GameObject = GameObject.FindWithTag ("GameController");
    if (gameControllerObject != null)
    {
        gameController = gameControllerObject.GetComponent (GameController);
    }
    if (gameController == null)
    {
        Debug.Log ("Cannot find 'GameController' script");
    }
    // Richiama l'oggetto Game Controller e il suo script GameController.js FINE
}

function OnTriggerEnter(other : Collider) 
{
    if (other.tag == "Boundary")
    {
        return;
    }
    Instantiate(explosion, transform.position, transform.rotation);
    if (other.tag == "Player")
    {
        Instantiate(playerExplosion, other.transform.position, other.transform.rotation);
        // dopo che è istanziato il VFX per l'esplosione del Player
        // richiama Game Controller oggetto> GameObject.js> funzione Gameover()
        gameController.GameOver ();
    }
    gameController.AddScore (scoreValue);
    Destroy(other.gameObject);
    Destroy(gameObject);
}

In conclusione:

1. Asteroide è un Prefab con associato DestroyByContact.js
a) istanzia l’esplosione del Player
b) richiamala funzione di Gameover() di GameController.js
2. Game Controller è un empty object con associato GameController.js
a) riceve da DestroyByContact.js l’attivazione della funzione Gameover()
b) Gameover() scrive ‘Game Over!’ sul display e setta la variabile booleana gameOver a VERO
c) Se gameOver è VERO scrive a video ‘Press R for Restart’ e setta la variabile booleana restart a VERO, interrompe il ciclo while con break
d) Se restart è VERO resta in attesa che venga premuto ‘R’
e) Se viene premuto R viene ricaricato il livello – Application.LoadLevel (Application.loadedLevel) –

Unity – Spaceship Shooting Game – JS – Scores

You scores will increase when an Asteroid Explode

Create the GUI Text

MAIN TOP MENU> GameObjects> Create Other> GUI Text, rename it ‘Score Text’

NOTICE:
GUI Text> Transform Component
– it does not use ‘Screen Space’ in Pixels 600x900px
– it use the ‘Viewport Space’ =
– lower left corner 0,0
– upper right corner 1,1
– upper left corner 0,1
– middle of the viewport 0.5,0.5

Perfezioniamo la posizione utilizzando un valore in pixel ammesso da:
GUI Text> GUI Text Component
– Pixel Offset 10,-10

Scripts

Hierarchy> Game Controller> GameController.js

#pragma strict

var hazard : GameObject;
var spawnValues : Vector3;
var hazardCount : int;
var spawnWait : float;
var startWait : float;
var waveWait : float;

// Hierarchy DRAG E DROP un GUI Text in Inspector
var scoreText : GUIText;
// contatore di punteggio, private perchè non vogliamo che sia modificabile da Inspector
private  var score : int;

function Start () {
    // Il punteggio iniziale è zero
    score = 0;
    // poi viene richiamata ogni frame la funzione UpdateScore()
    // che scrive a video il punteggio
    UpdateScore ();
    StartCoroutine (SpawnWaves ());
}

function SpawnWaves () {
    yield WaitForSeconds (startWait);
    while (true)
    {
        for ( var i : int= 0; i < hazardCount; i++)
        {
             var spawnPosition : Vector3= new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);
             var spawnRotation : Quaternion= Quaternion.identity;
            Instantiate (hazard, spawnPosition, spawnRotation);
            yield WaitForSeconds (spawnWait);
        }
        yield WaitForSeconds (waveWait);
    }
}

function AddScore (newScoreValue : int) {
    // aggiorna score aggiungendo il valore newScoreValue
    // che gli viene inviato da DestroyByContact.js
    // alla riga:  - gameController.AddScore (scoreValue); -
    score += newScoreValue;
    // e scrive a video il punteggio
    UpdateScore ();
}

function UpdateScore () {
    // a scoreText viene assegnato in Inspector un GUI Text
    // ne modifico la proprietà .text scrivendo il punteggio attuale Score: 10
    scoreText.text = "Score: " + score;
}

NOTICE: tag the Game Controller object – GameController

Inspector> Game Controller (Script)> Score Text> DRAG ANd DROP ‘Score Text’ (GUI Text)

Prefab> Asteroid> DestroyByContact.js

#pragma strict

var explosion : GameObject;
var playerExplosion : GameObject;

// Assegnato in Inspector è l'incremento di punteggio per ogni esplosione
var scoreValue : int;
// variabile privata, non visibile in Inspector
private var gameController : GameController;

function Start ()
{
    // inserisco in una variabile l'oggetto con tag GameController
    var gameControllerObject : GameObject = GameObject.FindWithTag ("GameController");
    // se l'oggetto con tag GameController esiste lo inserisco in una variabile
    if (gameControllerObject != null)
    {
        gameController = gameControllerObject.GetComponent (GameController);
    }
    // se l'oggetto con tag GameController non esiste restituisce un messaggio di errore
    if (gameController == null)
    {
        Debug.Log ("Cannot find 'GameController' script");
    }
}

function OnTriggerEnter(other : Collider) 
{
    if (other.tag == "Boundary")
    {
        return;
    }
    Instantiate(explosion, transform.position, transform.rotation);
    if (other.tag == "Player")
    {
        Instantiate(playerExplosion, other.transform.position, other.transform.rotation);
    }
    // se la collisione è presente e viene istanziata l'esplosione
    // dello script taggato GameController richiama la funzione AddScore
    // e gli invia il parametro scoreValue, cioè l'incremento di punteggio per ogni asteroide esploso
    gameController.AddScore (scoreValue);
    
    Destroy(other.gameObject);
    Destroy(gameObject);
}

Inspector> Destroy By Contact (Script)> Score Value 10, every asteroid explosion you win 10+ scores

Riassumendo funziona nel seguente modo:

1. Asteroide è un Prefab, ed include lo script DestroyByContact.js

2. DestroyByContact.js
a) istanzia il VFX dell’esplosione
b) distrugge l’asteroide e l’oggetto chge lo ha urtato
c) invia a GameController.js la variabile ‘scoreValue’ alla funzione AddScore()

3. Game Controller è un oggetto vuoto con associato GameController.js
a) riceve il valore ‘scoreValue’ da DestroyByContact.js
b) ‘scoreValue’ viene ricevuto dalla funzione AddScore() e storato nella variabile ‘newScoreValue’
c) viene sommato il valore a quello esistente
d) la funzione UpdateScore() cambia il valore dell’oggetto GUIText assegnato in Inspector nella variabile ‘scoreText’

Unity – Spaceship Shooting Game – JS – Clear Exploded GameObjects

It is useful clear exploded gameobjects to improve performance of your game

1. Create the script:

DestroyByTime.js

#pragma strict

// Da Inspector assegnare quanto tempo esisterà ancora l'oggetto VFX esplosione dopo che verrà istanziato
// ATTENZIONE! non deve essere distrutto prima che sia terminata l'animazione dell'esplosione!
var lifetime : float;

function Start ()
{
    Destroy (gameObject, lifetime);
}

2. Assets> Prefabs> VFX> Explosions> Select a prefab for the explosion animation> Inspector> ‘Add Component’> Scripts> DestroyByTime

3. Inspector> Destroy By Time (Script)> Lifetime example 2 (seconds)

Unity – Spaceship Shooting Game – JS – Game Controller

1. MAIN TOP MENU> GameObject> Create Empty> rename it ‘Game Controller’
2. Inspector> Transform> small gear icon> Reset
3. Inspector> Assign the tag GameController

Generate a single asteroid

4. Assign the cript ‘GameController.js’

#pragma strict

var hazard : GameObject;   // oggetto pericoloso - Assign the asteroid prefab inside Inspector
var spawnValues : Vector3; // Assign the max value of asteroid Vector3 position inside Inspector example X=6 Z=16

function Start () {
    SpawnWaves ();
}

function SpawnWaves () {
    // Asteroid position, Random values: X -6 to 6 | Z 16 to -16
    var spawnPosition : Vector3= new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);
    // Asteroid rotation
    var spawnRotation : Quaternion= Quaternion.identity;
    // Render the hazard
    Instantiate (hazard, spawnPosition, spawnRotation);
}

Generate multiple asteroids

#pragma strict

// ######################### VARIABILI ASTEROIDI START ##################################
// Assegnare da Inspector il prefab Asteroid
var hazard : GameObject;  
// Assignare da Inspector la posizione nella quale può essere generato Asteroid, 
// per X=6, sarà uguale per X a +6 o -6 unità Unity dal centro 0,0,0  
var spawnValues : Vector3; 
// Assegnare da Inspector il numero di asteroidi per ondata da generare  
var hazardCount : int;
// Assegnare da Inspector il tempo di attesa nel generare i singoli asteroidi di un'ondata
var spawnWait : float;
// Assegnare da Inspector il tempo di attesa per generare il primo asteroide
// il giocatore avrà il tempo di concentrarsi prima di iniziare a giocare
var startWait : float;
// Assegnare da Inspector il tempo di attesa tra un'ondata e la successiva
var waveWait : float;
// ######################### VARIABILI ASTEROIDI END ####################################

function Start () {
    // Al'interno della funzione start richiamo la funzione per generare le ondate di asteroidi
    SpawnWaves ();
}

// FUNZIONE GENERAZIONE ONDATE ASTEROIDI START
function SpawnWaves () {
    // imposto una breve pausa per dare il tempo al giocatore di concentrarsi prima di iniziare a giocare
    yield WaitForSeconds (startWait);
    // GENERAZIONE ONDATE INIZIO - while sempre vero, genera un ciclo infinito di asteroidi
    while (true)
    {
        // Genera la singola ondata di asteroidi, il numero di asteroidi che compone l'ondata è la variabile hazardCount
        for ( var i : int= 0; i < hazardCount; i++)
        {
             var spawnPosition : Vector3= new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);
             var spawnRotation : Quaternion= Quaternion.identity;
            Instantiate (hazard, spawnPosition, spawnRotation);
            // Tempo di attesa che trascorre tra la generazione di un asteroide e il successivo
            // per evitare che si scontrino tra loro
            yield WaitForSeconds (spawnWait);
        }
        yield WaitForSeconds (waveWait);
    }
    // GENERAZIONE ONDATE FINE - while sempre vero, genera un ciclo infinito di asteroidi
}
// FUNZIONE GENERAZIONE ONDATE ASTEROIDI END