Finalmente siamo arrivati al nocciolo del nostro corso: in questa lezione vedremo come creare script in Unity!
Ma cos’è uno script?
Beh, uno script è qualcosa che attribuisce ad un oggetto uno o più comportamenti specifici.
Ok, la descrizione è un po’ troppo generale, ma perchè in effetti uno script è l’elemento più genereale che si possa trovare in un videogioco realizzato in Unity!
Per essere più chiari, devi sapere che tutti i componenti che abbiamo esaminato fino a questo momento possono essere considerati script a tutti gli effetti, preconfezionati per noi dal team di Unity e pronti all’uso.
Ovviamente questi non bastano, e per la stragrande maggioranza delle azioni che si verificheranno nel tuo videogioco dovrai creare uno script apposito, che si tratti dell’accensione di una lampadina alla pressione di un tasto o dell’intelligenza artificiale dei nemici del gioco!
Per scrivere i nostri script avremo bisogno di un linguaggio di programmazione, cioè di un linguaggio che ci permetta di comunicare con la macchina sulla quale girerà il nostro videogioco.
Benché i computer siano bravissimi ad effettuare calcoli complicatissimi in un battito di ciglia essi non hanno un gran comprendonio, e dirgli “computer, dì al personaggio di sparare con la pistola” lo mandarebbe in confusione!
Un linguaggio di programmazione è una lingua molto rigida dal punto di vista della sintassi.
Questa ci permette di farci capire dal computer tramite l’utilizzo di alcune parole chiave senza fraintendimenti, in maniera univoca e non soggetta ad interpretazioni.
Esistono moltissimi linguaggi di programmazione, e quello che utilizzeremo in Unity è il C# (il cui nome è C Sharp, e non C cancelletto o C hashtag!).
Per scrivere il nostro codice avremo bisogno di un’IDE: l’interfaccia di sviluppo da cui potremo scrivere, modificare e correggere il codice del nostro script in maniera agevole.
Utilizzeremo Visual Studio, che è integrato in Unity e che quindi hai già installato insieme a quest’ultimo!
Creiamo il nostro primo script dal Project Panel ed apriamolo (Se non sai cos’è e come aprire quel Panel l’ho spiegato in questa lezione). Verrà aperto automaticamente in Visual Studio:
Al suo interno troveremo queste prime righe di codice:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PrimoScript : MonoBehaviour {
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}Per il momento ignoriamo le prime tre righe di codice e concentriamoci su questa parte:
public class PrimoScript : MonoBehaviour {
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}questa è la classe dello script che abbiamo appena creato.
Per un programmatore con un minimo di esperienza potrebbe sembrare una blasfemia, ma per il momento puoi vederla come un grosso scatolone all’interno del quale andremo a scrivere il nostro codice!
La classe dovrà avere sempre lo stesso nome dello script che abbiamo creato in precedenza nel formato public class Nomeclasse : MonoBehaviour (in questo caso sarà “PrimoScript”).
Assicurati di non cambiarlo mai, o lo script non funzionerà più correttamente!
Per cominciare eliminamo quelle poche righe di codice che troviamo dentro la classe, fino ad arrivare ad una situazione del genere :
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PrimoScript : MonoBehaviour {
}Le parentesi graffe che seguono la dichiarazione della classe indicano e delimitano il corpo della classe stessa, e il nostro codice dovrà essere scritto al loro interno!
Le variabili in C#
Una variabile è quella parte di codice che ci permette di salvare e manipolare dei dati.
Come vedremo esistono diversi tipi di dati, e di conseguenza esistono anche un’infinità di tipi di variabili!
La prima cosa da fare all’interno di una classe è dichiarare le variabili che verranno utilizzate all’interno del nostro script.
La variabile va dichiarata specificandone modificatore d’accesso, tipo e nome.
Modificatore d’accesso
Il modificatore d’accesso è quella parola chiave che attribuisce una certa visibilità alla nostra variabile.
I modificatori d’accesso che più ci ritroveremo ad utilizzare (e opposti tra loro) sono public e private, e per scegliere correttamente quale valore attribuire alla nostra variabile dobbiamo rispondere alla domanda:
voglio che questa variabile sia modificabile ed accessibile dall’esterno?
Le variabili con modificatore public infatti saranno visibili dall’inspector panel del nostro componente, e quindi modificabili da esso o da qualsiasi altro script del nostro videogioco.
Certe volte però è bene (o talvolta anche necessario) nascondere delle variabili che non devono essere modificate da mano umana o da un qualsiasi altro script.
Definendo una variabile come private essa ci sarà completamente nascosta, e sarà impossibile modificarne il valore senza accedere direttamente allo script!
Si può omettere il modificatore d’accesso, ma in questo caso la nostra variabile verrà considerata come privata.
Tipi di dato
Il tipo di un dato è la parte più importante della dichiarazione della nostra variabile.
Esso infatti permette alla nostra macchina di capire con quale dato avrà a che fare e di poterlo gestire opportunamente, riservandogli la giusta quantità di memoria e senza entrare in confusione.
Per ricollegarmi a ciò che ho detto all’inizio riguardo l’intelligenza dei nostri computer, supponiamo di voler fare una somma tra due valori: 2 e “ciao”.
Chiunque abbia frequentato la prima elementare a questo punto potrebbe scoppiare a ridere, perchè sa che 2 è un numero, mentre “ciao” è una parola, e non può essere usata come un numero!
Il nostro computer invece proverà a sommare i due valori completamente diversi tra loro, perchè non sa che uno dei due è un numero e l’altro una parola. Per questo motivo in fase di dichiarazione delle variabili è necessario specificare il tipo di dato!
Se il modificatore d’accesso può essere omesso, il tipo di una variabile deve sempre e necessariamente essere specificato.
Non può esistere una variabile che non abbia il proprio tipo ben in evidenza, e se provassimo ad inizializzarne una il nostro bravo Visual Studio inizierebbe a segnalarci errori a raffica!
Esistono una miriade di tipi di dato differenti, ma per il momento introdurrò solo quelli basilari, introducendone altri man mano che verranno utilizzati.
- int: indica un numero intero, come il 2, il 3, il 10 e così via.
- float: indica un numero decimale. Per essere riconosciuto correttamente il numero decimale deve essere separato dalla sua parte intera da un punto e deve avere una f alla fine. Es: 2.3f, 3.14f, 5.005f.
- string: indica una stringa, o più semplicemente una sequenza di caratteri. Al suo interno potrai salvare una parola, una frase o una sequenza qualsiasi di lettere e numeri!
- bool: indica una variabile booleana. Ok, il nome può far paura, ma in realtà una variabile booleana è qualcosa di estremamente semplice. Essa infatti funziona esattamente come un’interruttore, e può avere solo uno tra due valori: vero o falso (in inglese true o false). Magari per il momento la cosa non avrà molto senso, ma in futuro l’utilizzo di queste variabili sarà necessario per eseguire determinate parti del nostro script ed escluderne altre!
Nome della variabile
Ultima parte della definizione di una variabile è il nome. Esso dovrà essere univoco (quindi non potranno esistere più variabili con lo stesso nome), non dovrà contenere spazi e dovrà essere diverso dal tipo di dato.
Se il nome della nostra variabile è composto da più di una parola è buona norma avvalersi del cosiddetto “Camel Case”, cioè porre la prima lettera di ogni parola successiva alla prima con carattere maiuscolo (esempio: miaVariabile).
Dopo aver definito modificatore d’accesso, tipo e nome la dichiarazione di una variabile può dirsi conclusa!
A questo punto è necessario chiudere la definizione della variabile stessa tramite l’uso di un punto e virgola.
Il punto e virgola è un segno importantissimo all’interno di parecchi linguaggi di programmazione, e dovrai utilizzarlo alla fine di qualsiasi istruzione che eseguirai all’interno dei tuoi script!
vediamo quindi un semplice script al cui interno sono state definite delle variabili:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PrimoScript : MonoBehaviour {
public int miaVariabile;
public string nomeDelMioCane;
private string mioCodiceFiscale;
}Dopo aver scritto questo codice all’interno del nostro script in Visual Studio sarà necessario salvarlo tramite l’apposito tasto nella barra in alto.
A questo punto potremo procedere assegnando il nostro script ad un oggetto qualsiasi della nostra scena come abbiamo fatto per qualsiasi altro componente fino a questo momento (nell’animazione qua sotto io l’ho assegnato alla main camera!)
Come potrai notare ancora una volta, dall’inspector del nostro script sarà possibile modificare le variabili “miaVariabile” e “nomeDelMioCane”.
Sarà invece impossibile vedere o modificare la variabile mioCodiceFiscale, perchè è stata dichiarata come privata!
Metodi ed istruzioni
I metodi sono senza dubbio il cuore pulsante dei nostri script.
Se fino a questo momento abbiamo solo dichiarato le nostre variabili, è all’interno dei metodi che esse entrano in gioco diventando realmente utili. E lo fanno attraverso le istruzioni!
Per farti afferrare meglio il concetto facciamo un esempio culinario: la preparazione di una torta.
Possiamo vedere l’intera procedura di preparazione della nostra torta come il nostro script e le variabili come gli ingredienti della nostra torta (uova, farina, zucchero e così via).
Le istruzioni saranno i singoli passaggi che dovremo eseguire per produrre la nostra torta, come ad esempio montare gli albumi d’uovo, aggiungere la farina dopo 5 minuti, accendere il forno a 180 gradi, infornare per 40 minuti e via dicendo.
Queste singole istruzioni possono essere racchiuse in delle “macroistruzioni”, ossia i metodi!
Tornando all’esempio della preparazione della torta, immagina che il nostro ricettario venga diviso in parti diverse per preparare elementi diversi della torta: una parte contenente le istruzioni per fare il pan di spagna, una parte per la crema ed una parte per la guarnitura.
All’interno di ogni parte della ricetta troveremmo delle istruzioni per creare quello specifico elemento, ed è esattamente ciò che fanno i metodi!
Dividono il codice del nostro script in parti diverse per aumentarne la flessibilità, la leggibilità e la riusabilità.
Se per la mia torta ho creato un’ottima crema pasticcera, potrò usare la stessa crema per fare degli ottimi bignè, no?
Ecco, la stessa cosa vale per i metodi.
Se ho un metodo che permette al mio personaggio per ricevere danni, potrò usarlo in più occasioni (ricevere danni dopo aver subito un attacco dal nemico, o in seguito ad una caduta!).
Come utilizzare metodi ed istruzioni
Se la teoria può essere piuttosto confusionaria al momento, con la pratica tutto sarà più chiaro! Vediamo quindi come scrivere metodi ed istruzioni in codice comprensibile per la nostra macchina:
Per il momento lavoreremo solo con un particolare tipo di metodi : le event function.
Come suggerisce il nome, questo tipo di metodi entra in funzione al verificarsi di un particolare evento all’interno del nostro gioco.
Abbiamo già visto due di queste event function, anche se solo di sfuggita: le funzioni Start() ed Update(), che abbiamo cancellato dal nostro script all’inizio di questa lezione.
La funzione Start() ed il suo contenuto entrano in esecuzione all’avvio del nostro gioco (o in alternativa quando l’oggetto che contiene lo script viene attivato nella nostra scena).
Mentre, la funzione Update() viene eseguita ad ogni frame del nostro gioco.
Modifichiamo il nostro primo script come segue: inseriamo la funzione Start e al suo interno richiamiamo una prima istruzione: Debug.Log!
Forse lo avrai già notato, ma Visual Studio ci sarà molto utile durante la scrittura del nostro codice.
Scrivendo di un’struzione esso infatti ci suggerirà sempre un elenco di metodi o variabili da richiamare, con annessa descrizione e sintassi!
Debug è una classe predefinita di Unity, e inquanto classe contiene al suo interno un certo numero di metodi, a cui possiamo accedere mettendo un punto dopo la parola Debug!
Quello di cui abbiamo bisogno è il metodo “Log”, che come possiamo leggere dalla sua breve descrizione non farà altro che far apparire una scritta all’interno della nostra console di Unity (di cui abbiamo già brevemente parlato nella lezione riguardante l’interfaccia).
Scriviamo quindi una breve frase fra parentesi e virgolette e chiudiamo l’istruzione utilizzando il punto e virgola. Otterrai qualcosa di simile:
using UnityEngine;
using System.Collections;
public class PrimoScript : MonoBehaviour {
void Start(){
Debug.Log("Ciao Mondo!");
}
}Salvando ed entrando in Play Mode verrà eseguita la funzione Start e vedremo apparire il nostro messaggio all’interno del console panel.
Assegnazione delle variabili
Una delle istruzioni fondamentali nella scrittura di codice è l’assegnazione delle variabili. Possiamo assegnare o modificare il valore di una variabile in due modi: o durante la sua dichiarazione o all’interno di un metodo. Per esempio:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PrimoScript : MonoBehaviour {
private int miaVariabile = 10;
private int altraVariabile;
void Start(){
altraVariabile = 5;
}
}In questo caso la variabile detta miaVariabile è stata istanziata con un valore di 10, mentre alla variabile altraVariabile è stato assegnato un valore di 5 all’interno della funzione Start.
La regola generale per un’assegnazione è che il valore di ciò che sta a destra del segno “=” viene assegnato a ciò che sta alla sua sinistra.
Se lo script fosse stato:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PrimoScript : MonoBehaviour {
private int miaVariabile = 10;
private int altraVariabile;
void Start(){
altraVariabile = miaVariabile + 5;
}
}allora altraVariabile avrebbe avuto un valore di 15!
Cioè il valore di miaVariabile (che è 10) sommato a cinque. Il valore di altraVariabile sarà 15 fino ad un’ulteriore modifica o alla fine dell’esecuzione dello script.
Per fare un ulteriore esempio sull’assegnazione delle variabili, esaminiamo il seguente script:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PrimoScript : MonoBehaviour {
private int counter = 0;
public string mioNome;
void Update(){
counter = counter + 1;
Debug.Log("Il mio nome è "+ mioNome + " ed ho scritto " + counter + " messaggi!");
}
}Questa volta stiamo utilizzando la funzione Update, quindi il suo contenuto verrà eseguito ad ogni frame del nostro gioco!
la variabile counter è stata inizializzata a 0, e la prima cosa che fa la nostra funzione Update è assegnarle il suo stesso valore incrementato di uno.
In pratica, ne aumenta il valore di uno! In seguito la funzione stampa sulla console una scritta contenente il nostro nome (da inserire tramite inspector panel) più l’attuale valore di counter, che verrà aggiornato di ciclo in ciclo.
La prima volta sarà 1, poi 2, 3 e così via.
Considerazioni finali
Ovviamente questi sono solo i concetti base per introdurti al mondo dello scripting in Unity.
Nella prossima parte continueremo a parlare di scripting introducendo altri elementi fondamentali ed imparando a controllare direttamente oggetti del nostro gioco.
Per questa lezione è tutto, alla prossima!