Guida pratica a Unity3D

variable name.print(Script1.qualcosa);
Script1.qualcosa++;

function Update(){
…
yield; //attende un frame
yieldWaitForSeconds (2); //attende 2 secondi
…
}

Manipolare il Transform di un GameObject

Transform contiene tutte le informazioni su posizione, rotazione e scala di un oggetto tridimensionale (o GameObject): di seguito riporto le istruzioni utili per manipolarle. Ovviamente a queste tre corrispondenti variabili è necessario assegnare un oggetto vettore (Vector3) o, se si tratta di una rotazione, di un Quaternion:transform.position = Vector3(0, 0, 0);
transform.rotation = Quaternion.identity; //means no rotation
transform.localScale += Vector3(0.1,0,0);

Nemici che si muovono verso di noi secondo varie traiettorie

Nella realizzazione di uno sparatutto in prima persona (cosiddetti FPS) una delle prime cose da fronteggiare riguarda le modalità  con cui gli enemy si avvicineranno a voi. Ad esempio in un videogioco di base horror potremmo avere degli zombi dalla caratteristica camminata “zoppa” che si avvicinano a noi seguendo una determinata traiettoria, del tipo:

• linea retta;
• linea curva (“spirale”);

Questo almeno è quello che è possibile definire in prima istanza; ora, associando allo zombie uno script di update fatto come segue, regolando i parametri di ingresso delle “velocità ” rispetto ad x e a z è possibile di fatto ottenere entrambe le traiettorie.

//walk each to other
var other: GameObject;
var vx = 0.3;
var vz = 0.3;

function walk(){
 animation.CrossFade("zombiewalkcycle");
 
 var p1 = transform.position;
 var p2 = other.transform.position;

 //var tmp = Vector3(0,0,0);

 transform.LookAt(p2); //definisce la direzione
  
 //0.92 vuol dire che si avvicina al punto di molto
 //ad es. 0.50 si avvicina di meno e si stabilizza
 //girandogli attorno
 var xx = (p2.x - p2.x*0.92) * vx;
 var yy = 0;
 var zz = (p2.z - p2.z*0.92) * vz;
 
 transform.Translate(xx, yy, zz, Space.Self);
   
 var d = Vector3.Distance (p1, p2); 
 print ("Distanza tra "+p1+" e "+ p2 +" = "+ d);

}

function Update() {
walk();
}

Qualche nota di commento sul codice: quello che vi basta cambiare è il valore di vx e vy, che io ho impostato in tre modalità  diverse ragionando sugli ordini di grandezza (ricordo che un odg rappresenta, parlando “a spanne”, una “decina”, per cui da 10 a 1000 vi sono due odg). Per cui ho impostato:

Update nemico per ogni frame:

 var xx = (p.x - p.x*0.92) * vx;
 var zz = (p.z - p.z*0.92) * vz;

dove ho testato tre possibilità :

1) vx=vy=0.05 spirale 1
2) vx=0.5, vy=0.05 spirale 2
3) vx=0.05, vy=0.5 linea "quasi" retta

Ovviamente il tutto è completamente indipendente, da quanto ho sperimentato, dalla posizione relativa dei due oggetti: il funzionamento si basa sul fatto che l’oggetto che si muove (lo zombie, per capirci) calcola il proprio forward “guardando” nella direzione del target (il vostro player, ovvero quello che nel video resta fermo). L’algoritmo, regolando opportunamente la velocità , converge anche se il player-target si muove nel tempo, e gli inizierà  presto a girare intorno, mantenendo uan distanza costante che dipende dallo 0.92 che ho lasciato nel codice:

//0.92 vuol dire che si avvicina al punto di molto
 //ad es. 0.50 si avvicina di meno e si stabilizza
 //girandogli attorno
 var xx = (p2.x - p2.x*0.92) * vx;
 var yy = 0;
 var zz = (p2.z - p2.z*0.92) * vz;

Accesso statico e dinamico alle variabili

Unity3D, in particolare mediante il suo linguaggio di scripting Javascript (dalla sintassi simile a quella del noto linguaggio client-side) permette di accedere alle variabili nel seguente modo: di seguito presento i dettagli essenziali per programmare che saranno utili in varie circostanze, dagli script più essenziali a quelli più complessi.var x : int;
var y : float;Le variabili necessitano di una dichiarazione di tipo: in questo caso abbiamo dichiarato un intero x ed un float y. La prassi usuale per rendere attivo lo script (ad esempio prova.js) è definire un comportamento per un GameObject (un behaviour) associandolo mediante drag’n drop dal men๠principale di Unity3D. E’ bene mettere tutti gli script in un’apposita cartella, e poi è possibile fare quante associazioni si desidera: in particolare le due variabili sopra indicate saranno public, ovvero saranno modificabili dall’esterno e visibili dall’interfaccia di Unity.

E’ inoltre possibile accedere direttamente da dentro lo script “proprietario” indicando il nome della variabile (ad esempio x=0; x++; e via dicendo), oppure da uno script all’altro mediante la seguente notazione, piuttosto intuitiva:
GetComponent(prova).x = 0;
GetComponent(prova).x++;

Contrariamente, se la variabile è dichiarata come statica (static var z: int; ad esempio), allora è sufficente utilizzare la dot notation (notazione con il punto) come se il nome dello script fosse il nome della classe:

prova.z++; prova.z=0;

NullReferenceException Third Person Controller: come risolvere?

Si tratta di un errore a runtime, ovvero che non viene segnalato quando scrivete il codice ma soltanto quando lo lanciate. Tale eccezione viene lanciata quando inserite un Third Person Controller senza una telecamera di riferimento, ovvero una Camera che sia taggata come Main Camera.
In altri se utilizzate un Third Person Controller per il vostro personaggio avrete bisogno, come mostrato in figura, di avere una MainCamera di riferimento in termini di tag corretto.

Sparo di un cannone (moto proiettile)

Una delle cose più importanti nella realizzazione di un videogioco è la concretizzazione del sistema fisico, ovvero la realizzazione di corpi che, in primissima istanza, si comportano come se fossero soggetti a forza di gravità . Avrete notato che se ponete in una scena un piano ed un cubo, ad esempio, e premete Play dopo aver posizionato opportunamente una camera, il cubo rimarra sospeso nel vuoto.Devo necessariamente premettere un paio di cose prima di andare avanti: anzitutto la differenza tra vista Globale e Locale. La prima, in effetti, fa riferimento ad una “visione” degli assi direzionali x,y,z in modo assoluto, quindi indipendente dai vari oggetti sulla scena, mentre la seconda è relativa a dove “sta guardando” un determinato GameObject. La distinzione viene fatta perchè, nel caso in cui ruotiate un certo personaggio, per esempio, il suo sistema di assi puo’ non coincidere con quello globale, e puo’ essere utile in alcuni casi passare dall’una all’altra.

Come forse saprete Unity3D permette di applicare la fisica ad un qualsiasi GameObject, ed il modo più semplice per farlo è quello di selezionare l’oggetto e dal menu Components selezionare Phisics-> RigidBody. Questo vi metterà  a disposizione una nuova componente nella quale potrete decidere le caratteristiche fisiche dell’oggetto, tra cui:

• mass: la massa o “peso” dell’oggetto
• drag: il “rallentamento” che subisce l’oggetto durante il moto, ad esempio “effetto paracadute” che potete settare a 20, per esempio;
• angular drag: il “rallentamento” che subisce l’oggetto durante la rotazione, che potete settare a 5, per esempio;
• collision detect: discreta, continua, o continua e dinamica;
• use gravity: oggetto sottoposto alla forza di gravità  lungo l’asse globale y, in direzione -1.

A questo punto proveremo ad applicare una forza ad esempio ad una sfera sulla quale avrete applicato la componente fisica, allo scopo di emulare il classico “moto di un proiettile” (il cannone che spara un colpo, per intenderci). Per farlo ricorreremo alla pratica funzione addForce, applicata ovviamente una sola volta quando l’oggetto è stato creato (ovvero dentro Awake(): vedi anche ciclo di vita di un GameObject):

var force = 20.0;
var direzione = Vector3 (0,1,1);

function Awake(){
rigidbody.AddForce(direzione * force);
}

Il valore 20 rende il moto del proiettile visibile rispetto ad una massa fissata ad 1, se inserite altri valori dovrete calibrare per tentativi il resto di conseguenza. Inoltre ho introdotto un vettore direzione che spara, quindi, lungo (0,1,1) come è possibile vedere anche nel video:

Se poi ad esempio decidiamo di vincolare la direzione del movimento senza scomodare complesse formule matematiche, potrei congelare uno o più assi (freeze) e fare in modo che il movimento sia diretto verso l’alto (lungo l’asse y, tipo lancio di un missile).

Tratto da: unity3ditalia.blogspot.com, a cura di Salvatore Capolupo. Immagine di copertina tratta da: Source (WP:NFCC#4), Fair use, Link