Dans cette partie du tutoriel, nous développons les bases d'un simple jeu de tir spatial. Nous commençons avec un environnement 2D pour apprendre l'IA. Notre jeu utilisera le gameplay de base de défilement vers la droite, ce qui signifie notre vaisseau va vers la droite, tandis que les ennemis viennent de droite à gauche. Notre but est d'essayer de donner un peu de vie à nos vaisseaux ennemis.

Nous allons utiliser les principes de base de la trigonométrie, la programmation orientée objet (héritage, polymorphisme, ...) ainsi que un peu d' algèbre vectoriel. Si vous êtes familier avec ceux-ci, ce ne sera pas un problème, si vous ne l'êtes pas, ceux-ci sont rapidement expliqués dans cet article. C'est à vous d'aller chercher plus d'informations car nous ne pouvons pas répondre à tous ici ...

Voici une video qui montre ce que vous allez faire (en anglais).

• Création de notre vaisseau
• Bouger notre vaisseau
• Un vaisseau qui tire
• Donner des trajectoires avec un peu de trigonométrie
• Tourner en rond
• Rétrécir et grossir
• Forme elliptique
• Cache-cache (premier FSM)
• Vaisseau kamikaze
• Vaisseau qui peut voir (devant lui)

Création de notre vaisseau

Premièrement nous allons créer notre propre vaisseau. Ce n'est pas de l'IA vu que nous créons un code que le joueur utilise. La partie AI vient juste après. Donc, si vous avez téléchargé le projet, vous devez avoir un objet SpaceShip. Il a déjà tout ce qu'il faut et la plupart des informations que vous devez savoir sont écrites comme commentaires sur le script. (Cette partie viendra avec le projet, promis ca vient au plus vite!!!)

Maintenant, nous devons créer le NPC (Non-Player-Character) ou dans notre cas, Non-Player-Ship qui signifie le vaisseau que le joueur ne controle pas. Notre première tâche consiste à instancier un nombre aléatoire de vaisseaux à des emplacements aussi aléatoires. Dans le dossier SpawnObject est le script ci-dessous, il l'a déjà été ajouté à l'objet Spawn de la Hiérarchie. Vous pouvez simplement cocher sur.

using UnityEngine;
using System.Collections;

public class CreateRandom : MonoBehaviour {
    public GameObject ship;
    Transform _transform; 
    void Start () {
         _transform= GetComponent<Transform>();
         InvokeRepeating("CreateRandomShip",0.01f,2.0f);
    }

    void CreateRandomShip(){
        Vector3 vec= new Vector3(_transform.position.x,0,Random.Range (-1f,-9f));
        Instantiate(ship,vec,transform.rotation);
    }
}

Toute la magie se trouve dans  Vector3 vec  = new Vector3 (22,0, Random.Range (-1f,-9f)); Maintenant, qu'est-ce que cela fait? cela crée un vector3 avec x = 22 qui est juste devant notre écran de sorte que nos ennemis n'apparaissent pas soudainement au milieu de l'écran, y = 0 parce que nous sommes en 2D et y n'est pas utilisé ici. Enfin, nous utilisons un nombre aléatoire restreint dans un ordre de valeurs pour définir la valeur de z. C'est la commande qui est responsable de l'aspect désordonné de nos vaisseaux.

Notre projet a un objet Spawn qui est un simple objet vide. Attachez le script sur cette objet. La fonction CreateRandomShip est appelée avec InvokeRepeating toutes les 2 secondes.

Bouger notre vaisseau

Maintenant, pour la deuxième partie, la création des vaisseaux c'est bien, mais ils ont aussi besoin de se déplacer. C'est là que la programmation orientée objet entre en jeu. Nous sommes sur le point de déclarer une classe qui servira à représenter le comportement de base de nos vaisseaux. Si nous voulons des vaisseaux avec des action splus spécifiques, nous déclarons une nouvelle classe qui hérite de notre classe de base (aussi appelé classe parent). La classe dérivée (aussi appelée classe enfant) précisera quels sont les comportements qui doivent être modifiés et quels comportements doivent être utilisés en tant que tels.

Ci-dessous est notre class de base ennemi. Nous allons y revenir plus tard pour ajouter un peu plus d'actions de base. Ajoutez ceci à la prefab ennemi dans le panneau Projet.

using UnityEngine;
using System.Collections;

public class Enemy : MonoBehaviour {

	protected Vector3 velocity;
	public Transform _transform;
	public virtual void Start () {
                _transform = GetComponent<Transform>();
                velocity = new Vector3(Random.Range(0.5f,1.5f),0,0);
	}
        public virtual void Update(){
              _transform.Translate ( -velocity.x*Time.deltaTime,0,velocity.z*Time.deltaTime,Space.World);
        }

       void OnTriggerEnter(Collider other){
		if(other.gameObject.tag == "EnemyDeath")Destroy(gameObject);
	}
}

Cela sera notre classe de base. Toute classe ennemie héritera de celle-ci de sorte que tout membre que nous voulons  universel à tous les ennemis soit ajouté ici. C'est pourquoi la plupart des variables sont déclarées protégées (protected) ou public jusqu'à présent.

Notez que la plupart des fonctions sont déclarées virtual comme nous allons probablement les remplacer plus tard dans nos classes dérivées. Notez également que la fonction OnTriggerEnter n'est pas virtuelle. Nous voulons que tous les vaisseaux soient détruits en sortant de l'écran (il y a des ColliderBox de chaque côté de l'écran dans notre projet). Il s'agit d'un comportement commun à tous nos navires. Nous n'aurons pas à le réécrire plus tard.

velocity =new Vector3(Random.Range(0.5f,3.0f),0,0); encore nous utilisons une valeur aléatoire pour définir la vélocité (vitesse) de nos vaisseaux.

Nous avons maintenant un premier niveau tout simple. Vous pouvez y ajouter des astéroïdes de manière à avoir deux sortes d'ennemi.

Nos vaisseaux bougent mais nous voulons aussi qu'ils tirent

Nous pourrions aussi utiliser InvokeRepeating pour modifier le composant z de la vélocité de nos vaisseaux. Ainsi, ils n'iraient pas tout le temps vers la gauche directement mais parfois un peu vers le haut et parfois un peu vers le bas:

public virtual void Start(){
    InvokeRepeating("ChangeZ",2.0f,1.0f);
}
public virtual void Update(){
     _transform.Translate( -velocity.x*Time.deltaTime,0,
         velocity.z*Time.deltaTime,Space.World);
}

void ChangeZ(){
    velocity.z = Random.Range(-1.0f,1.0f);
}

Comme vous pouvez le constater, cela crée un beau bazar (pour rester poli) mais qui sait, cela peut être l'effet recherché.

Un vaisseau qui tire

Pusique  nos vaisseaux ont deux canons, nous sommes sur le point de leur donner la possibilité de "recharger" avant de tirer à nouveau. Eh bien, en fait, nous allons juste alterner les coups de feu entre les canons de gauche et de droite. Le vaissaue dispose de deux gameobjects vides (empty GameObject) comme enfants devant les canons que nous allons utiliser pour notre tir. Le code ci-dessous est ajouté à notre classe de base:

Transform _primaryShoot;
Transform _secondaryShoot;
bool side = true; 
public GameObject proj; 

protected void Shoot(){
    if(_primaryShoot){
        if(_secondaryShoot){
            if(side)
                Instantiate (proj,_primaryShoot.position,Quaternion.identity);
            else
                Instantiate (proj,_secondaryShoot.position,Quaternion.identity);
             side = !side;
        }else
             Instantiate (proj,_primaryShoot.position,Quaternion.identity);
   }
}
void OnCollisionEnter(Collision other){
      if(other.gameObject.tag == "Ship"){
           Destroy (gameObject);
           other.gameObject.SendMessage("DecreaseHealth",15);
      }
}

Jetez un coup d'œil à la fonction Shoot. La principe est  que les ennemis pourraient avoir un, deux ou aucune arme. On pourrait penser que s'il n'y a pas d'arme pourquoi essayer de tirer, vous n'êtes jamais sans erreur ... Vous pouvez effectivement ajouter une instruction else en fin qui lancerait  un avertissement du genre "Vous shootez mais cet objet n'a pas arme ". Sans la première vérification if, vous planter votre jeu.

Maintenant, nous devons ajouter notre première classe de base ennemi. Dans le dossier EnemyScript, trouver le BasicEnemy et ajouter le à la préfabriqué Enemy. Vous pouvez effectivement désactiver ou supprimer le composant Enemy. Puisque BasicEnemy est un enfant d' Enemy, Unity va automatiquement ajouter tous les membres publics et protégés de la classe parent:

using UnityEngine;
using System.Collections;

public class BasicEnemy : Enemy {

	public override void Start () {
		base.Start();
		_primaryShoot = transform.Find ("SpawnLeft").transform;
		_secondaryShoot = transform.Find ("SpawnRight").transform;	
               InvokeRepeating("Shoot",Random.Range(2.0f,4.0f),Random.Range(2.0f,4.0f));
	}

	public override void Update () {
		base.Update ();
	}
}

Nous surchargeons la fonction Start mais comme certains membres sont affectés dans la fonction Start parent nous l'appelons avec base.Start (); Ensuite, nous retrouvons nos deux armes et commençons à appeler la fonction Shoot. Vous pourriez vous demander pourquoi je n'appelle pas base.Shoot (), la fonction Shoot est protégée dans ma classe de base de sorte qu'elle est héritée. Vous  utilisez la base lorsque vous voulez utiliser un membre de la classe parente qui est redéfinie dans la classe dérivée.

Et voilà. Ils sont prêts à tirer, il vous suffit de glisser et déposer le préfabriqué ProjectileEnemy. Vous la trouverez dans le dossier Projectile sous ProjectileEnemy (c'est juste une sphère colorée). J'ai également ajouté une fonction de collision dans le cas où le joueur frappe levaisseau. Gardez à l'esprit que la mort est aussi une sorte de AI.

Si vous utilisez le projectile du projet, il a déjà le script associé avec ce code:

using UnityEngine;
using System.Collections;

public class ProjEnemy : MonoBehaviour {

	Transform _transform;
	void Start () {
		_transform = GetComponent<Transform>();
	}

	void Update () {
		_transform.Translate ( speed*Time.deltaTime,0,0,Space.World); 
	}
	void OnCollisionEnter(Collision other){
		if(other.gameObject.tag == "Ship"){
			other.gameObject.GetComponent<ShipControl>().DecreaseHealth(10);
			Destroy(gameObject);
		}
	}
	void OnTriggerEnter(Collider other){
		if(other.gameObject.tag == "EnemyDeath")Destroy(gameObject);
	}
}

Rien d'extravagant encore. La fonction de collision envoie un message au vaisseau pour réduire la vie. Notez que si vous décidez de créer des projetiles plus avancés, vous pouvez toujours hériter de ce projetile de base.

Donner des trajectoires avec un peu de trigonométrie

Prenons un second type de mouvement IA vraiment basique. Nous sommes maintenant sur ​​le point d'entrer dans le royaume des oscillations et des vagues. Ce que vous allez voir ici est simplement l'équation de base du principe de l'univers. Ouais, je sais, cela semble un peu trop insistant mais j'y suis pour rien c'est comme ça.

Donc, en utilisant des fonctions simples comme cosinus ou sinus, on peut facilement obtenir de jolies formes.

Nous allons déclarer une nouvelle classe et créer du mouvement pour notre vaisseau. Le code va simplement bouger notre vaisseau de haut en bas de manière oscillatoire.

using UnityEngine;
using System.Collections;

public class ShipOsc : Enemy {

    float amplitude = 2;
    float omega = 0.5f;
    float index;
    float zPos;

    public override void Start(){
        base.Start ();
        _transform.position = new Vector3(22f,0f,-5f);    
        _primaryShoot = transform.Find ("SpawnLeft").transform;
        _secondaryShoot = transform.Find ("SpawnRight").transform;
        zPos=_transform.position.z;
        InvokeRepeating("Shoot",Random.Range(2.0f,4.0f),Random.Range(2.0f,4.0f));
    }

    public override void Update(){
        index += Time.deltaTime;
        float zPos=amplitude*(Mathf.Cos(omega*index))*Time.deltaTime;
        _transform.Translate ( -velocity.x*Time.deltaTime,0,zPos,Space.World);
    }
}

Une explication rapide sur l'équation, Amplitude aura une incidence sur la taille de la vague, oméga influe sur la fréquence de l'onde, en quelque sorte la vitesse d'un sommet à l'autre, time is utilisé pour modifer la valeur. La phase correspond à la valeur en radians va décaler le point de départ de l'onde. Nous verrons un exemple plus tard.

Cette classe d'ennemi a aussi la possibilté de tirer.

L'image ci-dessous montre que la position est fonction du temps (time), si tous les vaisseaux ont la même valeur pour time, ils ont tous la même position. L'indice (index) est incrémenté à chaque nouveau vaisseau, chaque vaisseau a une valeur unique.

Et voilà!!! Nos vaisseaux semblent se suivre avec un joli mouvement.

Sur la première photo, la valeur donnée à Omega est plus grande que dans la deuxième image. En conséquence, la vague des vaisseaux est réduite. Si vous donnez une valeur inférieure à l'amplitude, la vague portera sur une plus petite distance du haut vers le bas. Il vous suffit de jouer avec l'amplitude et l'oméga pour avoir un premier aperçu sur les oscillations et les vagues. Cela n'est pas seulement utile pour faire bouger nos vaisseaux, mais il s'avère que cela gère de nombreuses lois de physiques.

Vous pourriez penser à aussi utiliser ce principe pour vos projectiles.  Vous avez l'outil pour le faire, maintenant c'est à vous.

Tourner en rond

Nous continuons à modifier nos fonctions trigonométriques et cette fois nous sommes sur le point de tourner autour d'un point. Ce que nous voulons réaliser, c'est un ensemble de vaisseaux placés en cercle autour d'un point et tournant autour alors que le point se déplace vers notre vaisseau du joueur. Mmm, pas sûr que ce soit bien clair, mais vous verrez ce n'est pas de la magie, juste des maths.

Nous avons besoin d'un nouveau script qui va prendre notre objet spawn et le déplacer le long de l'axe des x.

using UnityEngine;
using System.Collections;

public class CirclePattern : MonoBehaviour {

	void Update () {
		_transform.Translate ( -Time.deltaTime,0,0,Space.World);
	}
}

Ceci va sur l'objet Spawn pour le faire bouger

Nous devons maintenant déclarer une fonction qui va instancier et positionner nos vaisseaux autour de cet objet Spawn. Le fait est que nous voulons aussi pouvoir réutiliser cette fonction avec le moins de problème possible. Disons que nous voulons placer 10 vaisseuax, mais la prochaine fois nous voulons seulement 5 vaisseauxde sorte que ça casse un peu le modèle.

Nous devons maintenant penser en termes de cercle unité. Il s'agit d'un simple cercle de rayon 1 qui contient la valeur correspondante de cos et sin en radians tout autour.

using UnityEngine;
using System.Collections;

public class CirclePattern : MonoBehaviour {

	public GameObject ship;
	public int amount; //Give a value in the Inspector for how many ships
	void Start () {
		for(int i = 0 ;i< amount ;i++){
			//Créer un objet et le parenter à l'objet Spawn
                        GameObject obj = (GameObject) Instantiate (ship, transform.position, transform.rotation);	
			obj.transform.parent = transform;

                        PlaceShip (obj,i,amount);

                        // Obtenir l'angle entre le vaisseau et l'objet Spawn
                        // et l'utiliser comme shift
			CircleMove sc = obj.GetComponent<CircleMove>();
			float angle = Vector3.Angle(obj.transform.localPosition, transform.forward);
    		        Vector3 cross = Vector3.Cross(obj.transform.localPosition, transform.forward);
    		        if (cross.y < 0) angle = -angle;
			     sc.phase = angle * Mathf.Deg2Rad;
		}
	}

	void Update () {
		_transform.Translate ( -Time.deltaTime,0,0,Space.World);
	}

        // Avec l'index de notre objet récemment créé dans la boucle
        // On le divise par le nombre d'objet et on multiplie par 2PI (Cercle entier)
	void PlaceShip(GameObject obj, int i, int amount){
		float u = ((float)i / (float)(amount)) * (Mathf.PI*2);
		float x = (float)Mathf.Cos(u);
                float z = (float)Mathf.Sin(u);

		obj.transform.localPosition = new Vector3(x, 0,z)*2;
	}
}

Notez que nous devons ajouter un script CircleMove à notre vaisseau avec un membre appelé phase. Vous obtiendrez également quelques erreurs pour des variables que nous n'avons pas encore déclarées.

La fonction PlaceShip est simplement le principe de gâteau d'anniversaire. Combien de personnes nous avons et diviser le gâteau en parts égales.

Le vaisseau utilise le script suivant:

using UnityEngine;
using System.Collections;

public class CircleMove : Enemy {

    public float phase;
    public override void Start () {
        base.Start();
        _primaryShoot = transform.Find ("SpawnLeft").transform;
        _secondaryShoot = transform.Find ("SpawnRight").transform;    
        InvokeRepeating("Shoot",Random.Range(2.0f,4.0f),Random.Range(2.0f,4.0f));
    }

    public override void Update () {
        transform.localPosition= new Vector3(Mathf.Cos (Time.time+phase ),0,Mathf.Sin (Time.time+phase));
    }
}

Grâce à notre héritage, nous traitons uniquement le mouvement, et nos vaisseaux tirent toujours. Les vaisseaux sont déplacés dans localPosition parce que nous voulons qu'ils tournent autour de cet objet Spawn qui en quelque sorte est maintenant notre point d'origine. Grâce à la variable  phase, les vaisseaux sont uniformément placés autour du centre. Essayez de changer la quantité de navires et vous verrez que, tant que vous ne donnez pas une valeur trop grande, ça va.

Essayer de supprimer les deux variables phase dans l'Update et ils sont tous au même endroit. Supprimer une seule, ils sont alignés.

Vous pouvez également essayer de déclarer une seconde variable phase et l'utiliser comme ceci:

	public float phase;
	float phaseA;

	public override void Start () {
		phaseA =phase +30f;
	}

	public override void Update () {
		transform.localPosition= new Vector3(Mathf.Cos (Time.time+phaseA ),0,Mathf.Sin (Time.time+phase));
	}

Rétrécir et grossir

Nous voulons maintenant que nos vaisseaux tournent autour du centre mais aussi vont et viennent vers le centre.

	public override void Update () {
		transform.localPosition= new Vector3((Mathf.Cos (Time.time)+2)*Mathf.Cos (Time.time + phase),0,
			(Mathf.Cos (Time.time)+2)*Mathf.Sin (Time.time+phase));
	}

Rappelez-vous quand j'ai dit que cosin et sin interpolent et  sont contraints entre 1 et -1, je me sers de cette fonction ici. La distance entre les vaisseaux et le centre est en constante croissance et décroissance. Le+2 est utilisé pour donner une distance minimale avec le centre, pour que vous n'ayez pas tout le monde qui s'empile au milieu bien que ce soit peut être ce que vous voulez (encore une fois enlevez la variable pour voir ce qu'il se passe). Ce n'était pas trop dur, vous voyez.

Forme Elliptique

Viens notre dernière modification sur les fonctions trigonométriques, nous allons créer une ellipse ou en quelque sorte une forme similaire. Réfléchissons une seconde ce qu' est une ellipse. D'abord qu'est-ce qu'un cercle? Il s'agit d'une forme géométrique qui a chacun de ces points équidistants du centre. Une ellipse est alors basé sur une forme de cercle qui a certains points plus proches du centre que d'autres.

Donc, nous voulons obtenir certains points plus proches et d'autres plus loin, mais la différence de distance ne peut pas être brusque, ce qui pourrait déplacer les vaisseaux soudainement. Rappelez-vous encore que cos et sin interpolatent et sont constraints. Nous pouvons tout simplement appliquer cela à nos valeurs x et z de manière à avoir deux mouvements indépendants.

	public override void Update () {
		transform.localPosition= new Vector3((Mathf.Cos (Time.time+phase)+2)*Mathf.Cos (Time.time + phase),0,
			(Mathf.Cos (Time.time)+2)*Mathf.Sin (Time.time+phase));
	}

J'ai ajouté une variable et c'est tout. Notez que ce n'est pas une ellipse parfaite puisque l'équation de l'ellipse est différent, c'est juste elliptique.

Pour une véritable ellipse, c'est effectivement plus simple il vous suffit de donner des amplitudes différentes pour vos fonctions cosin et sin:

	void Update () {
		transform.localPosition= new Vector3(2*Mathf.Cos (Time.time + phase),0,
			3*Mathf.Sin (Time.time+phase));
	}

Comme je l'ai mentionné au début, le but est de vous montrer ce qui peut être fait pour donner vie à votre objet. Vous pouvez développer un space shooter et utiliser ces conseils comme ils sont.Vous pouvez également les utiliser dans un jeu d'horreur. Vous pourriez avoir un objet de jeu vide avec un AudioSource joint qui émet un bruit de "Booooooo". Avec un modèle elliptique autour du joueur, l'objet semble tourner autour avec un mouvement de va-et-vient. Avec un peu plus variables de peaufinage vous pouvez créer un effet audio déroutant.

Cache-cache (première FSM)

Nous voilà sur le point d'introduire un nouveau mot, Finite-State-Machine (FSM). Qu'est-ce qui se cache derrière ce mot fantaisiste? Simplement un ensemble d'action en fonction d'autres actions ou situations. Cela signifie que votre IA effectue une action après analyse de l'entourage et de son propre état.  Il y a un tutoriel avancé pour ce sujet ici, mais croyez-moi, il est avancé.

Pour notre petit vaisseau, nous allons créer un simple (ou une je sais pas) FSM où le vaisseau peut se cacher derrière un rocher pour se protéger et continuer son voyage. Avant de sauter dans le codage, il est toujours recommandé de prendre le temps de penser à votre script.

1. Levaisseau se déplace vers la gauche jusqu'à ce qu'il se fasse tirer dessus
2. Le vaisseau est attaqué et avance vers la couverture si la couverture n'est pas derrière lui
3. Le vaisseau attend un petit moment puis retourne à son voyage
4. Le vaisseau atteint l'autre extrémité ou est tué sur la route

Le graphique ci-dessous montre les états du FSM et l'arbre de décision (en anglais).

Vous devez d'abord ajouter un public int santé, à notre classe de base Enemy.cs.

Maintenant, la grande partie:

using UnityEngine;
using System.Collections;

public class ProtectScript :Enemy {

	Transform cover;
	Transform [] wayout = new Transform[2];
	public int way;
	enum State{Forward,Hiding,Moving};
        State Current;
	public bool hit;
	public override void Start () {
		base.Start ();
		health = 3;
		cover = GameObject.Find ("Cover").GetComponent<Transform>();
		GameObject[] obj = GameObject.FindGameObjectsWithTag("Wayout");
		for(int i = 0;i<obj.Length;i++)wayout[i] = obj[i].GetComponent<Transform>();
		way = -1;
		hit =false;
                Current = State.Forward
                _primaryShoot = _transform.Find ("SpawnLeft").GetComponent<Transform>();
		_secondaryShoot = _transform.Find ("SpawnRight").GetComponent<Transform>();
		InvokeRepeating("Shoot",0.01f,Random.Range(2.0f,4.0f));
	}

	public override void Update () {
		switch(Current){
			case State.Forward:
				_transform.Translate ( -velocity.x*Time.deltaTime,0,velocity.z*Time.deltaTime,Space.World);
				break;
			case State.Hiding: 
				ToTarget (_cover);
				if(Vector3.Distance (cover.position,_transform.position) <= 0.5f &&way<0 ) {		
					StartCoroutine(ChangeSwitch(Random.Range (1.0f,3.0f)));	
					way = Random.Range (0,2);
				}
                                break;
			case State.Moving:
				ToTarget (_wayout[way]);
				if(Vector3.Distance (wayout[way].position,_transform.position) < 0.2f) current = State.Forward;	
				break;
		}
	}

	IEnumerator ChangeSwitch(float time) {
		yield return new WaitForSeconds(time);
		Current = State.Moving;
	}

	public override void OnCollisionEnter(Collision other){
		if(other.gameObject.tag == "ProjectileShip"){
			Destroy(other.gameObject);
			health-=1;
			if(health<=0)Destroy(gameObject);
			if(Current ==State.Forward &&_transform.position.x >cover.position.x )
                             Current =State.Hiding;
		}
	}
	void ToTarget(Transform tr){
		Vector3 direction = tr.position - _transform.position;
		direction.Normalize();
		_transform.Translate ( direction.x*Time.deltaTime,0,direction.z*Time.deltaTime,Space.World);
	}
}

Vous devez ajouter le RockPrefab et le positionner correctement sur ​​le niveau. Assurez-vous que le rocher et les deux sorties de rochers sont à y = 0.

Nous utilisons une énumération pour définir l' état du vaisseau. Le bon point de l'énumération, c'est que vous ne pouvez pas attribuer une valeur erronée. L'utilisation d'un switch ou un if avec des integers ou string, pour certaines raisons, vous pourriez vous retrouver avec une mauvaise valeur. Cela ne peut pas arriver avec Enum car seules les valeurs déclarées peuvent être utilisés.

Dans l' Update, nous utilisons un switch avec l'état current. Si notre vaisseau est attaqué pour la première fois, nous changeons l'état de forward à hiding et le navire se dirige vers le rocher. Il y attend un temps aléatoire jusqu'à ce qu'un wayout soit choisi et l'état est changé en moving. Le vaisseau quitte sa couverture. Lorsque vous atteignez le wayout, Current est alors changé pour forward. Si le rocher est déjà passé alors que le vaisseau est attaqué, il ne changera pas sa trajectoire considérant qu'il ne peut revenir en arrière.

if(Current ==State.Forward &&_transform.position.x > cover.position.x )current =State.Hiding;

Cela assure que si la position est plus petite que la position de couverture (nous nous dirigeons vers la gauche et x est réduit) current ne peut plus être modifié.

ToTarget est appelée pour obtenir le nouveau vecteur pour faire avancer notre bateau.

Lancez le jeu, si vous ne faites rien, le navire fera son chemin vers la gauche. Si vous prenez assez tôt, sa direction va changer et les différents états seront utilisés. Tirez de nouveau après couverture, cela n'affectera pas plus.

Vaisseau kamikaze

Le comportement suivant est assez simple, nous voulons que le vaisseau se "suicide"  dans le nôtre. Mais nous allons ajouter un peu plus de chose. Nous ne voulons pas que le vaisseau revienne en arrière pour nous attaquer.

Comme nous voulons réutiliser la fonction ToTarget du paragraphe précédent, nous la bougeons dans un autre fichier pour pouvoir l'appeler n'importe où nous en avons besoin.

Le projet a un script GameManager qui contient déjà nos méthodes d'extension:

	public static void Target(this Transform _transform, Transform target){
		Vector3 direction = target.position - _transform.position;
		direction.Normalize();
		_transform.Translate ( direction.x*Time.deltaTime,0,direction.z*Time.deltaTime,Space.World);
	}

Nous créons un nouveau script que nous attachons à notre vaisseau:

using UnityEngine;
using System.Collections;

public class Banzai : Enemy {

	Transform target;
	public override void Start () {
		base.Start ();
		_primaryShoot = transform.Find ("SpawnLeft").GetComponent<Transform>();
		_secondaryShoot = transform.Find ("SpawnRight").GetComponent<Transform>();
		target = GameObject.FindGameObjectWithTag("Ship").GetComponent<Transform>();
	}

	public override void Update () {
		_transform.Target(_target);
	}
}

Si nous lançons le jeu, le vaisseau nous suivra constamment. Comme nous l'avons dit, nous voulons seulement être attaqué si le vaisseau ennemi est en face de nous.

	public override void Update () {
		if(_transform.position.x > _target.position.x)
			_transform.Target(_target);
		else 
			base.Update();
	}

Donc, si nous sommes sur la gauche de l'ennemi, nous utilisons notre méthode Target, autrement nous appelons le comportement de base de notre classe de base.

Vous pouvez facilement appliquer le même comportement au projectile ennemi, de sorte que le vaisseau et le projectile soient dirigées vers le vaisseau du joueur. Vous pouvez également l'utiliser uniquement sur ​​le projectile en utilisant l'un des comportements précédents. Encore plus! Que faire si vous essayez de créer un projectile oscillant!

N'oubliez pas que vous pourriez essayer de convertir les algorithmes que nous avons utilisés précédemment en méthodes d'extension, tout comme Target, de sorte que vous pouvez facilement les appeler sur n'importe quel objet.

Vaisseau qui peut voir (devant lui)

Enfin, dans notre dernière partie, nous allons revenir à notre premier algorithme qui  crée des vaisseaux à des positions aléatoires. Nous allons également supprimer notre rocher. Rappelez-vous, chaque navire reçoit une vitesse différente. En conséquence, certains vont aller plus vite que d' autres (Capitaine Evident pour vous servir). Cela signifie que certains d'entre eux vont se retrouver au-dessus des autres et on ne veut pas que cela se produise. Donc, nous allons donner des "yeux" à nos vaisseaux afin qu'ils puissent vérifier en face d'eux si quelque chose est là et modifier leur comportement en fonction de cela.

Le comportement que nous devons recréer est la ligne de vision. The image ci-dessous montre le principe de base. La flèche verte est la transform.forward, nous avons juste besoin de voir si quelque chose se trouve dans la zone de 45 degrés (ou autre) de ce vecteur dans une plage définie par le cercle bleu.

Pour parvenir à ce principe, il y a différentes façons. Celle que j'ai choisi utilise le moteur de physique fourni par Unity. Je vais donc ajouter une sphère de collision à ma préfab de l'ennemi et définir son rayon de 3. Vous obtiendrez un avertissement qu'une box collider est déjà attachée, juste cliquez sur Ajouter. Cliquez IsTrigger .

Maintenant, définissons un script simple:

using UnityEngine;
using System.Collections;

public class SeeFront : Enemy {

	float angle =45;
	public override void Start () {
		base.Start ();
	}

	public override void Update () {
		base.Update ();
	}

	void OnTriggerEnter(Collider other){
		if(other.gameObject.tag == "EnemyShip"){
			if(Vector3.Angle(other.gameObject.transform.position - _transform.position, transform.forward) <= angle){
				SeeFront sc = other.GetComponent<SeeFront>();
				velocity = sc.velocity;
			}
		}
	}
}

Tout ce que je fais est une régulation du trafic. Dans le cas où un vaisseau entre en collision avec un autre par l'arrière, il vérifie s'il existe un angle inférieur à 45 degrés, et si oui, il trouve la vitesse de l'autre vaisseau et l'applique à lui-même. Notez que je ne leur ai pas donné la possibilité de tirer mais vous devriez savoir comment le faire maintenant.

Ce principe pourrait également être utilisé dans un jeu de simulation de trafic comme SimCity ou GTA.

Conclusion

Nous avons atteint la fin de ce tutoriel. J'espère que vous avez appris quelques trucs que vous utiliserez dans votre propre jeu. Nous sommes passés par un peu de trigonométrie de base avec notre cercle unité et la façon d'utiliser ses fonctionnalités via sin et cos. Nous avons créé des formes et des cercles elliptiques fantaisistes. Nous avons vu un peu d'algèbre de vecteur de base comme la recherche de l'angle entre deux vecteurs ou la distance entre deux points. Nous sommes aussi allés à travers certaines caractéristiques de la POO de base comme l'héritage, override,  fonctions virtuelles, polymorphisme et autres.

Maintenant, c'est à vous de mélanger les différentes fonctionnalités que vous venez de voir et de créer des NPC qui accumulent de nombreux comportements. Gardez à l'esprit que l'IA devient rapidement cher sur le CPU. Vous pouvez vouloir soulager un peu avec InvokeRepeating afin que les calculs ne soient effectués que toutes les x secondes.

Dans l'ensemble, j'espère que cela vous a été utile.

Vous devriez lire cet article si:

• Vous voulez savoir comment sauvegarder des données de manières persistantes
• Vous devez stocker des données plus complexes que de simples données primitives

Introduction

Le stockage de données avec Unity est un peu de la science. Si vous souhaitez enregistrer des scènes entières, la position des joueurs etc alors la tâche peut être intimidante. J'ai construit le UnitySerializer qui rend ce processus beaucoup plus facile et les futurs tutoriels de cette série porteront sur une solution de sauvegarde complète. Ce tutoriel couvre quelques-unes des autres manières de stocker des données et de les faire passer entre les versions du jeu, par exemple à travers une connexion RPC ou d'un serveur.

Les bases

Ok, donc les bases. Si vous voulez un morceau de données qui doit être enregistré avec Unity, votre premier recours est probablement PlayerPrefs. PlayerPrefs vous permet de stocker des valeurs fondamentales de primitives avec une simple string. C'est souvent une bonne idée de choisir des noms  significatifs au cas où vous commencer à piétiner partout dans vos propres données plus tard!

//C# & US

PlayerPrefs.SetInt("Score", currentScore);
PlayerPrefs.SetInt("HighScore1", currentScore);
PlayerPrefs.SetString("HighScore1Name", currentPlayerName);

//Obtenir les valeurs

highScore1 = PlayerPrefs.GetInt("HighScore1");
highScore1Name = PlayerPrefs.GetString("HighScore1Name", "N/A"); //Valeur par defaut optionelle

Valeurs dans le jeu

Si vous souhaitez faire passer des données d'une scène vers une autre, la meilleure solution sera une classe statique:

//US

public static class PermanentVariables
{
    public var playing : boolean;
    public var playerName : String;
}

//C#

public static class PermanentVariables
{
    public static bool playing;
    public static string playerName = "";
}

et pour accéder:

PermanentVariables.playerName = "whydoidoit";

The downside with classes like this is that you can't set the variables using the Inspector - so if you want to use a combination of Inspector and code access you want to consider a DontDestroyOnLoadobject that is present in each scene or your starting  scene.   You could do that like this:

L'inconvénient avec les classes de ce genre est que vous ne pouvez pas définir les variables à l'aide de l'inspecteur - si vous souhaitez utiliser une combinaison d' Inspector et aussi l'accessibilité des codes, pensez à l'objet DontDestroyOnLoad  qui est présent dans chaque scène ou la scène de départ. Vous pouvez le faire comme ceci:

public class SharedBehaviour : MonoBehaviour {

	public static SharedBehaviour current;

	public Transform somePrefab;

	public int score;
	public string playerName;

	void Awake()
	{
		if(current != null && current != this)
		{
			Destroy(gameObject);
		}
		else
		{
			DontDestroyOnLoad(gameObject);
			current = this;
		}
	}

}

Ou avec US

	static var current : NameOfYourScript;

	var somePrefab : Transform;

	var score : int;
	var playerName : String;

	function Awake()
	{
		if(current != null && current != this)
		{
			Destroy(gameObject);
		}
		else
		{
			DontDestroyOnLoad(gameObject);
			current = this;
		}
	}

static assure que peu importe dans combien de scènes l'objet est utilisé (utile pour les tests), il n'y a qu' une copie en mémoire. Vous devez accéder à des variables comme ceci:

var x = SharedBehaviour.current.somePrefab;

Stocker des choses plus complexes

Ok so we had a look at a high score method using PlayerPrefs - what a total load of rubbish that was - having to know it was HighScore1Name - ugh. We'd be better off defining a high score table like this:

Ok, donc nous avons jeté un coup d’œil à une méthode high score utilisant PlayerPrefs - ce dégât quand il faut  savoir que la varible s'appelle HighScore1Name et pas autrement - mouaip. Nous ferions mieux de définir un tableau des hi-score comme ceci:

public class ScoreEntry
{
     public string name;
     public int score;
}

public List<ScoreEntry> highScores = new List<ScoreEntry>();

//Utilisation
highScores.Add(new ScoreEntry { name = currentPlayerName,score = score });

//Affichage
void OnGUI()
{
     foreach(var score in highScores)
     {
         GUILayout.Label(string.Format("{0} : {1:#,0}",
            score.name, score.score));
     }
}
class ScoreEntry
{
     var name : String;
     var score : int;
}

var highScores = new List.<ScoreEntry>();

//Utilisation
var entry = new ScoreEntry();
entry.name = currentPlayerName;
entry.score = score;
highScores.Add(entry);

//Affichage

function OnGUI()
{
     for(var score in highScores)
     {
         GUILayout.Label(String.Format("{0} : {1:#,0}",
            score.name, score.score));
     }
}

Mais comment pourrions-nous conserver cela dans PlayerPrefs - BinaryFormatter vient à la rescousse! Avec BinaryFormatter nous pouvons convertir n'importe quelle classe avec un constructeur sans paramètre dans un tableau d'octets et de là dans une string qui est adapté pour stocker dans PlayerPrefs. Il vous suffit d'inclure quelques namespaces et c'est tout:

// UnityScript
//Ces namespaces sont nécessaires
//pour BinaryFormatter
import System;
import System.Runtime.Serialization.Formatters.Binary;
import System.IO;

class ScoreEntry
{
     var name : String;
     var score : int;
}

//High score
var highScores = new List.<ScoreEntry>();

function SaveScores()
{
	//Nouveau BinaryFormatter
	var b = new BinaryFormatter();
	//Creation d'un MemoryStream
	var m = new MemoryStream();
	//Sauvegarde des scores
	b.Serialize(m, highScores);
	//Addition à PLayerPrefs
	PlayerPrefs.SetString("HighScores", Convert.ToBase64String(m.GetBuffer()));
}

function Start()
{
	//Trouver les données
	var data = PlayerPrefs.GetString("HighScores");
	//Si non-nul, charger
	if(!String.IsNullOrEmpty(data))
	{
		//Binary formatter pour le nouveau chargement
		var b = new BinaryFormatter();
		//Création d'un MemoryStrea, avec les données
	        var m = new MemoryStream(Convert.FromBase64String(data));
	        //Charger le nouveau score
	        highScores = b.Deserialize(m) as List.<ScoreEntry>;
         }
}

// C#
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using System.Collections;
//Ces namespaces sont nécessaires 
//pour BinaryFormatter
using System;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

public class HighScores : MonoBehaviour {

	//High score 
	public class ScoreEntry
	{
		//Nom du joueur
	     public string name;
		//Score
	     public int score;
	}

	//High score 
	public List<ScoreEntry> highScores = new List<ScoreEntry>();

	void SaveScores()
	{
		//Création d'un BinaryFormatter 
		var b = new BinaryFormatter();
		//Création d'un MemoryStream
		var m = new MemoryStream();
		//Sauvegarde des scores
		b.Serialize(m, highScores);
		//Addition à PlayerPrefs
		PlayerPrefs.SetString("HighScores", 
			Convert.ToBase64String(
				m.GetBuffer()
			)
		);
	}

	void Start()
	{
		//Obtenir les données
		var data = PlayerPrefs.GetString("HighScores");
		//Si non-nul, charger
		if(!string.IsNullOrEmpty(data))
		{
			//BinaryFormatter puis renvoyer les données
			var b = new BinaryFormatter();
			//Création d'un MemoryStream avec les données
			var m = new MemoryStream(Convert.FromBase64String(data));
			//Charger les nouveaux scores
			highScores = (List<ScoreEntry>)b.Deserialize(m);
		}
	}

}

Stocker des objets Unity

It can be tricky to store actual Unity objects so there's often a need to create a class that mirrors the data in a Unity object that you actually use for storage.  So for example if you wanted to pass a bunch of AnimationStates across an RPC call then you will need to create a class that represents the transmitted AnimationState.  The same is true for a bunch of other Unity objects, but the work is trivial.

il peut être difficile de stocker des objets Unity de sorte qu'il est souvent nécessaire de créer une classe qui reflète les données dans un objet Unity que vous utilisez réellement pour le stockage. Ainsi, par exemple, si vous vouliez passer un tas de AnimationStates à travers un appel RPC alors vous aurez besoin de créer une classe qui représente la AnimationState transmis. La même chose est vraie pour un tas d'objets Unity autres, mais le travail est trivial.

Envoyer Via RPC

Il apparaît donc clairement que le dernier code parvient à transformer une vieille classe en string, donc on peut utiliser le même principe pour envoyer n'importe quel type de paramètre via RPC!

	[RPC]
	void ReceiveHighScores(byte[] highScores)
	{
		var b = new BinaryFormatter();
		var m = new MemoryStream(highScores);
		var otherPlayersScores = (List<ScoreEntry>)b.Deserialize(m);
	}

	void UpdateScores()
	{
		var b = new BinaryFormatter();
		var m = new MemoryStream();
		b.Serialize(highScores, m);
		networkView.RPC("ReceiveHighScores", RPCMode.Others, m.GetBuffer());
	}

Parler à la toile

L' envoi de données vers des serveurs Web à l'aide WWWForm est facile, mais il peut être plus facile de convertir les données binaires dans une string comme nous l'avons vu avec Convert.ToBase64String () même si ce n'est pas nécessaire en fonction de la configuration de votre serveur.

Saving to a file

Sauvegarder un fichier est également facile, Unity fournit Application.persistentDataPath comme un emplacement pour vos fichiers et vous venez d'utiliser l'objet FileStream en place du MemoryStream.

void SaveScores()
	{
		//Créer un BinaryFormatter
		var b = new BinaryFormatter();
		//Créer un fichier
		var f = File.Create(Application.persistentDataPath + "/highscores.dat");
		//Sauvegarder les scores
		b.Serialize(f, highScores);
                f.Close();
	}

	void Start()
	{
		//Si non-nul, charger
		if(File.Exists(Application.persistentDataPath + "/highscores.dat"))
		{
			//BinaryFormatter pour charger les nouvelles données
			var b = new BinaryFormatter();
			//Créer le fichier
			var f = File.Open(Application.persistentDataPath + "/highscores.dat", FileMode.Open);
			//Charger les scores
			highScores = (List<ScoreEntry>)b.Deserialize(f);
			f.Close();
		}
	}

Conclusion

J'espère que vous avez appris quelques nouveaux trucs pour enregistrer les données et déplacez entre les différentes instances du même jeu, que ce soit en tant que valeur stockée ou via une connexion RPC.

N'oubliez pas que si vous souhaitez enregistrer des scènes complexes et des instances de prefab vous consulter Unity Serializer.

• Pourquoi les Quaternion sont utiles
• Faire que l'ennemi regarde le joueur avec réalisme
• Orienter du texte face à la caméra
• Combiner plusieurs Quaternions
• Orienter un billboard face à la caméra
• Ajouter des mouvements
• Plus de states

Le projet du tutoriel

Pourquoi les Quaternion sont utiles

Les quaternions sont utilisés pour décrire les rotations dans Unity, ils sont le format utilisé en interne plutôt que les matrices de transformation.

Il ya une confusion immédiate avec quaternions pour de nombreux utilisateurs - et cela est dû au fait que lorsque vous regardez un objet dans l'inspecteur, la rotation est représentée avec un Vector3 avec des rotations autour de X, Y et Z. Ce sont en fait les  eulerAngles de la rotation - et non le Quaternion lui-même. Cette confusion est aggravée par le fait que les quaternions ont des propriétés appelées x, y et z - mais ceux-ci n'ont rien à voir avec les valeurs spécifiées dans l'inspecteur (ou du moins très peu)!

Il ya plusieurs façons de faire un Quaternion - à partor d'un Vector3 d' angles, vous utilisez Quaternion.Euler soit avec les 3 axes de rotation comme paramètres ou comme un Vector3 décrivant la rotation. Pour faire une rotation qui regarde dans une direction, vous utilisez Quaternion.LookRotation (directionVector). Dans ce tutoriel, vous allez apprendre d'autres façons d'utiliser les quaternions et comment les combiner.

De nombreux débutants tombent dans le piège suivant:

transform.rotation = new Vector3(100,100,100);
transform.rotation = new Quaternion(100,100,100,1);

La première ligne renverra une erreur de conversion. La seconde passera le cap de la compilation mais pas celui de votre compréhension. Vous voulez que votre objet ait une rotation de (100,100,100) cependant dans l'inspecteur vous voyez des valeurs différentes. Pourtant vous avex passé (100,100,100,1) (c'est quoi ce 1...?). En fait vous n'avez pas donné une rotation mais plutôt un vecteur vers lequel l'objet regarde. Le 1 de fin est la quatrième dimension ou le domaine des nombres complexes/imaginaires. En simplifié, nous passons un vector3 cible que nous interpolons avec le 1 (cette valeur peut être 1 ou -1 mais apparait le plus souvent comme 1).

Résumé sur eulerAngles et Quaternions:

EulerAngles:

Avantages:

• Facile à comprendre et à visualiser puisqu'ils utilisent un vector 3D.
• Ils sont calculés plus rapidement du simple fait qu'ils ne contiennent que 3 valeurs (4 pour le Quaternion).

Inconvénients:

• Une rotation peut produire différent résultats. Différents logiciels utilisent des ordres différent (x,y,z) ou (y,x,z) ou autres. Le résultat est différent à chaque fois.
• l'effet Gimbal Lock. Quand une rotation s'aligne avec une autre, elles se bloquent ensemble et une dimension est perdue.

Quaternions:

Avantages:

• Evitent l'effet de Gimbal Lock
• La rotation est basée sur un vecteur cible et non un ensemble de rotations indépendantes.

Inconvénients:

• Ils sont légèrement plus lents que les eulerAngles du fait de la valeur en plus.
• Un humain normalement constitué ne peut les comprendre et les maitriser entièrement en une seule vie.

Vous pouvez combiner des rotations multiples en utilisant l'opérateur * (qui vous sera utile plus tard dans ce tutoriel) et vous pouvez également modifier un Vector3 en multipliant par un quaternion, cela renvoie une version tournée du vecteur. L'ordre de la manipulation Quaternion est significatif.

var newVector = Quaternion.AngleAxis(90, Vector3.up) * Quaternion.LookRotation(someDirection) * someVector;

EulerAngles sont faciles à représenter, mais sont beaucoup moins puissants que les Quaternions. Avec Unity, il est facile de se déplacer entre les deux représentations afin que vous puissiez choisir celle qui convient le mieux à chaque fois. Si vous restraindre les rotations, par exemple, vous pouvez trouver les eulerAngles d'un Quaternion, puis appliquez votre opération de restriction avec Mathf.Clamp puis tournez les angles de nouveau dans un quaternion en mettant à jour la variable eulerAngles ou en créant un nouveau Quaternion avec Quaternion.Euler (yourAngles).

Lorsque vous voulez combiner des rotations, comme une inclinaison de la tête et une rotation du corps, vous pouvez utiliser les deux approche, mais dès que les rotations ne sont plus autour de l'axes général (world axis), par exemple votre personnage peut aussi être penché en avant, alors vous préfèrerez les Quaternions. Il est très simple d'utiliser un Quaternion pour créer une simple rotation autour de chaque axe que vous souhaitez, puis les combiner.

Unity fournit également des axes très utiles transform.forward, transform.right et transform.up qui peuvent être utilisés en conjonction avec Quaternion.AngleAxis pour créer des rotations qui peuvent être appliquées en plus d'une rotation de l'objet existant.

transform.rotation = Quaternion.AngleAxis(degrees, transform.right) * transform.rotation;

Faire que l'ennemi regarde le joueur avec réalisme

Une chose bien commune que nous devons faire souvent est de faire quelque chose regarder dans une direction. Dans un jeu spatial en 3 dimensions où regarder sous tous les angles est possible, ce n'est pas un problème - mais lorsque les ennemis doivent se tenir debout sur le sol, les ennuis commencent.

La manière la plus évidente pour qu'un ennemi regarde dans une direction est d'utiliser Transform.LookAt (somePosition). Dans notre premier exemple, nous avons un joueur qui est une capsule avec une caméra attachée dessus, elle se déplace en utilisant l' Input de base pour les mouvement FPS.

Il ya quatre ennemis dans notre scène. Nos ennemis sont assez stupides dans cette première scène, ils vont juste pointer vers le joueur, en utilisant BasicLookAtPlayer.cs

using UnityEngine;
using System.Collections;

public class BasicLookAtPlayer : MonoBehaviour {
	void Update () {
		transform.LookAt(Camera.main.transform.position);
	}
}

Comme vous pouvez le voir, on utilise la commande LookAt pour pointer l'ennemi vers la caméra principale, dans notre cas le joueur. Malheureusement, cela a un inconvénient assez important lorsque le joueur ou l'ennemi sont à différentes hauteurs! L'ennemi peut se retrouver couché sur le dos d'une manière improbable ou tout simplement à regarder vers le bas...

Rotation sur l'axe-y seulement

Nous devons faire tourner l'ennemi seulement autour de l'axe Y de sorte qu'il regarde en direction du joueur, sans tourner autour des axes x et z qui le feraient pencher de façon improbable.

Heureusement, c'est assez simple à accomplir. Dasn cette scène, nous utilisons le script LookAtPlayerOnOneAxis.cs

using UnityEngine;
using System.Collections;

public class LookAtPlayerOnOneAxis : MonoBehaviour {

	void Update () {
		var newRotation = Quaternion.LookRotation(Camera.main.transform.position - transform.position).eulerAngles;
		newRotation.x = 0;
		newRotation.z = 0;
		transform.rotation = Quaternion.Euler(newRotation);
	}
}

Tout d'abord nous créons un nouveau Quaternion qui regarde depuis la position actuelle de l'ennemi vers la caméra principale (notre joueur). Quaternion.LookRotation prend une direction, que l'on peut obtenir facilement en faisant la soustraction de la position de la caméra moins la position de l'ennemi. Lorsque nous avons le Quaternion nous le changeons en une représentation de l'angle en Vector3 avec eulerAngles et nous le plaçons dans newRotation.

La rotation que nous avons créé est exactement la même que celle obtenue en utilisant la méthode LookAt dans la première scène.

Pour faire en sorte que cela ne soit qu'une rotation sur l'axe-y, nous avons simplement mis le x et z des éléments à 0 - puis nous changeons la valeur actualisée de nouveau en un Quaternion en utilisant Quaternion.Euler.

Faire la rotation en douceur

At the moment the enemies just snap to a rotation facing the player - that's not very realistic and will start to look strange when we start having them move around the scene.

Pour le moment, les ennemis se tournent brusquement vers le joueur - ce n'est pas très réaliste et ça peut sembler étrange quand nous commencerons à les déplacer autour de la scène.

 using UnityEngine;
using System.Collections;

public class SmoothLookAtPlayerOnOneAxis : MonoBehaviour {

	void Update () {
		var newRotation = Quaternion.LookRotation(Camera.main.transform.position - transform.position).eulerAngles;
		newRotation.x = 0;
		newRotation.z = 0;
		transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(newRotation), Time.deltaTime);
	}
}

Encore une fois nous faisons la rotation à l'aide de LookRotation et un angle de zéro sur les axes x et z. Ensuite, nous utilisons Slerp pour interpoler entre la rotation actuelle et la cible.

Slerp prend trois paramètres. Le premier (1) est la rotation de départ, le seconde (2) est la rotation cible et le troisième est un nombre compris entre 0 et 1 indiquant le ratio de translation entre 1 et 2 . Une valeur de 0 ne change rien, une valeur de 1 termine la rotation  et une valeur de 0,5 reviendra à mi-chemin entre les deux.

Dans notre cas, nous voulons mettre à jour la rotation potentiel à chaque iframe, nous n'avons donc pas vraiment une bonne valeur de départ et de fin et une quantité connue de temps entre les deux. Pour atteindre notre objectif et faire que la rotation semble lisse, nous prenons la rotation actuelle et la mettons à jour pour se rapprocher de la rotation finale par un ratio à chaque frame. Pour ce faire, nous avons mis le troisième paramètre à Time.deltaTime.

L'effet de ceci est que le personnage va se mettre à tourner plus rapidement, puisque le ratio de départ représente une plus grande valeur - utiliser Time.deltaTime signifie que nous bougeons n% vers la rotation cible à chaque frame (où n% serait de 10% si Time.deltaTime était de 0,1 s). Le frame suivant, nous commençons plus près de la rotation cible (en supposant que le joueur ne soit pas en mouvement) et nous déplaços n% de la différence. Alors que nous approchons de la rotation cible notre vitesse de rotation va ralentir et nous donner une attrayante rotation en ralentissement.

Rotation en douceur avec une vitesse maximum

The problem of our last example is that  should the rotations be very different the character may start rotating very quickly, perhaps unrealistically.  We probably want a way of making a smooth rotation that is limited to a maximum number of degrees per second.

Le problème de notre dernier exemple est que, si les rotations sont très différentes, le personnage peut se mettre à tourner très rapidement, peut-être de manière irréaliste. Nous avons probablement besoin d'un moyen de créer une rotation en douceur qui est limiteé à un nombre maximum de degrés par seconde.

Dans la quatrième scène nous utilisons le script RotateToPlayerWithAMaximumSpeed.cs

using UnityEngine;
using System.Collections;

public class RotateToPlayerWithAMaximumSpeed : MonoBehaviour {

	public float maximumRotateSpeed = 40;
	public float minimumTimeToReachTarget = 0.5f;
	Transform _transform;
	Transform _cameraTransform;
	float _velocity;

	void Start(){
		_transform = transform;
		_cameraTransform = Camera.main.transform;
	}

	void Update () {
		var newRotation = Quaternion.LookRotation(_cameraTransform.position - _transform.position).eulerAngles;
		var angles = _transform.rotation.eulerAngles;
		_transform.rotation = Quaternion.Euler(angles.x, Mathf.SmoothDampAngle(angles.y, newRotation.y, ref _velocity, minimumTimeToReachTarget, maximumRotateSpeed),
			angles.z);
	}
}

A partir de cet exemple, nous allons commencer à faire une incursion dans le monde de l'optimisation. Nous allons donc cacher nos Transforms pour la caméra et l'enemi.

Donc, pour effectuer notre rotation avec une vitesse maximum nous appelons Mathf.SmoothDampAngle - cette fois nous allons également combiner les eulerAngles existants de la rotation avec une nouvelle valeur pour la rotation Y. Les fonctions SmoothDampXXXX (disponible sur Vector3 et Mathf) prennent une vitesse actuelle, une vitesse maximale et un temps prévu pour compléter le mouvement. La vitesse actuellet est seulement utilisée par la routine et nous devons fournir un float pour le contenir - nous ne l'assignons pas nous-mêmes.

Mathf.SmoothDampAngle(angles.y, newRotation.y, ref _velocity, minimumTimeToReachTarget, maximumRotateSpeed)

maximumRotateSpeed needs little explaining, but minimumTimeToReachTarget allows us to have a slower smoothed start and finish to our rotation.  When set to 0 the rotation will complete as fast as possible without exceeding the maximumSpeed, a larger value indicates that we are happy that the rotation be slower so that it will complete closing the continually updated rotation distance in the ideal time.  The practical upshot of that is that rotations will smoothly slow down as the target value is approached.

maximumRotateSpeed est assez clair cependant minimumTimeToReachTarget nous permet d'avoir un rythme plus lent et plus lissée en début et en fin de rotation. Lorsqu'elle est réglée sur 0, la rotation est complétée aussi vite que possible sans dépasser le maximumSpeed, une valeur plus élevée indique que nous voulons que la rotation soit plus lente afin qu'elle achève de fermer la distance de rotation continuellement mis à jour en temps idéal. La conséquence pratique en est que les rotations ralentissent en douceur quand la valeur cible est approchée.

	void Update () {
		var newRotation = Quaternion.LookRotation(_cameraTransform.position - _transform.position).eulerAngles;
		var angles = _transform.rotation.eulerAngles;
		_transform.rotation = Quaternion.Euler(angles.x, Mathf.SmoothDampAngle(angles.y, newRotation.y, ref _velocity, minimumTimeToReachTarget, maximumRotateSpeed),
			angles.z);
	}

L'Update fonctionne sur notre rotation cible, prend la rotation actuelle de l'ennemi et remplace l'axe de rotation Y avec le SmoothDampAngle pour faire tourner l'ennemi vers notre joueur. Un effet très utile.

Orienter du texte face à la caméra

Nos ennemis sont assez ennuyeux et nous allons vouloir leur donner un peu d' IA. La première chose que nous allons faire est de les faire dormir jusqu'à ce que le joueur soit proche d'eux - nous voulons indiquer leur sommeil avec un signe de ronflement Zzzzz sau-dessus d'eux quand ils sont dans cet état.

Nous allons commencer par ajouter le commencement d'un Finite State Machine à chacun des enemis. Cela se trouve dans MovementStateMachine.

using UnityEngine;
using System.Collections;

public class MovementStateMachine : MonoBehaviour {

	public bool sleeping = true;
	public Transform sleepingPrefab;

	IEnumerator Start () {
		var t = transform;
		while(true){
			yield return new WaitForSeconds(Random.value * 3f + 2);
			if(sleeping)	{
				Instantiate(sleepingPrefab, t.position + Vector3.up * 3f, t.rotation);
			}
		}
	}
}

Nous avons un state machine très simple qui dit endormi ou non. Pas grand chose se passe quand il se réveille cependant. Et en fait il n'y a toujours rien pour le réveiller dans notre code. Mais cela suffit pour démontrer comment faire tourner un objet pour qu'il soit en face de la caméra

Quand le script se lance, il rentre dans une coroutine qui va créer une prefab au-dessus de la tête de l'enemi si le script est endormi à ce moment.

using UnityEngine;
using System.Collections;

public class GentleRiseAndDestroy : MonoBehaviour {

	public float timeToLive = 2f;
	Transform _transform;

	void Start () {
		_transform = transform;
		Destroy(gameObject, timeToLive);
	}

	void Update () {
		_transform.position += Vector3.up * Time.deltaTime;
	}
}

Le script détruit l'objet au bout de quelques secondes, et fait l'objet s'élever lentement à chaque frame.

When you get close to the enemies you see that there is another problem, the Zzzzzz aren't pointing outwards from the screen.  A lot of people are confused by this (I know I was) - we have a script that says LookAt the camera - why isn't it looking at it?

Lorsque vous vous approchez des ennemis vous voyez qu'il y a un problème, les Zzzzzz ne sont pas orientés vers l'extérieur de l'écran. Beaucoup de gens sont confus par cela (je l'étais) - nous avons un script qui dit LookAt (regarde) la caméra - pourquoi est-ce que cela ne regarde pas la caméra?

Modifier des vecteurs de Transform

Le problème avec LookAt, c'est que cela regarde vers l'emplacement de la caméra. Mais la caméra est située en un point fixe dans le monde, tandis que l'image qu'elle projette représente les choses vues sur son plan focal. Les objets regardent vers un seul point et, selon l'endroit où ils sont, ce n'est pas par rapport à l'emplacement où ils sont rendus à l'écran par la caméra.

Il y a une astuce pour ce faire, mais elle n'est pas conseillé dans de nombreux cas et nous allons voir une autre façon dans la section suivante. Vous savez probablement que transform.forward représente la direction vers l'avant d'un objet de la même manière que Vector3.forward représente l'avant en coordonnées du monde. Ce que beaucoup de gens ne savent pas, c'est que vous pouvez également définir transform.forward et il va faire pivoter l'objet!

Ce que nous voulons, c'est notre TextMesh de pointer vers le plan focal de la caméra, et non y regarder. En fait, nous voulons que l'object adopte le forward de la caméra.

using UnityEngine;
using System.Collections;

public class ReversedCameraDirection : MonoBehaviour {

	Transform _transform;
	Transform _cameraTransform;

	void Start () {
		_transform = transform;
		_cameraTransform = Camera.main.transform;
	}

	void Update () {
		_transform.forward = _cameraTransform.forward;
	}
}

Nous ajoutons ce script ReverseCameraDirection à la prefab Zzzzz Sleeping Text en place du script BasicLookAtPlayer et c'est parti.

Combiner plusieurs Quaternions

So our Zzzzzz themselves aren't very interesting and they could give us an opportunity to demonstrate how we can use Quaternion combinations.  Let's have the Zzzzzz slowly rotate as they drift upwards - what I mean is, have them face the camera but spin slowly around on the plane of the screen.

Donc, notre Zzzzzz  ne sont pas très intéressants et ils pourraient nous donner l'occasion de montrer comment on peut utiliser des combinaisons de quaternions. Nous allons faire que nos Zzzzzz tournent lentement pendant qu' ils dérivent vers le haut - ce que je veux dire, c'est les avoir face à la caméra, mais tournant lentement autour du plan de l'écran.

Pour faire cette rotation, nous créons un nouveau script SpinAroundForward.

using UnityEngine;
using System.Collections;

public class SpinAroundForward : MonoBehaviour {

	Transform _transform;
	float _rotatingFactor;

	void Start(){
		_transform = transform;
		_rotatingFactor = 0.2f + (Random.value * 0.8f);
	}

	void Update () {
		_transform.rotation = _transform.rotation * Quaternion.AngleAxis(Time.deltaTime * 20 * _rotatingFactor, Vector3.forward); 
	}
}

Ce script crée un facteur de rotation au hasard dans la fonction Start et l'applique dans la fonction Update.

Vous pouvez voir comment nous combinons la rotation actuelle de l'objet avec une rotation autour de Vector3.forward. Quaternion.AngleAxis crée un quaternion qui est un nombre de degrés de rotation autour d'un axe donné. Nous utilisons l'opérateur * pour le combiner avec la rotation actuelle du Zzzzzz.

Maintenant, si vous exécutez ceci dans la scène tutoriel, vous verrez que le texte tourne, mais ne fait pas face à la caméra. Il y a une bonne raison à cela: notre script ReverseCameraDirection est désactivé! Si vous cliquez sur Sleeping Text 3 et activez le script ReverseCameraDirection vous verrez alors que le  Zzzzzz fait face à la caméra, mais ne tourne pas. Voici l'un des pièges de la définition d'un vecteur de transform directement - il mélange vos combinaisons de rotation. Nous avons besoin d'une approche différente si nous voulons atteindre notre objectif.

En Scene 8 on remplace ReverseCameraDirection avec une version Quaternion de AdjustForwardToPointToCamera.

using UnityEngine;
using System.Collections;

public class AdjustForwardToPointToCamera : MonoBehaviour {

	Transform _transform;
	Transform _cameraTransform;

	void Start () {
		_transform = transform;
		_cameraTransform = Camera.main.transform;
	}

	void Update () {
		_transform.rotation = Quaternion.FromToRotation(_transform.forward, _cameraTransform.forward) * _transform.rotation;
	}
}

Quaternion.FromToRotation est très puissant quand vous avez des vecteurs qui ont besoin de réglage! Elle peut être utilisée pour faire pivoter un objet vers la surface de la chose sur lequel il repose  en réglant le vecteur up  de l'objet pour être la normale de la surface, par exemple. Dans notre cas, nous allons l'utiliser pour faire tourner la transform.forward de notre Zzzzzz pour être le même que transform.forward de la caméra.

Nous combinons le Quaternion que nous avons créé à partir du forward en rotation vers l'angle correct avec la rotation actuelle (qui est également modifiée par notre script SpinAroundForward) et c'est tout, nous avons une caméra en face, en rotation, Zzzzzz. (Qui aurait cru cela!)

Faire tourner un plan pour faire face à la caméra

Ok, donc nous avons convenablement réglé nos TextMeshes face à la caméra - maintenant nous allons nous occuper des plans. Un plan créé avec Unity est un bon endroit pour mettre une texture 2D et la montrer au joueur. Faisons un plan 2D billboard qui fait toujours face à l'écran.

Pour nous donner une raison de faire cela, nous allons donner à nos ennemis une "humeur". Fondamentalement, ils vont commencer avec un niveau de bonheur et progressivement plus malheureux au fil du temps. Dans un jeu, nous pourrions trouver beaucoup d'autres raisons pour lesquelles cela pourrait être intéressant.

Le joueur va être capable de voir l'état d'esprit des ennemis quand ils regardent droit sur eux. Nous allons afficher une émoticônes qui  lorsque le joueur regarde directement vers eux - la couleur du smiley sera également une description plus précise de l'état d'esprit, vert, heureux er rouge, en colère.

Cela va introduire quelques scripts.

D'abord nous allons réfléchir à la façon de «regarder directement" un ennemi. Nous devons attacher un script au joueur qui permettra de tester ce qui est juste en face de lui.

using UnityEngine;
using System.Collections;

public class LookTrigger : MonoBehaviour {

	Transform _transform;

	void Start () {
		_transform = transform;
	}

	void Update () {
		RaycastHit hit;
		if(Physics.SphereCast(_transform.position + _transform.forward * 0.5f, 3f, _transform.forward, out hit, 400)){
			hit.collider.SendMessage("LookedAt", SendMessageOptions.DontRequireReceiver);
		}
	}
}

Nous envoyons un SphereCast à partir du joueur et, si elle heurte quelque chose, nous envoyons à l'objet touché un message indiquant qu'il a été "LookedAt".

Ok, donc ça a été facile - maintenant nous avons besoin de l'ennemi pour avoir son humeur. Nous avons un nouveau script appelé EnemyMood.

using UnityEngine;
using System.Collections;

public class EnemyMood : MonoBehaviour {

	public MoodIndicator moodIndicatorPrefab;
	public float _mood;

	Transform _transform;
	MoodIndicator _currentIndicator;

	void Start () {
		_transform = transform;
		mood = Random.Range(30,99);
	}

	void Update () {
		mood -= Time.deltaTime/2;
	}

	void LookedAt(){
		if(_currentIndicator)
			return;

		_currentIndicator = Instantiate(moodIndicatorPrefab, _transform.position + Vector3.up * 3.5f,
			Quaternion.identity) as MoodIndicator;

		_currentIndicator.enemy = this;
	}
}

using UnityEngine;
using System.Collections;

public class MoodIndicator : MonoBehaviour {

	public Texture2D[] moodIndicators;
	public Color happyColor = Color.green;
	public Color angryColor = Color.red;
	public float fadeTime = 4f;
	public EnemyMood enemy;

	Transform _transform;
	Transform _cameraTransform;
	Material _material;
	Color _color;
	Quaternion _pointUpAtForward;

	void Start () {
		_pointUpAtForward = Quaternion.FromToRotation(Vector3.up, Vector3.forward);

		_material = renderer.material;

		//Définit le graphique
		_material.mainTexture = moodIndicators[
			Mathf.Clamp(
				Mathf.RoundToInt( enemy.mood/(100/moodIndicators.Length)),
				0,
				moodIndicators.Length-1)
			];

		//Calcule la couleur
		var moodRatio = enemy.mood/100;
		_material.color = _color = new Color(
			angryColor.r * (1 - moodRatio) + happyColor.r * moodRatio,
			angryColor.g * (1 - moodRatio) + happyColor.g * moodRatio,
			angryColor.b * (1 - moodRatio) + happyColor.b * moodRatio
		);

		Update();
	}

	void Awake(){
		_transform = transform;
		_cameraTransform = Camera.main.transform;
	}

	public void Update () {

		//Pointe le plan vers la caméra
		_transform.rotation = Quaternion.LookRotation(-_cameraTransform.forward, Vector3.up)
			* _pointUpAtForward;

		//Le graphique disparait
		_color.a -= Time.deltaTime/fadeTime;
		_material.color = _color;
	}
}

C'est notre premier vrai script alors nous allons le démanteler.

	public Texture2D[] moodIndicators;
	public Color happyColor = Color.green;
	public Color angryColor = Color.red;
	public float fadeTime = 4f;
	public EnemyMood enemy;

Nos variables publiques sont dans un tableau des images pour les utiliser comme indicateurs de l'humeur - ce sont des smileys pour triste, heureux, etc Il y en a 4 dans l'exemple. Nous disposons d'une couleur heureuse et une couleur en colère, alors nous voulons faire disparaître l'indicateur au fil du temps, nous avons donc une variable qui contient le nombre de secondes avant que le plan tout entier deviennent transparent. Enfin, nous avons l'ennemi qui contient cet indicateur. Tous ces éléments seront définis quand nous arrivons à la fonction Start.

	void Start () {
		_pointUpAtForward = Quaternion.FromToRotation(Vector3.up, Vector3.forward);

		_material = renderer.material;

		_material.mainTexture = moodIndicators[
			Mathf.Clamp(
				Mathf.RoundToInt( enemy.mood/(100/moodIndicators.Length)),
				0,
				moodIndicators.Length-1)
			];

		var moodRatio = enemy.mood/100;
		_material.color = _color = new Color(
			angryColor.r * (1 - moodRatio) + happyColor.r * moodRatio,
			angryColor.g * (1 - moodRatio) + happyColor.g * moodRatio,
			angryColor.b * (1 - moodRatio) + happyColor.b * moodRatio
		);

		Update();
	}

La première chose à faire est de créer un quaternion en cache qui permet de transformer un objet pour que son vecteur up pointe vers son vecteur forward. Rappelez-vous c'es ce que nous devions faire pour faire face à la caméra.

Ensuite, nous sélectionnons une texture qui représente l'état d'esprit en divisant l'humeur actuelle (un nombre entre 0 et 98) par un facteur qui sera mis dans la gamme de textures que nous avons fournis - nous restraignons les valeurs pour nous assurer de toujours obtenir une texture valide .

Ensuite, nous décidons d'une couleur pour le smiley en utilisant une proportion de colère et heureux selon l'humeur.

Enfin, nous appelons Update pour que le code de rotation soit appelé immédiatement.

La fonction Update se présente comme suit:

public void Update () {
		//Pointer le plan vers la caméra
		_transform.rotation = Quaternion.LookRotation(-_cameraTransform.forward, Vector3.up)
			* _pointUpAtForward;

		//Le graphique disparait
		_color.a -= Time.deltaTime/fadeTime;
		_material.color = _color;
	}

D'abord nous travaillons sur la rotation qui pointe vers la normal de l'objet vers la caméra en utilisant la fonction Quaternion.LookRotation, en passant le transform.forward de la caméra, puis nous combinons cela avec notre rotation en cache qui pointe le up de l'objet vers le forward . Notre plan est maintenant correctement aligné.

La deuxième partie de la routine  estompe l'alpha de l'image dans le temps.

C'est tout - si vous essayez, vous verrez les indicateurs surgissent lorsque vous centrez l'ennemi à l'écran. Ils se fâchent rapidement!

Ajouter des mouvements

Ok so it's time for our enemies to go and attack the player.  We are going to use Quaternions again, to set the target position of the enemy to be a different rotation around the player in an attempt to have them sneak up, and space out when attacking.  That at the moment is in the future - let's have a look at our new MovementStateMachine3.  Warning - it's grown up a bit!

Ok, donc il est temps pour nos ennemis d' attaquer le joueur. Nous allons utiliser les Quaternions à nouveau, pour faire en sorte que la position cible de l'ennemi soit une rotation différente autour du joueur  dans le but de les voir se faufiler et s'espacer quand ils attaquent. C'est pour le moment une futur action - nous allons jeter un oeil à notre nouveau MovementStateMachine3. Attention - il a un peu grandi!

MovementStateMachine3.cs

using UnityEngine;
using System.Collections;

public class MovementStateMachine3 : MonoBehaviour {

	public bool sleeping = true;
	public Transform sleepingPrefab;
	public float attackDistance = 5;
	public float sleepDistance = 30;
	public float speed = 2;
	public float health = 20;
	public float maximumAttackEffectRange = 1f;

	Transform _transform;
	Transform _player;
	public Transform target;

	public EnemyMood _mood;

	CharacterController _controller;
	AnimationState _attack;
	AnimationState _die;
	AnimationState _hit;
	Animation _animation;

	float _attackDistanceSquared;
	float _sleepDistanceSquared;
	float _attackRotation;
	float _maximumAttackEffectRangeSquared;
	float _angleToTarget;

	bool _busy;

	// Initialisation
	IEnumerator Start () {
		_transform = transform;
		_player = Camera.main.transform;

		_mood = GetComponent<EnemyMood>();

		_attackDistanceSquared = attackDistance * attackDistance;
		_sleepDistanceSquared = sleepDistance * sleepDistance;
		_maximumAttackEffectRangeSquared = maximumAttackEffectRange * maximumAttackEffectRange;

		_controller = GetComponent<CharacterController>();

		_animation = animation;
		_attack = _animation["attack"];
		_hit = _animation["gothit"];
		_die = _animation["die"];

		_attack.layer = 5;
		_hit.layer = 5;
		_die.layer = 5;

		_controller.Move(new Vector3(0,-20,0));

		while(true){
			yield return new WaitForSeconds(Random.value * 6f + 3);
			if(sleeping)	{
				var newPrefab = Instantiate(sleepingPrefab, _transform.position + Vector3.up * 3f, Quaternion.identity) as Transform;
				newPrefab.forward = Camera.main.transform.forward;
			}
		}
	}

	void Update(){
		//Verifie si quelque chose d'autre controle 
		if(_busy)
			return;

		if(sleeping){
			if((_transform.position - _player.position).sqrMagnitude < _attackDistanceSquared){
				sleeping = false;
				target = _player;
				//Where this enemy wants to stand to attack
				_attackRotation = Random.Range(60,310);
			}
		}else{
			//Si la cible est morte alors retourne en mode sleeping
			if(!target){
				sleeping = true;
				return;
			}

			var difference = (target.position - _transform.position);
			difference.y /= 6;
			var distanceSquared = difference.sqrMagnitude;

			//Trop loin, on oublie...
			if( distanceSquared > _sleepDistanceSquared){
				sleeping = true;
			}
			//Assez proche pour une attaque
			else if( distanceSquared < _maximumAttackEffectRangeSquared && _angleToTarget < 40f){
				StartCoroutine(Attack(target));
			}
			//Autrement, c'est le moment de se bouger
			else{
				//Décider la position cible
				var targetPosition = target.position + (Quaternion.AngleAxis(_attackRotation, Vector3.up) * target.forward * maximumAttackEffectRange * 0.8f);
				var basicMovement = (targetPosition - _transform.position).normalized * speed * Time.deltaTime;
				basicMovement.y = 0;
				//Mouvement seulement si en face
				_angleToTarget = Vector3.Angle(basicMovement, _transform.forward);
				if( _angleToTarget < 70f)
				{
					basicMovement.y = -20 * Time.deltaTime;
					_controller.Move(basicMovement);
				}
			}
		}
	}

	void OnTriggerEnter(Collider hit) {
		if(hit.transform == _transform)
			return;

		if(hit.transform == _player){
			StartCoroutine(Attack(_player));
		}else{
			var rival = hit.transform.GetComponent<EnemyMood>();
			if(rival){
				if(Random.value > _mood.mood/100)
					StartCoroutine("Attack",rival.transform);
			}
		}
	}

	IEnumerator Attack(Transform victim){
		sleeping = false;
		_busy = true;
		target = victim;
		_attack.enabled = true;
		_attack.time = 0;
		_attack.weight = 1;
		//Attendre la moitié de l'animation
		yield return StartCoroutine(WaitForAnimation(_attack, 0.5f));
		/Verifier si toujours proche
		if(victim && (victim.position - _transform.position).sqrMagnitude < _maximumAttackEffectRangeSquared){
			//Appliquer les dommages
			victim.SendMessage("TakeDamage", 1 + Random.value * 5, SendMessageOptions.DontRequireReceiver);
		}
		//Attendre la fin de l'animation
		yield return StartCoroutine(WaitForAnimation(_attack, 1f));
		_attack.weight = 0;
		_busy = false;
	}

	void TakeDamage(float amount){
		StopCoroutine("Attack");
		health -= amount;
		if(health < 0)
			StartCoroutine(Die());
		else
			StartCoroutine(Hit());
	}

	IEnumerator Die(){
		_busy = true;
		_animation.Stop();
		yield return StartCoroutine(PlayAnimation(_die));
		Destroy(gameObject);
	}

	IEnumerator Hit(){
		_busy = true;
		_animation.Stop();
		yield return StartCoroutine(PlayAnimation(_hit));
		_busy = false;
	}

	public static IEnumerator WaitForAnimation(AnimationState state, float ratio){
		state.wrapMode = WrapMode.ClampForever;
		state.enabled = true;
		state.speed = state.speed == 0 ? 1 : state.speed;
		while(state.normalizedTime < ratio-float.Epsilon){
			yield return null;
		}
	}

	public static IEnumerator PlayAnimation(AnimationState state){
		state.time = 0;
		state.weight = 1;
		state.speed = 1;
		state.enabled = true;
		var wait = WaitForAnimation(state, 1f);
		while(wait.MoveNext())
			yield return null;
		state.weight = 0;
	}
}

       _mood = GetComponent<EnemyMood>();

		_attackDistanceSquared = attackDistance * attackDistance;
		_sleepDistanceSquared = sleepDistance * sleepDistance;
		_maximumAttackEffectRangeSquared = maximumAttackEffectRange * maximumAttackEffectRange;

		_controller = GetComponent<CharacterController>();

		_animation = animation;
		_attack = _animation["attack"];
		_hit = _animation["gothit"];
		_die = _animation["die"];

		_attack.layer = 5;
		_hit.layer = 5;
		_die.layer = 5;

Il est clair que nous faisons un tas de cache pour des raisons de performance - aussi toutes les distances sont au carré. Ainsi, nous pouvons éviter des racines carrées lorsque nous vérifions les distances.

On place plusieurs des animations sur un layer de haut niveau de sorte qu'elles remplacent l'animation par defaut (idle).

Donc la fonction Update est assez grande - elle commence comme ceci:.

                //Verifie si quelque chose d'autre controle 
		if(_busy)
			return;

Pour attaquer et d'être touché, nous allons permettre à quelque chose d'autre de contrôler le personnage - quand cela arrive _busy sera vrai et l'Update sera ignoré.

                if(sleeping){
			if((_transform.position - _player.position).sqrMagnitude < _attackDistanceSquared){
				sleeping = false;
				target = _player;
				//Où l'ennemi veut se placer pour attaquer
				_attackRotation = Random.Range(60,310);
			}
		}

Quand l'ennemi est endormi, nous vérifions si le joueur est à l'intérieur de attackDistance, si il l'est - on éteint le mode sommeil (youpi!) et fixé la cible sur  le joueur. Nous allouons aussi une rotation particulière autour du joueur que nous voulons cibler (le sournois tente d'approcher par le côté ou derrière!) - Actuellement, c' est simplement stocké dans une variable, nous allons voir où elle est utilisé ensuite. C'est ce qui arrive quand l'ennemi ne dort pas:

			//Si la cible est morte alors retourne en mode sleeping
			if(!target){
				sleeping = true;
				return;
			}

			var difference = (target.position - _transform.position);
			difference.y /= 6;
			var distanceSquared = difference.sqrMagnitude;

			//Trop loin, on oublie...
			if( distanceSquared > _sleepDistanceSquared){
				sleeping = true;
			}
			//Assez proche pour une attaque?
			else if( distanceSquared < _maximumAttackEffectRangeSquared && _angleToTarget < 40f){
				StartCoroutine(Attack(target));
			}
			//Autrement, temps de se la bouger
			else{
				//Decider la position cible
				var targetPosition = target.position + (Quaternion.AngleAxis(_attackRotation, Vector3.up) * target.forward * maximumAttackEffectRange * 0.8f);
				var basicMovement = (targetPosition - _transform.position).normalized * speed * Time.deltaTime;
				basicMovement.y = 0;
				//Mouvement seulemeent si en face
				_angleToTarget = Vector3.Angle(basicMovement, _transform.forward);
				if( _angleToTarget < 70f){
					basicMovement.y = -20 * Time.deltaTime;
					_controller.Move(basicMovement);
				}
			}

Nous mettons l'ennemi à dormir si sa cible a disparu ou qu'elle est trop loin. Ensuite, si ce n'est pas le cas, si nous sommes à distance de frappe, nous commençons une coroutine pour effectuer une attaque. Si nous ne sommes pas endormis et nous ne sommes pas assez près pour attaquer alors nous envisageons de nous de déplacer vers la cible.

La première partie de ce travail est d'où nous voulons défendre. Il s'agit d'une combinaison de la position de la cible, l'angle que nous avons décidé sur le moment où nous l'avons ciblé et la distance de frappe (que nous voulons être à 80%). Nous utilisons un Quaternion basé sur l'angle pour modifier un vecteur basé sur la direction vers laquelle la cible est orientée et nous utilisons 80% de la distance de frappe pour modifier cette valeur. Tout cela est appelé targetPosition. Par exemple, si l'angle nous avons pris était de 180 et la distance de frappe est de 2 alors la position de la cible serait 1,6 unité du monde directement derrière la caméra.

Ensuite, nous travaillons sur l'angle entre l'endroit où nous sommes et où nous voulons aller - si il ya trop d'écart on ne bouge pas encore (on laisse le script de rotation définir l'angle). Si c'était ok, alors nous nous dirigeons vers la position cible après avoir ajouté un peu de pesanteur pour maintenir l'ennemi sur le terrain. Ouf!

Utiliser des coroutines pour attendre la fin d'une animation

Ok, donc nous savons que si nous sommes assez proche alors une coroutine d'attaque est lancée. Ce que nous voulons faire est de mettre en pause le comportement normal,  lancer une animation d'attaque et appliquer des dommages à moitié de l'animation. C'est ainsi que nous obtenons ce qui suit:

D'abord - pour faire la routine de plus utile, nous réveillons toujours un ennemi quand d'attaque est appelé - c'est parce que vous pouvez également déclencher une attaque avec deux ennemies qui se rentrent dedans!

	IEnumerator Attack(Transform victim){
		sleeping = false;
		_busy = true;
		target = victim;
		_attack.enabled = true;
		_attack.time = 0;
		_attack.weight = 1;
		//Attendre l amoitié de l'animation
		yield return StartCoroutine(WaitForAnimation(_attack, 0.5f));
		//Toujours assez proche?
		if(victim && (victim.position - _transform.position).sqrMagnitude < _maximumAttackEffectRangeSquared){
			//Appliquer les dommages
			victim.SendMessage("TakeDamage", 1 + Random.value * 5, SendMessageOptions.DontRequireReceiver);
		}
		//Attendre la fin de l'animation
		yield return StartCoroutine(WaitForAnimation(_attack, 1f));
		_attack.weight = 0;
		_busy = false;
	}

En réglant  _busy = true, nous mettons l'Update en attente alors que cette routine performe. _attack est l'animation d'attaque que nous activons, définissons le début et lui donner son facteur. L'animation commence alors à jouer. Ensuite, nous commençons une autre coroutine qui permettra de surveiller l'animation, dans ce cas, elle attendre qu'elle soit passée de 50%. Nous allons voir cette routine dans un instant.

Lorsque l'animation est passée de 50%, nous vérifions que la victime cible n'est pas déjà morte, et qu'elle est toujours à portée et si ces conditions sont remplies, nous envoyons un message TakeDamageavec une quantité aléatoire de dégâts à infliger.

Nous attendons ensuite que l'animation soit terminée avant de retirer notre état busy et désactiver l'animation.

Donc, nous allons jeter un oeil à la coroutine WaitForAnimation:

	public static IEnumerator WaitForAnimation(AnimationState state, float ratio){
		state.wrapMode = WrapMode.ClampForever;
		state.enabled = true;
		state.speed = state.speed == 0 ? 1 : state.speed;
		while(state.normalizedTime < ratio-float.Epsilon){
			yield return null;
		}
	}

Then the loop just waits for the .normalizedTime (the ratio of the clip) to be greater than or equal to the value we passed in (- a floating point fudge factor).

Comme vous pouvez le voir, c'est assez simple! Nous nous assurons d'abord que l'animation ne provoque pas  une boucle ou une réinitialisation, car cela pourrait signifier que nous avons manqué le point de fin. Nous nous assurons également qu'elle est activée et a une certaine vitesse, sinon cette routine ne finirait jamais.

Puis la boucle attend que .normalizedTime (le ratio du clip) soit supérieure ou égale à la valeur que nous avons passée. (- Un facteur arbitraire en float).

Plus de states

Donc maintenant nous avons attaqué et envoyé un message de dégâts, nous devrions examiner comment ce message est traité. Dans cette démo, le joueur est invincible (haha!), mais les ennemis peuvent infliger des dommages l'un l'autre.

Quand l'ennemi reçoit un message TakeDamage il doit réagir:

	void TakeDamage(float amount){
		StopCoroutine("Attack");
		health -= amount;
		if(health < 0)
			StartCoroutine(Die());
		else
			StartCoroutine(Hit());
	}

Tout d'abord nous stoppons toutes attaques en court, puis on soustrait la santé puis nous lançons une coroutine Hit ou Die.

	IEnumerator Die(){
		_busy = true;
		_animation.Stop();
		yield return StartCoroutine(PlayAnimation(_die));
		Destroy(gameObject);
	}

	IEnumerator Hit(){
		_busy = true;
		_animation.Stop();
		yield return StartCoroutine(PlayAnimation(_hit));
		_busy = false;
	}

Both coroutines play an animation to completion, Die destroys the object, Hit re-enables it.

And that's pretty much it for this tutorial.  You should check out RotateToFaceTarget which replaces our earlier rotation script, using the target variable rather than always facing the player - this let's enemies target each other.  The only other script of interest is WalkingAnimation:

Les deux coroutines jouent une animation entière, Die détruit l'objet,  Hit le réactive.

Et c'est à peu près tout pour ce tutoriel. Vous devriez vérifier RotateToFaceTarget qui remplace notre script de rotation, en utilisant la variable cible plutôt que de toujours faire face au joueur - cela permet aux ennemis de se cibler les uns les autres. Le seul autre script d'intérêt est WalkingAnimation:

using UnityEngine;
using System.Collections;

public class WalkingAnimation : MonoBehaviour {

	Transform _transform;
	Vector3 _lastPosition;
	AnimationState _walk;

	public float minimumDistance = 0.01f;

	void Start () {
		_transform = transform;
		_lastPosition = _transform.position;
		_walk = animation["walk"];
		_walk.layer = 2;
	}

	void Update () {
		var moved = (_transform.position - _lastPosition).magnitude;
		_lastPosition = _transform.position;
		if(moved < minimumDistance)		{
			_walk.weight = 0;
		}else{
			_walk.weight = moved * 100;
			_walk.enabled = true;
			_walk.speed = 1;
		}
	}
}

Ce script se fond dans l'animation de marche en fonction de la rapidité de l'ennemi en mouvement.

Conclusion

Nous espérons que vous avez trouvé ce tutoriel utile. S'il vous plaît n'hésitez pas à laisser vos commentaires - particulièrement utile serait les commentaires concernant de futures fonctionnalités que vous aimeriez voir expliquées.

Mike(whydoidoit)

• Acceder à un script sur le même objet
• Comment GetComponent fonctionne?
• Obtenir plusieurs composants
• Interaction entre objets
• Interaction entre objets dans la hierarchie
• SendMessage et BroadcastMessage
• Fonctions Interactives

Introduction

Un problème récurrent quand on commence avec Unity est de savoir comment accéder aux membres d'un script à partir d'un autre script. Nombreux sont ceux qui pensent que le simple déréférencement du nom du script serait suffisant, ils réalisent rapidement qu'il ne l'est pas.

Durant l'élaboration d'un programme, les variables sont stockées dans la mémoire à des emplacements différents. Si un objet pouvait voir les membres d'autres objets, il y aurait alors le risque de les modifier, même si cela n'était pas voulu. Si,  deux instances d'objets contiennent le même script avec les mêmes noms de variables, le compilateur ne serait pas en mesure de dissocier les deux.

Pour éviter ce problème, chaque objet dans la mémoire ne peut pas voir les autres objets. Il est alors nécessaire de dire à un objet où la variable dont elle a besoin se trouve en mémoire. Le principe du pointeur a été abandonné avec C# et maintenant, nous utilisons à la place des références (qui utilisent en fait un pointeur).

Il ya en fait différentes façons d'accéder à des variables, certaines sont meilleurs que d'autres et certaines sont tout simplement à utiliser dans des situations particulières.

Pour résumer, il existe trois façons:

1. GetComponent, la plus commune, aussi celle qui crée le plus de confusion au premier abord
2. SendMessage, qui peut sembler plus facile à saisir, mais aussi beaucoup moins efficace.
3. Les variable statiques, la plus facile à utiliser, mais aussi la plus compliquée à comprendre pleinement.

Créez une nouvelle scène et ajoutez un Empty GameObject et nommez-le "ObjectA". Créez deux scripts appelés «Scripta» et «ScriptB". Ajouter les deux scripts sur ObjectA.

Ouvrez les deux scripts dans l'éditeur et ajoutez ces lignes:

ScriptA.cs

using UnityEngine;
using System.Collections;
public class ScriptA : MonoBehaviour{
	public int varBInA;
	public int otherBInA;

	void Update(){
		if (Input.GetKeyDown(KeyCode.Space)){
			varBInA = ScriptB.GetVarB();
			otherBInA = ScriptB.varB;
			if (varBInA > 0)
				ScriptB.AddVarB(10);
		}
	}
}

using UnityEngine;
using System.Collections;

public class ScriptB : MonoBehaviour{
	private int varB;
	void Start(){
		varB = 20;
	}

	void Update(){
		if (Input.GetKeyDown(KeyCode.P))
			print("varB in ScriptB"+varB);
	}

        public int GetVarB(){
		return varB;
	}

        public void AddVarB(int num){
		varB += num;
	}
}

var varBInA:int;
var otherBInA:int;

function Update(){
	if (Input.GetKeyDown(KeyCode.Space)){
	       varBInA = ScriptB.GetVarB();
		otherBInA = ScriptB.varB;
		if (varBInA > 0)
			ScriptB.AddVarB(10);
	}
}

var varB:int;
functionStart(){
	varB = 20;
}

function Update(){
	if (Input.GetKeyDown(KeyCode.P))
		print("varB in ScriptB"+varB);
}

function GetVarB(){
	return varB;
}

function AddVarB(){
varB += num;
}
}

import UnityEngine
import System.Collections
class ScriptA (MonoBehaviour): 
   public varBinA as int
   public otherBinA as int

   def Update ():
      if Input.GetKeyDown (KeyCode.Space):
         varBinA = ScriptB.GetVarB()
         otherBinA = ScriptB.varB
         if varBinA > 0:
            ScriptB.AddVarB(10)

import UnityEngine
class ScriptB (MonoBehaviour):
   public varB as int
   def Start ():
      varB = 20

   def Update ():
      if Input.GetKeyDown(KeyCode.P):
         Debug.Log ("varB in ScriptB $varB")

   def GetVarB () as int:
      return varB

   def AddVarB (num as int):
      varB += num

Nous devons dire au Scripta où est ScriptB afin qu'il puisse accéder à ses membres. Puisque nos scripts sont sur le même objet nous avons simplement besoin de déclarer une variable de type du script que nous souhaitons  et utiliser GetComponent pour trouver le script.

Acceder à un script sur le même objet

Modifier ScriptA ainsi:

ScriptA.cs

using UnityEngine;
using System.Collections;

public class ScriptA : MonoBehaviour{
	public ScriptB scriptB;
	public int varBInA;
	public int otherBInA;

	void Start(){
		scriptB = GetComponent<ScriptB>();
	}

	void Update(){
		if (Input.GetKeyDown(KeyCode.Space)){
			varBInA = scriptB.GetVarB();
			otherBInA = scriptB.varB;

			if (varBInA > 0){
				scriptB.AddVarB(10);
				print("In ScriptA otherBInA is " + otherBInA);
			}
		}
	}
}

	var scriptB: ScriptB ;
	var varBInA:int;
	varotherBInA:int;

	function Start(){
		scriptB = GetComponent(ScriptB);
	}

	function Update(){
		if (Input.GetKeyDown(KeyCode.Space)){
			varBInA = scriptB.GetVarB();
			otherBInA = scriptB.varB;

			if (varBInA > 0){
				scriptB.AddVarB(10);
				print("In ScriptA otherBInA is " + otherBInA);
			}
		}
	}
}

import UnityEngine
class ScriptA (MonoBehaviour):
   public scriptB as ScriptB 
   public varBinA as int
   public otherBinA as int

   def Start ():
      scriptB = GetComponent[of ScriptB]()

   def Update ():
      if Input.GetKeyDown (KeyCode.Space):
         varBinA = scriptB.GetVarB()
         otherBinA = scriptB.varB
         if varBinA > 0:
            scriptB.AddVarB(10)

Avec les modifications, lancez le jeu, appuyez sur P, il devrait s'afficher 20 dans la console, appuyez sur Espace, puis à nouveau sur P, la valeur est maintenant de 30. Il était également possible d'accéder directement à varB sans passer par la fonction puisque varB est public.Notez qu'accéder à une méthode  se fait de la même manière que pour les variables.

Si les membres étaient privée (private), il ne serait pas possible d'y accéder directement. Il faudrait alors untiliser une fonction publique (encapsulation).

Comment GetComponent fonctionne?

Nous devons d'abord déclarer un objet du type du script que nous voulons atteindre.

// C# 
ScriptB script;

// UnityScript
var script:ScriptB;

// Boo
ScriptB script;

Puis on utilise la fonction GetComponent comme ceci:

// C#
script = GetComponent<ScriptB>();

// UnityScript
script = GetComponent(ScriptB);

// Boo
script = GetComponent[of ScriptB]()

La fonction GetComponent va chercher à l'intérieur de l'objet  un composant correspondant au type que nous passons. Si aucun n'est trouvé une référence null est retourné et notre variable  script ne fera rien, elle pointe dans le vide. Si un composant de type ScriptB  est trouvé, alors l'adresse de ce composant est passé à la script variable, la variable pointe désormais vers le composant ScriptB stocké dans la mémoire. Afin d'accéder aux membres publics de ScriptB, nous avons juste besoin de déréférencer la variable  script à l'aide de l'opérateur point.

script.PublicMembers;

Les membres privés sont toujours inaccessibles.

Donc je peux cacher avec GetComponent?

Oui, et cela est recommandé pour les variables fréquement utilisées comme la Transform.

Quand vous accédez une variable d'un composant "Built-in" (d'usine) comme Rigidbody, Renderer, Transform...etc, Unity permet un accès direct comme ceci:

void Update(){
    transform.position.x += 10;
}

Mais ce que Unity fait derrière:

void Update(){
    GetComponent<Transform>().position.x +=10;
}

GetComponent devrait être éviter dans l'update donc il est préférable de cacher le composant:

C#

Transform _transform;

void Start(){
     _transform = GetComponent<Transform>();
}

void Update(){
     _transform.position.x = new Vector3(_transform.position.x+10,0,0);
}

_transform:Transform;

function Start(){
     trans = GetComponent(Transform);
}

function Update(){
     _transform.position.x +=10;
}

_transform as Transform

def Start():
   _transform = GetComponent[of Transform]()

def Update():
   _transform.position.x +=10

This will save some computation.

Obtenir plusieurs composants

Que faire si notre ObjectA a plusieurs  ScriptB sur lui-même. Dupliquez le ScriptB deux fois, ObjectA en a désormais trois.

ScriptA devient:

C#

using UnityEngine;
using System.Collections;

public class ScriptA : MonoBehaviour{
	private ScriptB [] scriptB;

	void Start(){
		scriptB = GetComponents<ScriptB>();
	}

	void Update(){
		if (Input.GetKeyDown(KeyCode.Space)){
			for (int i = 0; i<scriptB.Length; i++)
				scriptB[i].AddVarB(i);
		}
	}
}

private var scriptB:ScriptB [];

functionStart(){
	scriptB = GetComponents(ScriptB);
}

function Update(){
if (Input.GetKeyDown(KeyCode.Space)){
	for (int i = 0; i<scriptB.Length; i++)
		scriptB[i].AddVarB(i);
	}
}

import UnityEngine
class ScriptA (MonoBehaviour):
   public scriptB as (ScriptB)

   def Start ():
      scriptB = GetComponents[of ScriptB]()

   def Update ():
      if Input.GetKeyDown (KeyCode.Space):
         for i in range(scriptB.Length):
            scriptB[i].AddVarB(i)

Lancez le jeu, appuyez sur P, la console imprime trois 20. Appuyez sur Espace et P encore, la console devrait ressembler à ceci:

Parce que j'ai utilisé la valeur de i dans la boucle comme paramètre de la fonction, chaque script a reçu une valeur différente. A noter que pusique la boucle commence à 0, un script ne change pas.

Interaction entre objets

Nous pouvons également faire interagir deux objets d'une manière similaire. Créez un nouvel objet nommé "ObjectB". Retirez le composant ScriptB de ObjectA et'ajoutez le sur ObjetB.

Lancez le jeu, vous pouvez imprimer mais appuyer sur Espace lèvera une exception de référence null. Cela est dû au fait que le ScriptB n'est plus sur ObjectA et GetComponent n'a tout simplement pas pu le trouver. Nous devons d'abord trouver l' ObjectB avec GameObject.Find ("ObjectB").

Il vous suffit d'ajouter la ligne suivante dans le scriptA:

// C#
void Start () {
     scriptB = GameObject.Find ("ObjectB").GetComponent<ScriptB>();
}

// UnityScript
function Start(){
    scriptB = GameObject.Find ("ObjectB").GetComponent(ScriptB);
}

// Boo
def Start ():
   scriptB =GameObject.Find ("ObjectB").GetComponent[of ScriptB]()

GameObject.Find () trouve d'abord l'objet passé en paramètre, puis cherche le composant requis à l'intérieur de celui-ci. Il est recommandé d'effectuer ces actions dans le fonction Start ou à un moment du jeu où les retards n'affecte pas le gameplay. GameObject.Find et GetComponent sont des fonctions coûteuses car elles doivent parcourir toute la hiérarchie. Si votre scène ne comprend que 10 objets, ça passera, mais si elle contient des milliers d'objets vous verrez sûrement un mauvais effet.

Interaction entre objets dans la hierarchie

Faites glisser ObjectB dans ObjectA.

Lancez le jeu et vous verrez que cela fonctionne très bien. Pourtant, nous pouvons y arriver de meilleure manière à l'aide de commandes qui indiquent au compilateur que ObjectB est un enfant de ObjectA. Par conséquent, aucune nécessité de chercher tous les objets de la scène.

// C#
void Start () {
    scriptB =_transform.Find ("ObjectB").GetComponent<ScriptB>();
}
// UnityScript
function Start(){
   scriptB =_transform.Find ("ObjectB").GetComponent(ScriptB);
}

// Boo
def Start ():
    scriptB =transform.Find ("ObjectB").GetComponent[of ScriptB]()

Gameobject est échangé pour _transform. En effet, un objet enfant appartient à la transform deu parent donc nous limitons la recherche aux objets se trouvant dans la transform de ObjectA.

Encore mieux:

void Start () {
     script =GetComponentInChildren<ScriptB>();
}
function Start(){
   script =GetComponentInChildren(ScriptB);
}
def Start():
   script = GetComponentInChildren[of ScriptB]()

Note that it also works if you have children of children holding the script. Create an “ObjectC”, add ScriptB to it and add the object to ObjectB. Now A has B which has C.

Notez que cela fonctionne aussi si vous avez des enfants d'enfants qui contiennent le script. Créer un "ObjectC", ajoutez ScriptB dessus et ajoutez ObjectC à ObjectB. Maintenant A contient B qui contient C.

Changez ScriptB pour:

void Update(){
    if(Input.GetKeyDown (KeyCode.P))print (gameObject.name+" "+varB);
}

Lnacez le jeu, vous verrez que tous les objets sont trouvés.

GetComponentsInChildren fonctionnera de la même manière si chaque enfant contient plusieurs fois le script .

SendMessage et BroadcastMessage

Nous venons de voir différentes manières de faire interagir deux objets ou deux scripts. SendMessage et BroadcastMeassage sont deux autres possibiltés qui peuvent s'avérer plus simples mais aussi plus coûteuses. Le principe reste le même, on a une référence à un objet et on souhaite affecter un script qu'il contient.

Avec SendMessage, on peut appeler une fonction sur un objet sans avoir à trouver une référence au script. Vous allez me dire: "C'est quoi tout ce remue-manège si on peut faire simple?"

Et cela devrait vous paraitre logique, avec GetComponent on indique exactement où se trouve le script en mémoire. Avec SendMessage, le compilateur connait l'objet mais il devra passer par tous les scripts et toutes les fonctions jusqu'à ce qu'il trouve l'heureuse élue. Cela peut altérer votre jeu si vous l'utilisez souvent sur plusieurs objets.

SendMessage ne cherche que sur l'objet auquel l'appel est fait, BroadcastMeassage lance une recherche sur l'objet visé mais aussi sur tous ces enfants. La recherche sera donc encore plus longue si l'objet contient une grande hierarchie.

Voici un exemple tout simple en C#:

SendMessage

// ObjetA  Script.cs

int argent = 100;
void FonctionA(){
    print("FonctionA dans l'objet A");
}
void RetireArgent(int montant){
    argent -=montant;
}

// ObjetB

ObjetA obj;

void Start(){
    obj = GameObject.Find("ObjetA");
}
void Update(){
    if(Input.GetKeyDown(KeyCode.Space)){
        obj.SendMessage("FonctionA");
        obj.SendMessage("RetireArgent",50);
    }
}

Dans l'exemple ci-dessus, le premier appel va simplement chercher la fonction et lancer une impression sur la console. Le deuxième appel pass aussi un paramètre requit par la fonction.

BroadcastMessage fonctionne de la même manière.

Fonctions Interactives

Unity utilise de nombreuses fonctions qui font interagir deux objets ou plus. L'avantage de ces fonctions réside dans le fait qu'elles stockent de nombreuses informations sur l'autre objet.

Il existe deux principaux groupes:

1. Fonctions de collision : OnCollisionXXXX/OnTriggerXXXX
2. Fonctions de la class Physics

Voici une simple déclaration de collision :

// C#
void OnCollisionEnter(Collision other){}

//UnityScript
function OnCollisionEnter(other:Collision){}

//Boo
def OnCollisionEnter(collision as Collision):

Chaque appel crée une référence à l'autre objet qui est désormais accessible dans la fonction. other dans notre example est un référence à l'autre objet. En déréférençant cette variable nous pouvons désormais accéder aux composants de l'objet avec GetComponent.

void OnCollisionEnter(Collision other){
   if(other.gameObject.tag == "ObjetB"){
       ScriptB script = other.GetComponent<ScriptB>();
       script.variable = 20;
   }
}

Dans cet exemple en C#, j'accède aux données de other et vérifie si other a pour tag "ObjetB". Je sais alors que je suis en collision avec l'ObjetB et j epeux faire une requête pour le ScriptB avec GetComponent.

L'avantage est que vous n'avez pas à chercher l'objet avec GameObject.Find();, ilvous est donné par la fonction.

À noter que la classe COllider est un peu plus complète que la class Collsion, mais vous serez en mesure de faire les mêmes actions avec les deux classes. Il se peut que Collision nécessite une déréférenciation de plus pour accéder la même variable.

Les fonctions de la classe Physics ont un principe similaire. Elles utilisent une variable ou un tableau de variable pour stocker des information sur l'objet qvec lequel nous interagissons.

Voici par exmple un raycast:

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() {
        RaycastHit hit;
        if (Physics.Raycast(_transform.position, _transform.forward, out hit))
            print(hit.gameObject.name);

    }
}

Une variable de type RaycastHit est déclarée et passé comme paramètre à la fonction, le mot-clé out en C# permet de modifier une structure passée comme paramètre. En utilisant hit, nous pouvons retrouver toutes sortes d''informations concernant l'objet. Dans mon exemple, j'imprime simplement le nom de l'objet.

Interaction en action

Afin de donner une représentation visuelle et pratique, la vidéo ci-dessous résume quelques-unes des utilisations de GetComponent (en anglais pour le moment).

You should read this article if:

• You want smarter enemies (and not just ones that follow the shortest path!)
• You want to understand an A* Path finding algorithm implementation in Unity
• You'd like to learn about building a navmesh
• You'd like to see Linq and threading in action

Resources

• Wikipedia Article On A*

Project Video

A quick introduction to the project associated with this article.

Fundamentally Smart

A* is the basic way to make you enemies smart - because it's not just about finding the shortest path between two points.

With A* you can:

• Find the path between two points
• Based on the current threat level:
  • Find the shortest path
  • Find the path that avoids pinch points
  • Find the path that keeps in cover
  • Find the path that avoids where the player is looking
  • Find the best retreat from a fight
  • Find the best path to draw the player into crossfire
  • Find the best path to draw the player away from an asset
• Find the path that offers the most cover from a current attacker

Kinda cool!  In fact A* can pretty much do anything you can think of, presuming you have the nous to writing an algorithm that weights a path position for a given outcome.  In part #2 we will look at examples of this kind of intelligence - but first you need to understand what A* is and how to implement it.

A*

Ok, it's got a silly name, I admit it - and it can also be quite intimidating.  You can find some great implementations of A* including Aaron Grandberg's great A* Pathfinding Project - but there's nothing quite the same as understanding it for yourself, even if you use someone else's implementation.

A* uses a "best-first" approach to finding a path between the start and end points - in other words - it tries to go the logically shortest way first, then backs up if it can't make it and tries other short options next if the shortest path is blocked.

This is how A* works:

• Create an open set of all of the nodes that haven't been considered yet and have been discovered as a part of path finding
• Create a closed set of all of the nodes that have been considered
• Add the starting position to the open set

For each node we need to keep two scores - the first is the lowest known cost of getting to the node.  Later on we will use cost as something other than distance, but for now, imagine that is the number of world units that we travelled to reach this node (I'll show you how we calculate it next).  We call this the g score.

The second score is our best guess at how far it is from the start to the end positions via this node!   How do we guess?  Well we take the known cost of getting to this node and then we estimate the distance to the goal (in our case we will use the Manhattan distance) and add them together. We call this the f score.

Ok so thats the setup - next the actual algorithim:

So for the best node (lowest f score) in the open set we check if it's the goal position and return if it is -otherwise we find all of its walkable neighbours that haven't already been processed and for each one, calculate the cost of reaching that node via the one we are considering.  Then we check whether we already know of a better (less costly) way of reaching the neighbour, if we don't then we setup an open set node for the neighbour with the cost of getting to it and our estimated cost to the end position.

An example may help:

Her we have a starting position (in green) and a goal (in yellow).  On the first step of the algorithm we find all of the walkable neighbours and calculate a g and an f score for them.

The node with the lowest f score is the one indicated by the green arrow. So we consider that one next - on this step we now will have some candidates for which our g score via the current node is higher than the g score from the first test - so they won't be updated (in the graphic below they have a tg which is higher than the cells g):

On the next step we again take the lowest scoring open set node (the node in red shows the only one currently in theclosed set):

After processing that - again we take the lowest f scoring node:

After that, in this case it's just a straight run for the finish:

Here's an example of the A* algorithm seeking a target. Red to green indicates the distance from the target - open blue nodes are the ones in the open set, the coloured ones are in the closed set.

NavMesh

So in order for that algorithm to work we actually need something to represent the walkable and unwalkable positions in a terrain - we call such things a NavMesh - the easiest one is a Grid.  We can create a grid map that overlays the terrain and creates a simplified map of it for our algorithm.

In this picture we take an example scene and overlay a grid showing, in green, the walkable areas.

In Unity creating one of these is surprisingly easy!  All we need is a cube to define the bounds of our map and then ray cast each cell to see if it is walkable or not.

First we need a way of representing a cell in the map - for now we just care about walkable/unwalkable and the height of that cell in the world:

	//Representation of a grid cell
	public class GridCell
	{
		public bool walkable;
		public float height;
	}

Now we actually need a map - so clearly that should be a 2d array of these cells:

	//Width and height of the map in cells
	int width, height;
	//Active map of the world
	public GridCell[,] cells;

And then to convert it from World coordinates to grid coordinates we need a size for each cell:

	//Size in world units of a cell
	public float cellSize = 0.5f;

So we will now build a cube in the world, attach our script to it and use the bounds of its renderer to map where we want to put our navmesh (obviously we'd normally use a semi-transparent material!).

We need to work out the size of the map from our cubes bounds and the cell size and then do a couple of for next loops to actually find the terrain or another collider.  We also need a mask to indicate what colliders are walkable and which ones are not.

	//Scan the bounds of the model and create a grid
		bounds = renderer.bounds;
		//Work out the top left corner
		topLeftCorner = bounds.center - bounds.extents + new Vector3(0, bounds.size.y, 0);
		//Calculate the dimensions of the grid map
		width = Mathf.RoundToInt(bounds.size.x / cellSize);
		height = Mathf.RoundToInt(bounds.size.z / cellSize);
		//Create the grid map
		cells = new GridCell[width, height];
		//Scan for walkable terrain in each cell
		for(var x = 0; x < width; x ++)
		{
			for(var y = 0; y < height; y++)
			{
				//Get the position for a ray
				var currentPosition = topLeftCorner + new Vector3(x * cellSize, 0, y * cellSize);
				RaycastHit hit;
				//Create a cell for the grid
				var cell = new GridCell();
				cells[x, y] = cell;
				//Cast the ray
				if(Physics.Raycast(currentPosition, -Vector3.up, out hit, bounds.size.y))
				{
					//The height of the highest item in the cell
					cell.height = hit.point.y;
					//Test if the thing we hit was walkable
					if(((1 << hit.collider.gameObject.layer) & walkableLayer) != 0)
					{
						//Flag the cell as walkable
						cell.walkable = true;
					}
				}

			}
		}

When that's finished we actually want to run some "post processing" because at the moment it doesn't use any kind of concept of the width of a character and we can bake standard widths into the mesh.  In the example project with this tutorial we have build a plug in system that will call specially decorated classes - passing them the grid we make and letting them modify it.

Using that we can define a Radius Modifier that looks to make unwalkable areas a bit larger:

using UnityEngine;
using System.Collections;
using System.Linq;
using System.Collections.Generic;

[ProcessingPriority(1)]
public class RadiusModifier : BuildGraph.IProcessGrid {
	#region IProcessGrid implementation
	//Post process the grid
	public void ProcessGrid (BuildGraph builder)
	{
		//Make a list of nodes to flag as unwalkable
		//we can't immediately update them or the
		//whole thing would go horribly wrong as it
		//scanned its own output!
		var unwalkable = new List<BuildGraph.GridPosition>();
		//Run through the grid
		for(var x = 0; x < builder.width; x ++)
		{
			for(var y = 0; y < builder.height; y++)
			{
				//Get a current position
				var currentPosition = new BuildGraph.GridPosition { x = x, y = y };
				//Get all of the neighbours within 2 grid units and see if any
				//of them are not walkable
				if(builder.GetNeighbours(currentPosition, 2).Select(cell=>builder.GetCell(cell)).Any(gc=>!gc.walkable))
				{
					//If so add this cell to the unwalkable
					//list
					unwalkable.Add(currentPosition);
				}
			}
		}
		//Update the map
		foreach(var unwalk in unwalkable)
		{
			builder.GetCell(unwalk).walkable = false;
		}

	}
	#endregion

}

Seeking a Path

Having made a reasonable implementation of a grid navmesh - all we need to do now is some pathfinding!

We create a seeker script that is attached to the thing that wants to follow a path:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class Seeker : MonoBehaviour {

	//Target object
	public Transform target;
	//Cache to know what our
	//last path was for
	Vector3 lastDestination;

	//Route to follow
	public List<Vector3> route = new List<Vector3>();
	//Position on the route
	public int routePos;

	//Something that knows how to move
	//our character
	Movement movement;

	void Awake()
	{
		//Something that can be told where to go
		movement = GetComponent<Movement>();
	}

	// Update is called once per frame
	void Update () {
		//Check for a target
		if(target == null)
			return;

		//Get the position from the target
		var targetPosition = target.position;
		//Has it moved
		if(targetPosition != lastDestination)
		{
			//Update the cache
			lastDestination = targetPosition;
			//Ask the grid to build a path
			BuildGraph.instance.SeekPath(transform.position, targetPosition, (path)=>{
				//This is called when we get a result
				if(path == null)
					return;
				//Update the route
				route.Clear();
				route.AddRange(path);
				routePos = 0;

			});
		}

		//Are we at the end of the route?
		if(routePos < route.Count)
		{
			//Set the target to the current route position
			movement.targetPosition = route[routePos];
			//Check for the next route position
			var distance = Vector3.Distance(route[routePos], transform.position);	
			if(distance < movement.speed/2)
				routePos++;
		}

	}
}

This will track a scene object and try to get to it - it calls our SeekPath function, which is where the magic happens, every time the target moves.  Note that we use a callback function to update the path so we can use multiple threading.  This script interacts with a movement script which just moves towards a target position - the seeker updates that target as the enemy follows the path.

A* Implementation

Ok so it's time to look at the A* SeekPath function itself:

	//Find a path between two positions
	public void SeekPath(Vector3 startPosition, Vector3 endPosition, Action<IEnumerable<Vector3>> onComplete)
	{
		//Scan if we don't have a map yet
		if(cells == null)
			Scan();

		onComplete = onComplete ?? delegate {};

		//Start and end in grid coordinates
		var start = GetGridPosition(startPosition);
		var end = GetGridPosition(endPosition);

		//Run multithreaded
		Loom.RunAsync(()=>{
			try
			{
				//Set of considered nodes
				var closedSet = new Dictionary<GridPosition, Node>();
				//Set of all nodes processed (so we can rebuild the path)
				var map = new Dictionary<GridPosition, Node>();
				//Set of nodes yet to be considered
				var openSet = new Dictionary<GridPosition, Node>();

				//Create a node for the start
				var startNode = new Node { f_score = end.Distance(start) };
				//No cost
				startNode.g_score = 0;
				//Add to the map and opensets 
				map[start] = startNode;
				openSet[start] = startNode;
				//Get the time so we can abort if it takes too long
			    var currentTime = DateTime.Now;
				//While we have nodes
				while(openSet.Count > 0 )
				{
					//Check if we should abort
					if((DateTime.Now - currentTime).TotalMilliseconds > maxSeekTime)
					{
						break;
					}
					//Get the best possible node
					var best = openSet.Aggregate((c,n)=>c.Value.f_score < n.Value.f_score ? c : n);
					//Remove it from the open set and add it to
					//the closed set
					openSet.Remove(best.Key);
					closedSet[best.Key] = best.Value;
					//Have we reached the target?
					if(best.Key == end)
					{
						//Recreate the path
						var path = new List<Vector3>();
						var scan = best.Value;
						//Add the actual end position
						path.Add(endPosition);
						//Scan backwards from the end of the path
						//until scan.cameFrom is 0
						while(scan != null && scan.cameFrom != GridPosition.zero)
						{
							//Add the current node to the START of the path
							//thereby reversing the direction of the list
							path.Insert(0, GetWorldPosition(scan.cameFrom));
							//Get the next node
							scan = map[scan.cameFrom];
						}
						//Update the caller
						Loom.QueueOnMainThread(()=>{
							onComplete(path);
						});
						return;

					}

					//Get all of the neighbours of the current cell
					//that are walkable
					foreach(var cell in GetNeighbours(best.Key).Where(c=>GetCell(c).walkable))
					{
						//Have we processed this already?
						if(closedSet.ContainsKey(cell))
						{
							continue;
						}
						//Work out the cost to the neighbour via the current node
						var tentativeGScore = best.Value.g_score + GetWeightOfMovingBetween(best.Key, cell);
						Node currentNode;
						//Is the neighbour already open?
						if(!openSet.TryGetValue(cell, out currentNode))
						{
							//If not then create a node for it
							//this will have a maximum g_score
							currentNode = new Node();
							//Add it to the map and the open set
							map[cell] = currentNode;
							openSet[cell] = currentNode;
						}
						//Is the new g_score lower than the
						//current one?
						if(currentNode.g_score > tentativeGScore)
						{
							//Update the openset node with this
							//new better way of getting there
							currentNode.g_score = tentativeGScore;
							currentNode.cameFrom = best.Key;
							currentNode.f_score = tentativeGScore + cell.Distance(end);
						}

					}

				}
				//Indicate failure
				Loom.QueueOnMainThread(()=>{
					onComplete(null);
				});
			}
			catch(Exception e)
			{
				Debug.Log(e.ToString());
			}
		});

	}

As you can see we have a special struct representing grid positions called GridPosition and we call a number of helper functions to manipulate them, but I'll leave you to dig into the code if you want to learn more about them.  Hopefully you can see how the algorithm is processing the nodes and the set.  We have chosen Dictionaries as our method of storing data due to their O(1) lookup performance - so these are very fast to look up, but our "find the node with the best f_score" is running in O(n) time so that if the routine has to back up often it might start getting expensive - but this seems the best trade off between clarity of code and performance in this case.

Conclusion

So a lot of theory in #1 - in #2 we will get on to the actual job of making enemies smarter and look at ways of detecting pinch points and cover - then apply that to smarter path finding.

Tutorial Project

Comment .NET gère la mémoire est marqué par  de nombreuses inconnues. Pourquoi Unity me dit que mes value types ne peuvent être modifiées? Boxing une variable ne signifie pas lui en mettre plein la fiole?Non.

Cet article va tenter de clarifier certains points qui nous le souhaitons éclarciront votre manière de programmer.

• Zones de mémoire
• Value Types et le Stack
• Reference Types et le Heap
• Struct vs Class
• Créer une Reference
• Classes Statiques
• Variables Statiques
• Fonctions Statiques
• Heap Fragmentation, Object Pooling et Garbage Collection

Lorsqu'on débute la programmation avec Unity et la programmation en général, nombreux sont ceux qui tombent face à l'utilisation des variables types. Pourquoi certaines variables sont modifiées et d'autres ne le sont pas, pourquoi ma variable a disparu alors que j'en ai encore besoin?

Une autre erreur classique est l'utilisation des variables statiques. Les nombreux tutoriels sur internet vous les font utiliser sans vraiment vous dire ce qu'elles sont et mettent simplement en avant la "facilité d'accès".

Le problème c'est que les variables statiques (aussi appelées variables de classe) ne sont pas un sujet facile.

Certains vous diront tout simplement de les éviter, clamant que ce qui peut être fait avec du statique peut aussi être fait sans. Si cela est vrai, ce n'est pas toujours la meilleure solution.

Dans ce tutoriel, nous couvrirons les différentes zones de la mémoire, les value types et reference types, l'allocation dynamique de la mémoire et les variables statiques.

Zones de Mémoire

En lançant un programme, l'OS (operating system,  Windows, Mac ou Linux) réserve une partie de la mémoire de l'ordinateur pour le programme. Avant, il y avait quatre zones principales, le call stack, le heap, les registres et la mémoire statique.

Les développeurs de C# ont été assez gentils de minimiser ce nombre à deux zones seulement, stack et heap. La première est ordonnée, rapide mais limitée, la seconde est aléatoire, large et ainsi plus lente.

Il est possible pour le programmeur de choisir quelle zone sera utilisée pour chaque variable en fonction du but et du destin de la variable.

Il existe trois mot-clés de stockage (C en avait un quatrième, register)  pour le gestion de la mémoire:

1. auto
2. static (nous allons couvrir ces deux là)
3. extern.

Il se peut que vous rencontriez extern, cela signifie simplement que la variable est déclarée en dehors du projet, par exemple dans un DLL écrit dans un langage différent et non .NET.

extern int number;

Le compilateur n'alloue aucune zone de mémoire pour number et attend que la variable soit trouvée ailleurs. Nous n'allons pas passé plus de temps là-dessus. Pour plus d'info  ici.

Value Types et le Stack

auto signifie une variable automatique. Il se peut que vous n'ayez jamais vu ce mot auparavant puisqu'il n'est plus utilisé en C# cependant le principe existe toujours. Il fut un temps où auto était la variable par défaut:

int variable = 10;
auto int variable = 10;

Ces deux lignes ont le même effet.

Le principe d'une variable automatique est qu'elle est placée sur le call stack. Un stack est une pile de variables, tout comme une pile d'assiettes, vous pouvez retirer celle du dessus ou en ajouter une sur le dessus, mais  vous ne pouvez pas toucher celle du dessous. Voyez plutot:

Le stack est utilisé pour les appels de fonction, si vous réfléchissez deux secondes, le programme est une fonction principale qui lance une boucle sans fin (jusqu'à la fermeture du programme...) dans laquelle les fonctions Updates sont appelées à leur tour et elles appellent d'autres fonctions. Ainsi il est logique que toutes les variables de votre programme soient automatiques si elles ne sont pas définies autrement.

Il se peut que vous rencontriez le concept de stack frame, une collection de variables allouées localement par la fonction en cours (et contient également l'adresse de retour qui est le point d'instruction qui sera exécutée immédiatement après le retour de la fonction). Le compilateur maintient un pointeur vers la fin du stack frame puis utilise un décalage négatif de ce pointeur pour trouver la mémoire que vos variables locales occupent. Le résultat pratique de ceci est qu'après qu'une fonction ait retourné, alors aucun espace utilisé par ses variables locales est encore utilisé ou alloué en aucune façon mais plutot sauvegardées de manière à être disponible pour le prochain l'appel de la fonction.

Si vous écrivez une fonction récursive (une fonction qui s'appelle elle-même) vous pouvez potentiellement manquer d'espace dans le stack. Voici un exemple de fonction recursive:

void Fonction(int num){
   int temp;
   temp = num+1;
   Fonction(temp);
   print(temp);
}

Comme vous pouvez le constater, la fonction place num  sur le stack puis une variable temp puis s'appelle et le processus se répète. Notre fonction n'a aucune "sentinelle" et va infiniment se répéter jusqu'à ce qu'un stack overflow crash le programme. Si votre programme comporte une tel bug, le compilateur va probablement lancer l'avertissement de stack overflow.

Le temps de vie et la portée d'une variable fonctionnent ensemble. La vie d'une variable commence avec sa déclaration jusqu'à l'accolade correspondant à l'accolade qui s'ouvre au dessus. Mmm, une clarification s'impose.

void Update(){
    int number = 10;
    Fct(number);
    print(number);
} 

void Fct(int n){
    int inside=20;
    n = n + inside;
    print(n);
}

Update est appelée et la première instruction est une déclaration de variable. Le stack pointer est poussé vers le haut et la valeur de number est placée en mémoire.

La seconde commande est un appel de fonction. Lors d'un appel de fonction, le programme s'arrête et saute vers l'adresse de mémoire où la fonction est stockée. Certaines données sont placées sur le stack de manière à pouvoir reprendre le programme en fin de fonction. Les paramètres (s'il y en a) sont alors poussés sur le stack en créant une copie de l'original.

La variable number n'est pas poussée sur le stack pour être utilisée dans la fonction mais une nouvelle variable n est créée, placée sur le stack et la valeur de number y est placée. On dit que la variable number est passée par copie.

Nous avons alors une variable n dans la fonction qui a la valeur de number mais number n'existe pas dans Fct() et de ce fait ne peut être vue ni atteinte. Dans la fonction, la variable inside est créée. Le stack ressemble en quelque sorte à l'image au-dessus ( largement simplifié).

En fin de fonction, n est imprimée et a la valeur 30. Toutes les variables créées dans la fonction sont détruites/perdues. Cela inclut n et inside. Bien que les variables soient toujours physiquement en mémoire, elles sont simplement ignorées par le système et finiront probablement écrasées.

De retour dans Update, nous imprimons la variable number qui n'a pas changée sa valeur de 10. Le stack pointer a perdu la location de n et inside, si nous tentons de les utiliser dans Update, le compilateur renverrait une erreur que la variable n'existe pas dans cette partie du programme (scope).

Nous venons de voir que la portée d'une variable automatique est définie par les { } dans laquelle elle fut déclarée. En dehors, la variable n'existe plus et n'est plus visible. Ces accolades marquent le scope d'une fonction, d'une commande if, une boucle,...Il est en fait possible de créer un scope de la manière suivante:

void Update(){
  int a = 10;
   {
     int b = a;
   }
   // b n'existe plus
}

Temps de vie et scope

Le temps de vie (lifetime) signifie le moment du programme pendant lequel la variable existe, scope definit la zone du programme où la variable est visible. Dans le cas des variables automatiques, les deux sont identiques.

Toutes les variables value type sont placées sur le stack, celles ci sont:

• int
• unsigned
• float
• double
• char
• struct
• bool
• byte
• enum
• long
• short

Plus ou moins les variables héritées de C (excepté bool).

Pour une variable automatique, sa vie est prise en charge par le compilateur. La fin du scope dans lequel elle fut déclarée marque aussi la fin de  la variable comme nous l'avons vu dans l'exemple précédent. Le programmeur n'a pas à se soucier de libérer la mémoire occupée par la variable, cela est fait automatiquement.

Reference Type et le Heap

Une variable reference type est un objet stocké en mémoire comme référence. Lorsqu'on crée une nouvelle instance de la classe, les données sont stockées dans la zone de mémoire appelée le heap. Une référence pointant vers ces données est placée sur le stack. Cette référence  a comme valeur l'adresse de l'objet. Pour créer une instance d'une classe, le mot-clé new est utilisé. C'est un appel à l'OS pour obtenir de l'espace de mémoire correspondant au type de l'objet et une instruction pour lancer les codes nécessaires à l'initialisation de l'objet. Voyez ci-dessous comment créer une instance d'un objet de type Dog.

public class Dog{
     public string name { get; set;}
     public int age { get; set;}
     public Dog(string s, int n){
           name = s;
           age = n;
    }                          
}
public class Test : MonoBehaviour {
    Dog dog1 = new Dog("Rufus",10);
    Dog dog2 = new Dog("Brutus",8);

    void Update (){                                                  
        if(Input.GetKeyDown(KeyCode.Alpha1))
            print ("Le dog1 est nommé "+dog1.name+" et a  "+dog1.age+" ans.");
        if(Input.GetKeyDown(KeyCode.Alpha2))
             print ("Le dog2 est nommé "+dog2.name+" et a "+dog2.age+" ans.");
    }
}

Nos variables dog1 et dog2 sont des références vers des  locations en mémoire où les données concernées sont stockées. Ces références étant placées sur le stack, elles seront détruites en fin de scope.

Voyons maintenant la fonction Instantiate. Imaginons une prefab nommée Enemy qui inclut un modèle 3D, des composants et des scripts.

using UnityEngine;
using System.Collections;

public class Test : MonoBehaviour{
    public GameObject enemyPrefab;

    void Update(){
        if(Input.GeyKeyDown(KeyCode.Space))
               Instantiate(enemyPrefab,new Vector3(0,0,0), Quaternion.identity);
    }
}

Nous venons de créer une instance de enemyPrefab et elle se porte bien. Un problème cependant, nous n'avons aucune référence pour l'utiliser. Si nous devons appliquer des changements ou des actions à notre prefab, nous avons besoin d'une référence à cet objet.

void Update(){
    if(Input.GeyKeyDown(KeyCode.Space))
       GameObject enemyRef = Instantiate(enemyPrefab, new Vector3(0,0,0), Quaternion.identity);
        enemyRef.AddComponent(Rigidbody);
        Destroy(enemyRef);
     }
}

Dans cet exemple, la variable enemyRef est déclarée et assignée l'adresse du nouvel objet de type GameObject. enemyRef est désormais une référence à cet objet. Voyez comment il nous est possible d'ajouter un component (Rigidbody dans notre cas) puisque enemyRef sait où se trouve l'objet en mémoire. Sur la dernière ligne, l'objet est détruit, ce qui est plutot inhabituel de créer et détruire dans la foulée mais c'est juste pour l'exemple.

La référence est une variable automatique est par conséquent ne vit qu'entre les {} de la commande if. En dehors, la variable référence n'existe plus. Pour récuperer notre objet, nous devons le chercher ainsi:

GameObject enemyRefAgain = GameObject.Find(“Enemy”);

Toutes les variables reference type sont stockées dans le heap. Celles ci sont:

• class (classe, interface, classe abstraite, delegate)
• object
• string (bien qu'il n'y paraisse pas, c'est une instance de la classe String)

Les principales différences entre une variable value type et une variable reference type sont l'addition d'une variable pour pointer vers la donnée et la zone de stockage en mémoire. Cette référence doit d'abord être accéder avant de pouvoir accéder aux données. Cela rend les classes légèrement plus lentes que les structures qui peuvent être accédées directement. L'autre différence entre struct et class, les structures ne peuvent inhériter et sont passées par copie. Cela siginifie que lorsqu'on passe une structure en tant que paramètre d'une fonction, si la structure a une taille de 50 octets, on copie 50 octets de données sur le stack, une classe copie seulement sa variable référence et on peut accéder les données via cette référence.

Un autre problème:

using UnityEngine;
using System.Collections;

public class Memory : MonoBehaviour {
    DogC dogC1 = new DogC();
    DogC dogC2 = new DogC();
    int number1;
    int number2;

    void Update () {
        if(Input.GetKeyDown(KeyCode.Space)){
           number2=number1 = 10;
           number1 = 20;
           print (number1+" "+number2);
           dogC1.name = "Rufus";
           dogC1.age = 12;
           dogC2 = dogC1;
           dogC1.name = "Brutus";
           print (dogC1.name+" "+dogC1.age+" "+dogC2.name+" "+dogC2.age);
        }
    }
}

Vous remarquerez que les deux number sont indépendants, quand l'un change l'autre n'en voit rien.

Par contre, assigner un objet à un autre crée une connection et modifier l'un modifiera l'autre.

La raison est simple, avec dogC2 = dogC1; nous assignons l'adresse de dogC1 dans la variable référence dogC2. L'adresse original de dogC2 est perdue en mémoire et modifier dogC1 ou dogC2 revient au même. Nous avons alors deux références pour la même location.

Temps de vie, Scope et Garbage Collection

Dans le cas d'une variable reference type, le temps de vie est un peu trouble puisque c'est le job du Garbage Collector (GC) de vérifier et retirer la variable si nécessaire. Du temps de C et C++, c'était le boulot du programmeur de s'assurer que les variables allouées dynamiquement soient libérées (la fonction free() en C, ~ et delete en C++).

En C#, le GC vérifie si la variable est encore utilisée ou accessible, si aucune référence  n'est trouvée à partir des codes, il marque l'emplacement comme libre pour être remplacé. Les programmeurs familiers des interface COM ou autre système de décompte des références trouve souvent le GC un peu étrange comme concept. Ceci parce que dans un système de décompte des références, si deux objets se réfèrent l'un l'autre (comme un parent qui a une référence à un child et ce child lui même a une référence à son parent) peut avoir comme résultat que la mémoire n'est jamais libérée. Le GC n'a pas ce genre de problème puisqu'il considére que bien que les deux se réfèrent l'un l'autre, aucun des deux n'est accessible pour le reste du programme.

List<Action> actionsToPerformLater = new List<Action>();

void DisplayAMessage(string message)
{
      var t = System.DateTime.Now;
      actionsToPerformLater.Add(()=>{
          Debug.Log(message + " @ " + t.ToString());
      });
}

void SomeOtherFunction()
{
      DisplayAMessage("Hello");
      DisplayAMessage("World");
      SomeFunctionThatTakesAWhile();
      DisplayAMessage("From Unity Gems");

      foreach(var a in actionsToPerformLater)
      {
           a();
      }

}

En ce qui concerne la portée d'une variable de type référence, elle peut être consultée n'importe où dans le programme à condition d'effectuer l'action appropriée pour la trouver, à l'aide GameObject.Find (), par exemple, qui renvoie une référence à l'objet dans tous les scripts.

Struct vs Class

Laquelle doit on utiliser et dans quelle situations? Nous avons découvert qu'utiliser une classe ajoute une surcharge, la référence. Si nous devions créer un millier d'objets, nous obtenons un milliers de surcharges alors que notre structure n'en a pas.

Voyez cet exemple:

public class DogC{
    public string name { get; set;}
    public int age { get; set;}
}

public struct DogS {
    public string name;
    public int age;
}

using UnityEngine;
using System.Collections;

public class Memory : MonoBehaviour {
    DogC dogC = new DogC();
    DogS dogS = new DogS();

    void Update () {
        if(Input.GetKeyDown(KeyCode.Alpha1))
            Print (dogS);
        if(Input.GetKeyDown(KeyCode.Alpha2))
            Print (dogC);
        if(Input.GetKeyDown(KeyCode.Alpha3))
            print ("Struct: The dog's name is "+dogS.name +" and is "+dogS.age);
        if(Input.GetKeyDown(KeyCode.Alpha4))
            print ("Class: The dog's name is "+dogC.name +" and is "+dogC.age);
     }

    void Print(DogS d){
        d.age = 10;
        d.name = "Rufus";
        print ("Struct:The dog's name is "+d.name +" and is "+d.age);
     }

    void Print(DogC d){
        d.age = 10;
        d.name = "Rufus";
        print ("Class:The dog's name is "+d.name +" and is "+d.age);
    }
}

Tout d'abord, vous remarquerez que la troisième entrée n'imprime pas ce qui est attendu, le nom et l'âge du chien en structure ont disparu. D'autre part, la classe conserve ses valeurs.

Rappelez-vous ce que nous avons dit, une structure est un value type  quand une classe est un reference type. Lorsque vous appelez la fonction avec la structure, nous passons une copie de la structure, mais la copie n'est pas l'original. Lorsque vous modifiez les données, nous  modifions la copies sur la pile. Celle-ci est perdue à la fin de la fonction (nous pouvons retourners la structure en dehors de la fonction qui est alors copiée sur une autre structure).

La classe est passée en utilisant une référence qui peut accéder aux données d'origine et les modifier au sein de la fonction, ces modifications demeure même lorsque la fonction est terminée puisque c'est l'original qui est modifiée.

Qu'est-ce que cela devrait nous faire penser? Si ma structure est vraiment grande avec par exemple 10 variables, quand elle est passée à la fonction, la pile grossit de 10 emplacements. Maintenant, si je passe un tableau de structures avec 50 d'entre elles, la pile a maintenant 500 emplacements, la pile est limitée en taille et un débordement de pile (stack overflow) pourrait arriver si la structure et le tableau sont encore plus grands.

En passant la référence de ma classe, je passe une seule variable. Avec 50 instances, je passe 50 variables seulement.

Donc, les classes économisent de la mémoire, mais les structures sont plus rapides (sauf en cas de boxing sur lequel nous reviendrons plus tard). Donc, il s'agit de trouver un équilibre entre les deux. Envisagez d'utiliser des structures quand vous avez, par exemple de 5 à 8 variables. Au-delà, utiliser une classe.

Vous devez également garder à l'esprit que chaque fois que vous accédez à une variable qui est une structure (par exemple en faisant transform.position, transform est une class qui contient la structure position), vous créez une copie de cette structure sur la pile - cette copie prend du temps pour être créer.

Chaque fois que vous créez une classe vous allouez de la mémoire sur le heap qui va rapidement conduire à un GC  pour les variables rejetées - les structures sont toujours allouées sur la pile et donc ne causeront jamais de Garbage Collection.

Vous remarquerez que dans Unity, les structures sont souvent utilisés pour 3 à 4 variables comme position, color, quaternion, rotation, scale, ..., toutes sont des structures.

Un dernier point avant de passer à la suite, nous avons gardé pour la fin la cerise sur le gâteau. Il est possible de passer une structure par réf´rence pour que nous puissions modifier notre structure originales.

void PrintRef(ref DogS d){
    d.age = 10;
    d.name = "Rufus";
    print ("Structure:Le nom du chien est "+d.name +" et il a "+d.age+" ans.");
}

On appelle la fonction ainsi:

void Update(){
    PrintRef(ref dogS);
    print ("Structure:Le nom du chien est "+d.name +" et il a "+d.age+" ans.");
}

Vous avez remarqué le mot clé ref, cela dit au compilateur de créer une référence à la structure, au lieu de la copier sur la pile. En dehors de la fonction, la structure a gardé les valeurs données à l'intérieur de celle-ci. Ce mot-clé peut être utilisé avec n'importe quelle value type. C# a un deuxième mot-clé similaire out. La différence entre les deux est que out nécessite que la variable soit modifié dans la fonction.

Créer une Référence

Donc, nous venons de voir qu'il est possible de créer une référence à une variable value type. Considérons que nous voulons créer une variabe integer dans une fonction, mais nous voulons la garder pour une utilisation ultérieure. En déclarant simplement à l'intérieur de la fonction la variable automatique est perdue à la fin de la fonction.

Nous pouvons créer une variable allouée dynamiquement qui sera stocké dans le heap avec une référence dans notre script.

using UnityEngine;
using System.Collections;

public class Test:MonoBehaviour{
    int number;

    void Update () {
        if(Input.GetKeyDown (KeyCode.C))
            CreateVariable();
        if(Input.GetKeyDown (KeyCode.Space))
            PrintVariable(number);
    }

    void CreateVariable(){
        //int number = new int();
        number = new int();
        number = 10;
        print ("In function "+number);
    }

    void PrintVariable(int n){
        print (n);
        n+=10;
    }
}

Nous avons d'abord déclaré une variable number de type int qui est global à notre script. Nous utilisons cette variable à l'intérieur CreateVariable et lui attribue une référence à une variable integer  en utilisant new int ();

Pour clarifier cette situation, le mot clé new renvoie une référence à la variable qui est créé dans la section heap. Cette référence est stockée dans number qui contient maintenant l'adresse de la variable nouvellement créée. Utiliser number c'est utiliser indirectement la nouvelle variable.

Considérons la partie commenté, si nous avions fait de cette façon, nous aurions perdu notre référence à la fin de la fonction. Sur son cycle de nettoyage suivant, le garbage collector aurait trouvé notre donnée sans aucune référence et la retirerait de la mémoire. Considérez que lorsque vous déclarez une variable locale, comme nous l'avons fait ici à l'intérieur de la fonction, int number; aurait caché la variable global int number.

Prenons une situation basique de boxing(emboitâge...si cela a un sens...). Lorsque vous utilisez la fonction Debug.Log (objet);, le paramètre est de type object qui signifie que tout type de variable peut être passé à la fonction. Mais en passant un integer, le compilateur va boxer l'integer dans un objet. Il est alors possible d'optimiser le boxing en anticipant le comme ceci:

void PrintingManyTimes(int n){
    object obj = n;
    for(int i = 0;i<500;i++)
        Debug.Log(obj);
}

Static

Nous entrons maintenant dans la dernière partie de notre tutoriel. Encore une fois, si vous avez un passé en C, oubliez ce que vous savez à propos de l'utilisation de static.

Une variable statique en . NET est stockée dans une partie spéciale du heap appelée le heap à haute fréquence (high frequency heap).

Comme nous l'avons mentionné précédemment, nous rencontrons souvent des variables statiques dans des tutoriels pour débutants où seule la facilité d'utilisation est mise en avant. Le gentil tuteur ne prend souvent pas le temps de bien expliquer les avantages et les dangers des variables statiques. Nous allons essayer de clarifier ce qu'est un objet statique, comment l'utiliser, où l'utiliser et l'inverse.

Classes Statiques

Une classe statique est une classe qui ne possède pas d'instanciation d'objet, vous ne pourrez pas créer un objet d'une classe statique.

En conséquence, il n'y a qu'une instanciation et elle est faite par le compilateur. Vous pourriez être confus puisque je viens de dire qu'il ne peut y avoir aucune instance de celle-ci. Le programme alloue de la mémoire dans le heap pour cet objet et ne permettra aucun instanciation par l'utilisateur.

Les objets statiques sont créés à leur premier appel et seront détruits à la fin du programme (ou de son crash ...).

public static class GameManager{
    public static int score;  
    public static float amountOfTime;
}

Notez que si la classe est statique, les membres doivent l'être aussi.

Vous ne pourrez pas créer d'instance de GameManager.

GameManager GM = new GameManager();

renverra une erreur.

Vous pouvez accéder les membres de la classe statique simplement comme ceci:

GameManager.score = 10;

Cela peut se faire n'importe où et n'importe quand dans le programme. Une classe statique et ses membres ont une portée dans chaque fichier et un temps de vie de la durée du programme.

Exemple d'utilisation d'une classe statique

Lors du chargement d'une nouvelle scène, toutes les variables de la scène précédente sont détruites. Si nous voulons préserver une variable comme le score, par exemple, nous pouvons utiliser:

DontDestroyOnLoad(score);

Une grande utilité pour la classe statique réside dans leur temps de vie. Comme elles ne meurent pas, si nous voulons que notre score survive à la nouvelle scène, nous pouvons simplement utiliser une classe statique. À la fin de notre niveau, nous passons la valeur à l'élément statique, à partir de notre nouvelle scène nous pouvons faire l'opération inverse.

if(newLevel){
    GameManager.score = tempScore;
    Application.LoadLevel(nextLevel);
}

Et dans le script du nouveau niveau:

void Start(){
    scoreTemp = GameManager.score;
}

Un petit truc pour cet usage, ne pas utiliser GameManager.score pendant le niveau mais plutot une variable "classique" et seulement en fin de niveau passer les informations vers la statique.

Pensez à un jeu avec 10 niveaux où vous obtenez au maximum 200pts par niveau.

Un joueur termine le jeu en une seule fois et obtient 2000pts.

Un autre joueur termine le jeu en plusieurs coups et obtient 5000pts.

Le second joueur n'est pas aussi bon mais obtient plus de points parce qu'il a essayé chaque niveau plusieurs fois et accumuler des points. Si nous attendons le chargement du niveau suivant pour passer les points à la variable statique, les nouvelles tentatives annulent les points accumulés durant le niveau.

A la sortie du jeu, les données de la classe statique peuvent être envoyé à une sauvegarde, voyez plutot ici.

Variables Statiques

De nombreux débutants font cette erreur:

public static int health;
void Start(){
    health=100;
}

Dans un autre script, vous pourriez trouver:

void OnCollisionEnter(Collision other){
    if (other.gameObject.tag == “Enemy”){
        EnemyScript.health-=10;
        if(EnemyScript.health <=0)Destroy(other);
    }
}

Ils essayent le jeu avec un ennemi et réussissent à le tuer. Mais ils ajoutent plus d'ennemis et se demande pourquoi tout le monde meurt subitement.

La raison en est simple, vous avez plusieurs instances de la classe ennemie (qui n'est pas statique), mais vous n'avez qu'une seule variable health pour toutes les instances. Tuer un, c'est tous les tuer!

En fait, une variable statique déclarée dans une classe n'appartient pas aux objets, mais à la classe elle-même. C'est pourquoi nous y accédons en utilisant le nom de la classe et pas le nom de l'instance.

Cela n'a pas fonctionné pour la santé de l' ennemi parce que chaque ennemi doit avoir sa propre variable health.

Une variable statique de la même façon que la classe statique est instanciée lorsque la classe qui la définit est accédée pour le première fois. Cela signifie que même si il n'y avait aucune instance de la classe dans le jeu, la variable existerait si vous avez essayé d'y accéder.

Considérons un compteur d'ennemi, nous voulons garder la trace de la quantité d'ennemis que nous avons dans le jeu.

static var counter;

public void CreateEnemy(){
    GameObject obj=Instantiate(enemyPrefab, new Vector3(0,0,0).Quaternion.identity);

    if(obj)counter++;
}

public void DestroyEnemy(){
    Destroy(gameObject);
    counter--;
}

Ce script est attaché à chaque ennemi. Ils partagent tous la même variable compteur, même si ils ont tous un script différent.

Grâce à cette fonction dans notre jeu nous pouvons garder une trace de notre compteur d'ennemis. Notez l'utilisation d'une variable de référence, dans le cas où  Instantiate ne réussirait pas à créer l'objet, Instantiate retournerait une référence null. Si nous augmentons notre compteur sans vérifier, si pour quelque raison une instanciation échoue, nous avons un compteur qui tourne mal. Maintenant, si nous utilisons ce compteur à la fin de notre niveau, nous pouvons lancer le nouveau niveau comme tel:

if(counter<=0)Application.LoadLevel(nextLevel);

Sans la vérification, si nous avions un échec, après avoir tué tous les ennemis, nous aurions un compteur de 1, notre jeu a un bug.

Qu'en est-il de notre joueur, puis-je utiliser une variable health statique? Oui, vous pouvez utiliser une variable statique pour la santé du joueur puisqu'il n'y a qu'un seul joueur. De plus, l'accès à une variable statique est plus rapide que l'accès à une variable non-statique.

Lorsque vous appelez le membre d'une instance, le compilateur a besoin d'appeler une petite fonction qui vérifie l'existence de l'objet. C'est logique puisque vous ne devriez pas être en mesure de modifier une donnée qui n'existe pas. Une variable statique existera en toute circonstance. Du coup, la vérification n'est pas utile. Le gain est faible cependant.

Fonctions Statiques

Une fonction statique peut être implémentée dans une classe non statique, dans ce cas, seuls les membres statiques de cette classe peuvent être consultés à l'intérieur de la fonction. Ce qui est logique puisque la fonction statique est appelée par la classe et non par une instance, il serait difficile d'essayer d'accéder à des membres qui ne sont pas sûrs d'être en vigueur.

D'autre part, il est possible de passer des paramètres et vous avez probablement utilisé ce genre de fonction.

Vector3.Distance(vec1.vec2);
vec1.Normalize();

Application.LoadLevel (1);

if (GUI.Button(Rect(10,10,50,50),btnTexture)){}

La liste pourrait s'allonger encore et encore. Notez que le deuxième exemple n'est pas une méthode statique. Elle est appelée par l'instance de vec1 de type Vector3. Les autres exemples montrent que la classe est utilisée pour appeler la fonction statique.

Une fonction statique tend à être plus rapide que les non-statiques pour les mêmes raisons expliquées plus tot avec les variables statiques.

Exemple de fonction d'extension:

Nous voulons créer une fonction pour les tableaux qui prolongeront celles qui existent déjà (OrderBy, Sort, ...), nous pouvons déclarer une fonction statique qui permettra d'étendre la liste.

using UnityEngine;
using System.Collections;

public static class ExtensionTest {

	public static int BiggestOfAll(this int[] integer){
		int length = integer.Length;
		int biggest = integer[0];
		for(int i = 1;i<length;i++){
			if(integer[i]>biggest)biggest = integer[i];
		}
		return biggest;
	}
}

Nous déclarons une fonction statique, voyez comment le paramètre passé est l'instance qui appelle la fonction. En modifiant le type du paramètre, nous pouvons travailler avec d'autres types d'objets.

Déclarons et remplissons un tableau:

using UnityEngine;
using System.Collections;

public class Test : MonoBehaviour {

	int[] array = {1,25,12,120,12,6};

	void Start () {
		print(array.BiggestOfAll());
        }
}

Alors que vous tapez le point après le nom de votre tableau, vous verrez votre nouvelle fonction apparaître dans la liste.

Si vous décidez de créer une fonction plus générique qui accepte n'importe quel tableau quel que soit son type, vous mettriez en place une méthode d'extension statique générique.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public static class ExtensionTest {

	public static T TypelessBiggestOfAll<T>(this T[] t){
		int length = t.Length;
		var biggest = t[0];
		for(int i = 1;i<length;i++){
			biggest =((Comparer<T>.Default.Compare(t[i], biggest)>0)?t[i]:biggest);
		}
		return biggest;
	}
}

Notez l'ajout de l'aide System.Collections.Generic;. Comme le compilateur ne sais pas quel est le type de T, on ne peut pas se contenter de comparer les valeurs avec < ou >. Mais nous pouvons utiliser Compare <T>. Dans l'exemple, l'opérateur ternaire est utilisé. Il tend à rendre le code un peu déroutant au début, mais  aussi à sauver quelques lignes.

Il est maintenant possible de déclarer différents types de tableaux et utiliser la même fonction.

using UnityEngine;
using System.Collections;

public class Test : MonoBehaviour {

	int[] arrayInt = {1, 25, 12, 120, 12, 6};
	float[] arrayFl = {0.5f, 52.456f, 654.25f, 41.2f};
	double[]arrayDb = {0.1254, -15487.258, 654, 8795.25, -2};

	void Start () {
		print(arrayInt.TypelessBiggestOfAll());
		print (arrayFl.TypelessBiggestOfAll());	
		print (arrayDb.TypelessBiggestOfAll());
       }
}

Cela imprime  120, 654.25, 8795.25 .

De nombreux utilisateurs de Unity posent des questions sur la façon de contraindre un objet à l'intérieur d'une zone. Par exemple si vous voulez garder un objet à l'intérieur de l'écran, vous pouvez restraindre la transform de cet objet à l'aide de cette fonction:

using UnityEngine;
using System.Collections;

public static class GameManager{

	public static void ClampTransform(this Transform tr,Vector3 move, Vector3 min, Vector3 max){
		Vector3 pos = tr.position + move;
		if(pos.x < min.x ) pos.x = min.x;
		else if(pos.x > max.x) pos.x = max.x;

		if(pos.y  < min.y ) pos.y = min.y;
		else if(pos.y> max.y) pos.y = max.y;

		if(pos.z < min.z) pos.z = min.z;
		else if(pos.z > max.z) pos.z = max.z;

		tr.position = pos;
	}
}

Et voici comment l'utiliser sur n'importe quel objet:

Vector3 minVector = new Vector3(-10,0,-10);
Vector3 maxVector = new Vector3(10,0,10);
transform.ClampTransform(move,minVector,maxVector);

Dans cet exemple, l' objet est restreint dans un environnement 2D (y reste 0) dans un carré de 20*20  cenntré à (0,0,0).

Heap Fragmentation, Garbage Collection et Object Pooling

Le heap est une grande zone de mémoire dans laquelle les données sont stockées de manière aléatoire. En fait, elle n'est pas si aléatoire, l'OS va se pencher sur la mémoire et rechercher la première zone assez grande pour accueillir les données requises. La taille et l'emplacement du heap varie en fonction de la plate-forme que vous avez sélectionné.

Par exemple, lorsque nous demandons un integer, le système d'exploitation recherche 4 octets consécutifs de mémoire libre. Le fait est que pendant que le programme s'exécute, les emplacements de mémoire sont utilisés et  libérés sans véritable logique et votre programme pourrait se retrouver avec une fragmentation du heap.

Notez qu'aucune donnée n'a été ajoutée, il ya à la fin la même quantité de données qu'au state1. Seuls les mouvements ont créé une fragmentation du heap.

Une solution pour le programmeur peut être d'utiliser l'object pooling. Au lieu de détruire notre data3 en state1 nous la désactivons pour une utilisation ultérieure. Cela aurait évité notre fragmentation du heap.

Nous n'avons pas à détruire les données, nous les conservons inactives et en cas de besoin, nous les réveillons.

Il y a de nombreux avantages pour cette solution, tout d'abord nous évitons le cas vu plus haut d'appel du GC et de remaniement de la mémoire, d'autre part nous avons également éviter d'appeler Instantiate et Destroy, nous avons seulement besoin d'utiliser gameObject.SetActive(true / false);

Enfin, puisque nous ne détruisons pas, nous n'appelons pas le garbage collector qui est une action coûteuse.

ObjectScript.cs
using UnityEngine;
using System.Collections;

public class Test : MonoBehaviour {
	public GameObject prefab;
	GameObject[] objectArray = new GameObject[5];  
        public static int counter; 

         void Start(){
		for(int i = 0;i<objectArray.Length;i++){
			objectArray[i] = (GameObject)Instantiate(prefab,new Vector3(0,0,0),Quaternion.identity);
			objectArray[i].SetActive(false);
		}
        }
        void Createobject(){
		if(counter < objectArray.Length){    
                // iterate through array
			for(int i = 0;i<objectArray.Length;i++){  
                                // Find an inactive object                                     
				if(!objectArray[i].active){    
                               // Increase the counter, activate the object, position it                                              
					counter++;					                            
					objectArray[i].SetActive(true);	           
					objectArray[i].transform.position = new Vector3(0,0,0);  
					return;
				}
			}return;
		}else return;
	}
}
void OnCollisionEnter(CollisionEnter){
    if(other.gameObject.tag=="Object"){
        other.gameobject.SetActive(false);       //Deactivate the object
        ObjectScript.counter--;                        //Decrease counter

La scène n'a jamais  plus de 5 objets en même temps, quand l'un est désactivé, il peut être réactivé quand nous le voulons. Le GC n'est pas nécessaire.

Vous pouvez utiliser cette astuce pour vos ennemis, si vous avez une vague d'ennemis venant à vous, au lieu de détruire un ennemi tué, repositionnez-le à l'arrière, vous êtes sur le point de tuer le même gars plusieurs fois sans vous en apercevoir.

Idem pour vos munitions, au lieu de détruire chaque balle que vous ou les NPC tirez  (Non-Player-Character, les objets guidés par IA) , désactivez-les. Réactivez-les quand vous tirez à nouveau avec la position en face de votre arme et la vitesse adéquate.

Notez que pooling quand on parle de mémoire est un processus différent géré par le système d'exploitation qui consiste à réserver toujours la même quantité de mémoire quelle que soit la taille de l'objet. En conséquence, il n'y aura jamais de petits emplacements de mémoire discéminés en mémoire.

Réutilisation des tableaux

En plus de la réutilisation des objets, il est également utile d'envisager la création de zones tampons qui sont réutilisées par votre code entre les différentes demandes ou répétées dans le même appel.

void Update()
{
      if(readyToFire && Input.GetKeyDown(KeyCode.F))
      {
          var _cinqPlusProches = new Enemy[5];

          //Faire quelque chose pour remplir une liste d'ennemies

          TargetEnemies( _cinqPlusProches);
      }
}

Dans cet exemple, nous ciblons les 5 ennemis les plus proches  et nous tirons une arme automatique dans leur direction. Le problème est que nous allouons de la mémoire chaque fois que nous appuyons sur le bouton de tir. Si, au contraire, nous avions fait un tableau avec une longue durée de vie pour les ennemis que nous pouvons utiliser n'importe où dans notre code, nous n'aurions pas  à allouer de la mémoire et donc d'éviter le ralentissement.

Voici un exemple simple:

Enemy[] _cinqPlusProches = new Enemy[5];

void Update()
{
      if(readyToFire && Input.GetKeyDown(KeyCode.F))
      {
          //Faire quelque chose pour remplir une liste d'ennemies

          TargetEnemies( _cinqPlusProches);
      }
}

Mais peut-être que nous pourrions faire encore plus générale, si nous avons souvent besoin de tableaux d'ennemis:

Enemy[] _enemies = new Enemy[100];

void Update()
{
      if(readyToFire && Input.GetKeyDown(KeyCode.F))
      {
          //Faire quelque chose pour remplir une liste d'ennemies

          TargetEnemies(_enemies, 5);
      }
}

En réécrivant notre code pour TargetEnemies, on peut effectivement utiliser un tampon à usage général pour les ennemis partout dans notre code et d'éviter des allocations inutiles.

Conclusion

Nous arrivons à la fin de notre article. Nous voila en mesure de mieux comprendre comment la mémoire de notre ordinateur fonctionne et plus particulièrement sous Unity et le .NET framework.

Nous avons aussi abordé comment et où utiliser des cas statiques en prenant en compte qu'ils ne fonctionnent pas pour tous les cas d'objets.

Voici deux vidéos qui démontrent des cas traités dans cet article Use of static variables et Demonstration of Memory Management (en anglais).

You should read this article if:

• You'd like a way to find all of the transforms with GameObject.FindGameObjectsWithTag() rather than the game objects themselves
• You need to manipulate, sort and change the types of lists and arrays but always seem to write too much code
• You've heard of LINQ but don't know how it works
• You don't believe me when I say I can write a single line of code that returns all of the materials on the renderers on the five tagged objects nearest to a target! (or anything else seemingly as complex)

Introduction

LINQ stands for Language Integrated Native Query and in .NET it's a way of writing things that look like database queries but work on objects.  It's very powerful and, when you get your head around it, very easy to use.

In C# you can actually write things that look very like SQL statements:

var transformsWithTag = from go in GameObject.FindGameObjectsWithTag("YourTag") 
     where Vector3.Distance(go.transform.position - transform.position) < 100
     select go.transform;

But we'll be using the function based approach with is much more powerful and, I believe more readable.

The Power Of Enumerations

So Linq is a way of making an enumerator that enumerates an existing enumerable collection but changes it as it goes.  So you can use Linq on anything that is an array, a list, a dictionary - basically a collection of any kind.  Note that as a Linq function returns an enumeration - you can chain them together - and therein lies the power.

Linq lets you write a series of functions that manipulate the  collection. Supplying your own code in the form of anonymous functions.

Let's get into it.

Enabling LINQ

To use Linq you need to add an import or a using directive to your source code.

//C#
using System.Collections.Generic; //Always a good idea
using System.Linq;

//JavaScript
import System.Linq;

That's it!

A First Linq Statement

So let's do something simple - lets make an array of all of the transforms associated with game objects returned by GameObject.FindGameObjectsWithTag.

• Find all the game objects
• Select the transform from the game object
• Turn the result into an array

//C#

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(go => go.transform)
    .ToArray();

//Javascript

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(function (go) go.transform)
    .ToArray();

So notice how we use an anonymous function to do the selection work we want.   Select says take the current thing in the enumeration (at this point a game object), call it whatever (in our case go) and then return the result of some calculation (in our case get the transform) and then ToArray runs the whole job and puts the results into an array.

In C# we use a Lambda function: go => go.transform, and in JavaScript we use an anonymous function: function(go) go.transform

We aren't limited to a single statement in that function either!  We can put { and } and type any amount of code we like... More on this later.

Performing a Query

Ok so the Q is Query - let's do something that asks a question.  Let's get all of the transforms for the objects within 10 world units of the current position.

//C#

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(go => go.transform)
    .Where(t => Vector3.Distance(t.position - transform.position) < 10
    .ToArray();

//Javascript

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(function (go) go.transform)
    .Where(function (t) Vector3.Distance(t.position - transform.position) < 10)
    .ToArray();

So we've put our Where function after the select - so the enumeration is already an enumeration of Transforms - our Where anonymous function must return true or false so we make a simple test of the distance from the transform in the enumeration to our current transform.

Performing a Sort

Ok, let's imagine that some of our objects will have a script attached called Danger and that this script contains a float variable with a value called dangerLevel.  Let's sort our list of transforms by this danger level (if it exits, otherwise let's say they really aren't dangerous at all).

//C#

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(go => go.transform)
    .Where(t => Vector3.Distance(t.position - transform.position) < 10
    .OrderByDescending(t => {
       var danger = t.GetComponent<Danger>();
       return danger ? danger.dangerLevel : 0;
      })
    .ToArray();

//Javascript

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(function (go) go.transform)
    .Where(function (t) Vector3.Distance(t.position - transform.position) < 10)
    .OrderByDescending(function (t) {
          var danger = t.GetComponent(Danger);
          return danger ? danger.dangerLevel : 0;
         })
    .ToArray();

So we've added an OrderByDescending (sort them top to bottom).  We've also written a multi line function, because first we needed to get the component and then use one of its values.  You see how easy that was?  It's just like a normal function.

Right cool - but what about if we then also wanted them sorted by proximity - danger then proximity being the important factor?

//C#

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(go => go.transform)
    .Where(t => Vector3.Distance(t.position - transform.position) < 10
    .OrderByDescending(t => {
       var danger = t.GetComponent<Danger>();
       return danger ? danger.dangerLevel : 0;
      })
    .ThenBy(t => Vector3.Distance(t.position, transform.position)
    .ToArray();

//Javascript

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .Select(function (go) go.transform)
    .Where(function (t) Vector3.Distance(t.position - transform.position) < 10)
    .OrderByDescending(function (t) {
          var danger = t.GetComponent(Danger);
          return danger ? danger.dangerLevel : 0;
         })
    .ThenBy(function (t) Vector3.Distance(t.position, transform.position)
    .ToArray();

You can chain as many ThenBy and ThenByDescending as you like (note we should have used sqrMagnitude for performance reasons as the order is the same, but for clarity, we'll keep it as Vector3.Distance).

Drilling Down

You can also use LINQ to drill into the contents of a collection which is the member of an item in the list.

In our previous example we were returning the transform of all of the items found by tag - what if for some reason we wanted all of their renderers, in them and all of their descendants in the hierarchy?  That's where SelectMany comes in:

//C#

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .SelectMany(go => go.GetComponentsInChildren<Renderer>())
    .ToArray();

//Javascript

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .SelectMany(function (go) go.GetComponentsInChildren(Renderer))
    .ToArray();

SelectMany makes the collection a concatenation of all of the collections returned by it, so after our SelectMany the array will contain all of the renderers on all of the items.

Linq inside Linq

Let's say that last example wasn't what we wanted - let's say we wanted the renderer on the object and only its immediate children - still simple, but we will use a Linq statement inside a Linq statement...

//C#

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .SelectMany(go => go.transform.Cast<Transform>()
       .Select(t=>t.renderer)
       .Concat(new [] { go.renderer })
       .Where(r=>r!=null)
     )
    .ToArray();

//Javascript

var transformArray = GameObject.FindGameObjectsWithTag("MyTag")
    .SelectMany(function (go) go.transform.Cast.<Transform>()
         .Select(function (t) t.renderer)
         .Concat([go.renderer])
         .Where(function (r) r != null)
     )
    .ToArray();

So we get the transform and cast it to be a collection of Transforms (it's a weirdness in Unity that it isn't that by default, as it's capable of getting all of its children).  Then we select the renderer from each child and concatenate that enumeration with an array containing the renderer of the parent, then we only allow through the ones that aren't null.

Job done.

Finding the Closest Object

Ok so there are a couple of ways we could find the closest object - here's the inefficient one:

//C#

var closestGameObject = GameObject.FindGameObjectsWithTag("MyTag")
    .OrderBy(go => Vector3.Distance(go.transform.position, transform.position)
    .FirstOrDefault();

//Javascript

var closestGameObject = GameObject.FindGameObjectsWithTag("MyTag")
    .OrderBy(function (go) Vector3.Distance(go.transform.position, transform.position))
    .FirstOrDefault();

So here we order the collections by the distance and we get the FirstOrDefault one.  FirstOrDefault will return null if there are no objects in the list - you can also use First but it will throw an exception if there aren't any items.

The problem with this is that we had to sort the list - that takes time, especially when we only want the closest object.

We can use the generic Aggregate function to mean we don't have to do that:

var closestGameObject = GameObject.FindGameObjectsWithTag("MyTag")
   .Aggregate((current, next)=> Vector3.Distance(current.transform.position, transform.position) < Vector3.Distance(next.transform.position, transform.position) 
      ? current : next);

//Javascript

var closestGameObject = GameObject.FindGameObjectsWithTag("MyTag")
     .Aggregate(function(current, next) Vector3.Distance(current.transform.position, transform.position) < Vector3.Distance(next.transform.position, transform.position) 
        ? current : next);

So this only runs through the list once, each step it works out the closest of the two candidate items and returns that.  It only passes the list once.  In C# you can optimise this a bit using anonymous classes too (doesn't work anywhere near as well in JavaScript so I'll leave it out).

//Optimal C#
var currentPos = transform.position;    //Cache it - it's expensive!
var closestGameObject = GameObject.FindGameObjectsWithTag("MyTag")
   .Select( go => new { go = go, position  = go.transform.position })
   .Aggregate((current, next)=> 
      (current.position - currentPosition).sqrMagnitude <
      (next.position - currentPosition).sqrMagnitude
      ? current : next).go;

So in our first Select we just made up a new class with two members - go and position - that's what's in the enumeration now.  Then we use that cached position to work out which is closer (using the optimal sqrMagnitude method to avoid an expensive square root).  At the end we have the closest object, but it's now our anonymous class, so we convert it to a game object by taking the go variable.

Lists and Dictionaries

So we aren't limited to making arrays - we can make a list using .ToList() and we can make a Dictionary too!

Dictionaries clearly have a key so let's see how we make that...  Let's find all of the game objects in our scene with a tag and put them into a dictionary based on that tag:

//C#

var lookupByTag = GameObject.FindObjectsOfType(typeof(GameObject))
     .Cast<GameObject>()
     .Where(go=>!string.IsNullOrEmpty(go.tag))
     .ToLookup(go => go.tag);

//JavaScript

var lookupByTag = GameObject.FindObjectsOfType(GameObject)
    .Cast.<GameObject>()
    .Where(function (go) go.tag != "")
    .ToLookup( function (go) go.tag );

This creates a special sort of dictionary that we can access a list of game objects from with lookupByTag["SomeTag"]

We could create an ordinary dictionary perhaps of GameObject to distance (plug in a game object and it returns its distance from the target point).  This would be very fast if we continually needed to know that due to some calculation that ran on many game objects.

//C#

var objectToDistance = GameObject.FindObjectsOfType(typeof(GameObject))
     .Cast<GameObject>()
     .ToDictionary(go=>go, go=>Vector3.Distance(go.transform.position, transform.position));

//Get the distance of a GO later:

var distance = objectToDistance[someGameObject];

Notice the first parameter in ToDictionary is a key and the second is what we want in the dictionary values.  So this is returning a Dictionary<GameObject, float>.

Conclusion

So hopefully this first introduction has shown you some handy tips for using Linq to get going with list manipulations.  We'll explore more next time, because more there is!

Answers

You don't believe me when I say I can write a single line of code that returns all of the materials on the renderers on the five tagged objects nearest to a target!

var materials = GameObject.FindGameObjectsWithTag("sometag").Select(r=>r.renderer).Where(r=>r!=null).OrderBy(r=>(r.transform.position - transform.position).sqrMagnitude).Take(5).SelectMany(r=>r.materials).ToList();

foreach(var m in materials) m.color = Color.red;

Can you think of the English sentence which is grammatically correct and contains the word "and" five times in a row?

There is a man painting a pub sign for the "Pig and Whistle" pub.  The landlord walks outside, looks at the sign and says to the painter: "You need to leave more space between the Pig and 'and' and 'and' and Whistle."

Motivation:

You want to develop your first game, probably a zombie game or a Slender-like game (See below about this) and you are doing so. But hell on earth when you see that zombie getting through the trees and passing walls, they are zombies not ghosts. You go through your codes and the components of your zombie and everything seems fine, you even check the walls. Well, let me tell you something, everything is not fine or it would work  (Thank you Captain Obvious!!).

In this tutorial we will go through the basics of moving an NPC (Non-Player-Character) around, how to give him a little bit of reaction depending on its environment and how to implement a second FSM a little more developed than the one you may have seen in the Space Shooter tutorial but also more accessible than the one you will see in the FSM tutorials. Also you will have a little first peek at pathfinding algorithm.

• Starting with our NPC
• Adding waypoints
• Adding patterns
• Introduction to delegate
• Come closer (checking range)
• I can see you (Line of sight)

Starting with our NPC

You can learn the basics of CC with this video:

The CC is simply a complex component that helps in many ways to get collision detection without using a rigidbody. It is mainly composed of a capsule that wraps the player and detects and reports collision.

Using CC on your NPCs  and they will bump onto any colliders the world has to offer.There will be situations where CC could not be the best of solutions, for instance if you are trying to recreate a Mario Galaxy environment where gravity is constantly switched, that won't do. If you played a game like Prey (2006), the player was able to walk on the wall, CC won't do either. One major issue with CC is the fact that it does not react to physics, so you would have to do that by script. But in many cases, you are good to go with it.

You attach it to your NPC and first thing you do in your script is fetch the CC so that you can manipulate it. For  a tutorial on how and why fetching component, see here. We also make sure our object contains a CC using an attribute placed before the class.

[RequireComponent (typeof (ScriptB))]

Here is what you do:

using UnityEngine;
using System.Collections;

// This below is an attribute that ensures a CC is attached to the object and cannot be removed
// Try and remove the CC component from the object to see the result.
[RequireComponent (typeof (CharacterController))] 
public class AIScript : MonoBehaviour {
   CharacterController _controller;
   Transform _transform;

   void Start(){
      _controller = GetComponent<CharacterController>();
      _transform = GetComponent<Transform>();
   }
}

Using our _controller variable, we are in control of the Character Controller (what an awkward sentence that is...). The second line is just a cache of the Transform component for optimization.We shall get our NPC to move.

float speed = 5f;
float gravity = 20f;
Vector3 moveDirection;

void Update(){
    moveDirection = _transform.forward;
	moveDirection *= speed;
	moveDirection.y -= gravity;
	_controller.Move(moveDirection * Time.deltaTime);
}

Hold on a second before rushing into scripting as this is not about to do much good yet. The script above is pretty much taken from the Unity CC docs, we have a moveDirection vector3 that gets the forward of the object, each member is multiplied by the speed and the y member receives the gravity so that our NPC is constantly affected by "real " gravity as it is in the update. Finally, we call the Move method from the CC class to which we pass our moveDirection vector. Time.delatTime is just there to make our game frame independent.

For the time being our NPC only go straight forward, if you intend to develop a not-so-fun game that will be just fine. For any other purpose,  we need to get our NPC turning around. Here is the tutorial that will get you through this all so I will simply apply what is there in here:

Vector3 target;
float maxRotSpeed = 200.0f;
float minTime = 0.1f;
float velocity;

void Update () {	
//Previous moving codes	
	var newRotation = Quaternion.LookRotation(target - _transform.position).eulerAngles;
	var angles = _transform.rotation.eulerAngles;
	_transform.rotation = Quaternion.Euler(angles.x, 
		Mathf.SmoothDampAngle(angles.y, newRotation.y, ref velocity, minTime, maxRotSpeed),
	        angles.z);
}

The idea is that we create a quaternion vector from the NPC to the target that we convert to euler angles, so from quaternion vector to Vector3 vector. Then we convert our current rotation to eulerAngles.  Finally, we smoothly move from our current rotation to the target rotation with SmoothDampAngle. Our x and z rotations are not changing.

You will still have to be patient, we are missing some details  to get our guy going. But what we have here is the basics of moving our CC. We are only missing a target. Keep in mind our guy is stupid. He does what he is told to and we are about to tell him to go there (and he will, trust me). Next part we assign a value to target so that our NPC will use it as....target.

To make the reading easier, I will turn the two parts (moving and rotating) we have into one Move() function.

Let's get our NPC to move around with a simple script. :

bool change; 
float range;
void Start () {
   range = 2f;
   target = GetTarget();
   InvokeRepeating ("NewTarget",0.01f,2.0f);
}
void Update () {		
   if(change)
       target = GetTarget ();

   if(Vector3.Distance(_transform.position,target)>range){
      Move();
      animation.CrossFade("walk");
   }else animation.CrossFade ("idle");
}
Vector3 GetTarget(){
   return new Vector3(Random.Range (0,300),0,Random.Range (0,300));
}
void NewTarget(){
   int choice = Random.Range (0,3);
   switch(choice){
      case 0: 
         change = true;
         break;
      case 1: 
         change = false;
         break;
      case 2:
         target = _transform.position;
         break;
   }	
}

Our AI does not think, so we need to tell it where to move. For this purpose, the function GetTarget() is used. It simply returns a Vector3 that we assign to the target variable.

Notice the NewTarget function called with InvokeRepeating (for explanation on Invoke functions see here) that will simply decide if we assign a new target or not. It uses a random number between 0 and 2 and uses that number in a switch to decide the behavior.

• 0, we get a new target
• 1, we continue with the previous target
• 2, we stop and wait

The movement of the NPC is based on the distance to the target. If we are not close enough (>range), the NPC moves towards the target, if we are close enough, it waits. That is why on case 2, the transform.position is provided to the target, so that the NPC is close enough and wait. In the case of movement, the walking animation is played, in case of resting, the idle animation is played.

For this first AI our FSM looks like the picture next:

The picture tells us that the decision center (NewTarget function) defines the next action. Notice that the decision does not choose to walk, it only decides to provide a target. The Update will create the displacement using the target.

This kind of AI is not likely to be good enough for a “Human” NPC but is fairly good enough for any kind of animals. For instance, you could use this kind of script for a boar wandering in the forest. There is still one issue, on our terrain there is no particular environment threats. But what if there were a cliff or a lake, you do not want the NPC to get there, it would not look natural. To prevent this kind of happenings, we simply provide the NPC with a set of predefined targets.

Also, another issue that will come up pretty quick is the relief of your terrain. As you are assigning random values and in our case we kept y at 0, it means this algorithm is fine for flat terrain only. Simply think your relief goes at y = 10, which is just a tiny little hill, still you are too far from the point at 0, your character would never get below the range to switch target. Otherwise, you would have to increase the range but then again, that is not really good.

Adding waypoints

So the idea here is simple, we won't let our NPC go around freely. We provide a set of point that will be where the NPC goes and nowhere else. Consider a warden that walks around a building and nothing else. You place four point around the building and you let him know that his only duty is to walk from point A to B, then B to C, C to D and finally back to A and there you go again, A to B and so on. Not the best AI but we do not want smart AI yet.

On top of that since you are manually placing the waypoints if the relief would go up and down, you would have to place it at the level of the ground. For  the rest let the CC do its job.

On the picture above the waypoints A and B are at different y positions. The green line represent the actual path your CC will take. It just makes sense that since we are applying constant gravity , the CC just goes towards the target but follows the relief curve.

Let's first talk a little about the design. We could easily create an array of Transform to store our waypoints and manually assign waypoint A to 0, waypoint B to 1 and so on. Well, that doe snot sound really efficient to me. Particularly if we have hundreds of waypoints. We need to figure out a way that allows us to make our script universal, that is, for any amount of waypoint and also any waypoint grid.

First thing we do is define our waypoint. We need them to get an index in order to know which is first and second and so on. Well, let's add:

using UnityEngine;
using System.Collections;

public class WaypointScript : MonoBehaviour {

   bool used;
   public bool GetUsed(){
      return used;
   }
   public void SetUsed(bool b){
      used = b;
   }
   public float radius = 0.5f;
   void OnDrawGizmosSelected() {
        Gizmos.color = Color.red;
        Gizmos.DrawSphere(transform.position, radius);
    }
}

Attach that to the waypoint prefab.When placing a waypoint on the map, if the waypoint is selected in the hierarchy that will show a little red ball. It is now easier to see where is our waypoint. I suggest you add an empty game object and add the waypoint as children. It will keep your hierarchy clean and selecting the parent object will show the whole path. Now give a tag to the waypoint and start duplicating our waypoint to create a path.The tag is the name of our path. So you can create a second different path simply giving a different tag.

Only little special point, make sure the next node is always the closest one, let make clarify this (if possible), the distance between two consecutive nodes should always be smaller than the distance between the node and any other. That is if you have nodes A, B, C, D and E (in order), make sure B is the closest to A, then C is the closest to B, D the closest to C and finally E does not really matter since it is the last one remaining but as it will close the path do not make it closer to A than B would be (I probably lost half of you already...). Also, make sure the waypoints are placed above ground (not too high though).

Now we need a component that will create the different paths and will share them with the NPCs that need them. Create a new script called "PathScript" and attach it to an empty game object that we call "PathObject".

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class PathScript : MonoBehaviour {

   public GameObject[]start;
   Dictionary<string,List<Transform>>path = new Dictionary<string, List<Transform>>();

   void Awake () {
      string str = null;
      for(int i = 0;i<start.Length;i++){
         int index=0;
         str = start[i].gameObject.tag;
         GameObject [] gos = GameObject.FindGameObjectsWithTag(str);

         List<Transform> waypoints = new List<Transform>();
         waypoints.Add (start[i].transform);
         start[i].gameObject.GetComponent<WaypointScript>().SetUsed(true);
         while(true){
            Transform closest = FindClosest(waypoints[index],gos);
            if(closest != null)
               waypoints.Add (closest);
            if(++index >= gos.Length)break;
         }
         path.Add (str,waypoints);
     }	
   }

   Transform FindClosest(Transform start, GameObject[] obj){
      int layerMask = 1 << 2;
      layerMask = ~layerMask;
      Transform closest = null;float distance = Mathf.Infinity;
      foreach(GameObject go in obj){
         WaypointScript sc = go.GetComponent<WaypointScript>();
         if(start!=go.transform && !sc.GetUsed()){
            if(!Physics.Linecast (start.position,go.transform.position,layerMask)){
               float dist = (start.position - go.transform.position).magnitude;
               if(dist < distance){
                  distance = dist;
                  closest = go.transform;
               }
            }
         }
      }
      if(closest != null){
         closest.gameObject.GetComponent<WaypointScript>().SetUsed (true);
      }
      return closest;
   }

   public List<Transform> GetPath(string str){
      return path[str];
   }
}

This is a little bit of a first step into pathfinding. We have the Awake function that creates a public GameObject array. What you need to do is simply drag and drop the starting waypoint of your path into the slot and that is it for now actually, the rest is done for you.

The script gets the tag of the waypoint you gave, then find all waypoints with similar tag and place them in an array.  A list of Transform is created and the starting waypoint is added and remember the used boolean in our waypoint script, we set it to true so that we won't use that waypoint again. Then starts a loop that will take the latest node placed in the list and compare it with all other waypoints. The closest is return and placed in the list, then we start again until we have no more waypoint. The resulting list is placed in a Dictionary of string and List of Transform so that we have a way to retrieve our list with a name.

Pffff, next the FindClosest method: well no biggie here, simply we get our latest node from the list and we iterate through the array checking if the waypoint is not used already, if it is not hidden from the latest node (Linecast) and finally if it is the closest. We then have the GetPath method that uses the string parameter to retrieve the path from the dictionary. That simple!!!

Note that the FindClosest method is a simplified version of pathfinding method , greatly simplified I agree, but the idea is still there, comparing a node with other nodes and returning the closest one.

Now how do we provide our path to our NPCs?

In the code snippet below, I added a public string strTag;, this variable is showing in the inspector of teh NPC and allows you to provide the name of the path you want the NPC to follow. The name is actually the tag given. Remember that our path is made of waypoints and those waypoints have a common tag representing the path name. This is what you need to provide to the strTag of the NPC for it to find the path. Hopefully I made myself clear enough...

Waypoint code snippet

using UnityEngine;
using System.Collections;
//Added namespace
using System.Collections.Generic;

[RequireComponent(typeof(CharacterController))]
public class AIScript : MonoBehaviour
{
    //Cached variables
    CharacterController _controller;
    Transform _transform;

    //Movement variables
    float speed = 5f;
    float gravity = 100f;
    Vector3 moveDirection;
    float maxRotSpeed = 200.0f;
    float minTime = 0.1f;
    float velocity;
    //Added variables
    float range;
    List<Transform> waypoint;
    int index;
    public string strTag;

    void Start()
    {      
        _controller = GetComponent<CharacterController>();
        _transform = GetComponent<Transform>();

        index = 0;

        //Added codes
        if (string.IsNullOrEmpty(strTag))
            Debug.LogError("No waypoint tag given");
        range = 2.5f;
        waypoint = GameObject.Find("PathObject").GetComponent<PathScript>().GetPath(strTag);
    }

    void Update()
    {
        if ((_transform.position - waypoint[index].position).sqrMagnitude > range)
        {
            Move(waypoint[index]);
            animation.CrossFade("walk");
        }
        else NextIndex();
    }

    void Move(Transform target)
    {
        // Movement
        moveDirection = _transform.forward;
        moveDirection *= speed;
        moveDirection.y -= gravity;
        _controller.Move(moveDirection * Time.deltaTime);
        //Rotation
        var newRotation = Quaternion.LookRotation(target.position - _transform.position).eulerAngles;
        var angles = _transform.rotation.eulerAngles;
        _transform.rotation = Quaternion.Euler(angles.x,
         Mathf.SmoothDampAngle(angles.y, newRotation.y, ref velocity, minTime, maxRotSpeed), angles.z);
    }

    void NextIndex()
    {
        if (++index == waypoint.Count) index = 0;
    }
}

So what is new? Notice the required namespace at the top for using our List. Then we have a public string that needs to be given a value. Do that in the inspector.

if (string.IsNullOrEmpty(strTag))Debug.LogError("No waypoint tag given"); ensures a string is given. If none the game won't start.

We declare our  List<Transform> waypoint ;  note that it is only a reference but no memory is allocated. This way each NPC has a reference but only one path exists in memory instead of having duplicated paths for each NPC.

The Update has changed a little and we have a new function:

void Update()
{
    if ((_transform.position - waypoint[index].position).sqrMagnitude > range)
    {
        Move(waypoint[index]);
        animation.CrossFade("walk");
    }
    else 
        NextIndex();
}
void NextIndex()
{
     if (++index == waypoint.Count) index = 0;
}

So the update is not using Vector3.Distance anymore. We try to optimize our game so we gave up this function as it uses square root internally and square root is a little bad since it is a recursive function. Using squared magnitude we avoid the square root but we now need to keep in mind that all values will squared. So when we want to check if the distance is 2 we need to check for 4 (2*2). (Keep in mind that processors nowadays performs those actions real fast so this is tiny optimization but still it is )

NextIndex(); simply increase the index until it is equal to the waypoint.Count. It is then set to 0 to avoid out of bound and close our path.

Adding patterns

In the previous part we told our NPC to walk around and he now does. We could also tell him to do other actions in between. Instead of blindly go from A to B, then B to C (damn there he goes again...) and so on, we now tell him go from A to B but when you are there wait a while and do something (in our case he will do a victory animation), then continue. And maybe just wait a while when you reach another waypoint. Well, feel free to make him do whatever you want.

Actually, what the NPC will do will mainly depend on the animations you have under your sleeves. If you had a bench on the way, you could develop an animation with the NPC sitting down for a sec and continuing. You can even get him moonwalking if you fancy, again it has no limit but your imagination (and what you want your game to look like). Avoid the moonwalk tip if you plan on doing a zombie game or the next Call of Duty...

What we need to do is prepare some function we want to call in the appropriate moment. Let's see first our FSM.

As stated previously, nothing fancy, we are progressing slow. Our guy walks, reaches the waypoint and then depending on which waypoint he is on, we launch an action. Note that waypoints 2 and 3 will not do anything.

The action are a simple victory animation, you can use any animation you want instead, you can also add other states. The Wait state is just an IEnumerator function that waits 2 sec on an idle animation.

Now the code:

Pattern code snippet

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

[RequireComponent(typeof(CharacterController))]
public class AIScript : MonoBehaviour
{
    // Cached variables
    CharacterController _controller;
    Transform _transform;

    //Movement variables
    float speed = 5f;
    float gravity = 100f;
    Vector3 moveDirection;
    float maxRotSpeed = 200.0f;
    float minTime = 0.1f;
    float velocity;
    float range;

    //Waypoint variables
    List<Transform> waypoint;
    int index;
    public string strTag;

    //Added variables
    bool walking, waiting, victoring;
    bool isWaiting, isVictoring;

    void Start()
    {
        _controller = GetComponent<CharacterController>();
        _transform = GetComponent<Transform>();
        if (string.IsNullOrEmpty(strTag)) 
            Debug.LogError("No waypoint tag given");
        index = 0; 
        range = 4;

        waypoint = GameObject.Find("PathObject").GetComponent<PathScript>().GetPath(strTag);
        //Added codes
        walking = true; waiting = false; victoring = false;
        isWaiting = false; isVictoring = false;
        animation["victory"].wrapMode = WrapMode.Once;
    }

    void Update()
    {
        if (walking)
        {
            if (!isWaiting && !isVictoring)
                Walk();
        }
        else if (victoring)
        {
            StartCoroutine(Victory());
            victoring = false;
        }
        else if (waiting)
        {
            StartCoroutine(Wait());
            waiting = false;
        }
    }

    void Walk()
    {
        if ((_transform.position - waypoint[index].position).sqrMagnitude > range)
        {
            Move(waypoint[index]);
            animation.CrossFade("walk");
        }
        else
        {
            switch (index)
            {
                case 0:
                    walking = false; victoring = true;
                    isVictoring = true;
                    break;
                case 1:
                    walking = false; waiting = true;
                    isWaiting = true;
                    break;
                default:
                    NextIndex(); break;
            }
        }
    }
    void Move(Transform target)
    {
        //Movement
        moveDirection = _transform.forward;
        moveDirection *= speed;
        moveDirection.y -= gravity;
        _controller.Move(moveDirection * Time.deltaTime);
        // Rotation
        var newRotation = Quaternion.LookRotation(target.position - _transform.position).eulerAngles;
        var angles = _transform.rotation.eulerAngles;
        _transform.rotation = Quaternion.Euler(angles.x,
         Mathf.SmoothDampAngle(angles.y, newRotation.y, ref velocity, minTime, maxRotSpeed), angles.z);
    }

    void NextIndex()
    {
        if (++index == waypoint.Count) index = 0;
    }

    //Added functions
    IEnumerator Victory()
    {
        if (!animation.IsPlaying("victory")) animation.CrossFade("victory");
        yield return new WaitForSeconds(animation["victory"].length);
        walking = true; isVictoring = false;
        NextIndex();
    }

    IEnumerator Wait()
    {
        animation.CrossFade("idle");
        yield return new WaitForSeconds(2.0f);
        walking = true; isWaiting = false;
        NextIndex();
    }
}

So, we have some boolean variables to check what the status of our guy is. He can be walking, waiting or victoring. The update checks the booleans and call the appropriate function. The Walk function checks which waypoint is being reached, and defines the status of each boolean according to the waypoint. The rest is simple coding you should understand.

You often see in games this kind of pattern, for instance the guard at the entrance will walk back and forth in front of the door but after a while will stop and look around or might do a special action which often is the trigger condition for the player to perform a special action, like shooting right in the face.

Introduction to delegate

Before we dive into our FSM tutorials and get scared by all those delegates and closures and decide to retire in a remote mountain lodge with no computers, I will introduce a simple example about delegates.

void Afunction(){
    //stuff here
}

void (*fct)(int);
fct = &Afunction;

We are now about to modify our code so that we can use delegate. First off we need to declare the delegate, then create an instance of the delegate and finally assign a function to it. Then at last we can use our delegate.

delegate void DelFunc();
DelFunc delegate;
delegate = Afunction;

static void Afunction(){

}
void Update(){
   delegate();
}

This is the basic declaration and that is probably all you are about to see from most internet tutorials, few or none takes the risk to show more about it, we will. You know that a static function cannot access non-static members. So how do we use that on our NPC in a way that if we have many on scene, it still works.

float variable;
delegate void DelFunc();
DelFunc delegate;
delegate = this.Afunction; //Did you see the this pointer?

void Afunction(){
    variable = variable +10;
}

Now the whole point of a delegate is to be used but also to be flexible. Our goal is to have one function to call another one from a bag of functions. See below the example:

Delegate code snippet

using UnityEngine;
using System.Collections;
using System;

public class Delegate :MonoBehaviour {
	[SerializeField]
	float pos;
	float val = 10;
	//Delegate declaration
        public delegate void DelegateFunction();
	public delegate IEnumerator DelegateEnum();
	// Delegate object
        DelegateFunction _delegate;
	DelegateEnum _delegateEnum;
	bool del;
	void Start(){
		_delegate = this.Increase;   
		_delegateEnum = null;    
		pos = 0;
		del = true;
	}
	void Update () {
        // We press Space and _delegate is called since del is true 
        // (that is why we assign a function in Start to avoid null reference)
		if(Input.GetKeyDown(KeyCode.Space)){
			if(del)_delegate(); 
			// _delegateEnum is called in a StartCoroutine
                        else StartCoroutine(_delegateEnum());  
		}
		if(Input.GetKeyDown(KeyCode.I)){
			del =true;                // we ensure del is true
			_delegate =this.Increase; // we assign a function to _delegate
		}
		if(Input.GetKeyDown(KeyCode.D)){
			del =true;
			_delegate = this.Decrease;
		}
		if(Input.GetKeyDown(KeyCode.O)){
			del =true;
			_delegate = this.Zero;
		}
		if(Input.GetKeyDown(KeyCode.W)){
			del =false;        // we ensure del is false
			_delegateEnum = this.Wait; // we assign a function to _delegateEnum
		}
		if(Input.GetKeyDown(KeyCode.A)){
			del =false;
			_delegateEnum = this.WaitAndAdd;
		}

	}
	public void Increase(){
		pos += val*Time.deltaTime; 
		print (pos);
	}
	public void Decrease(){
		 pos -= val*Time.deltaTime;
		print (pos);
	}	
	public void Zero(){
		pos = 0;
		print (pos);
	}
	public IEnumerator Wait(){
		yield return new WaitForSeconds(1.0f);
		print("Enum"+pos);
	}
	public IEnumerator WaitAndAdd(){
		print("Adding soon"+pos);
		yield return new WaitForSeconds(1.0f);
		pos+=2;
		print("Added "+pos);
	}
}

Attach that script to any object of a scene and look at the console. You can also look at the Editor since pos has the [SerializeField] attribute, it makes a private variable show in the Inspector.

Depending on the button pressed, a function is assign to a delegate. Since the signature of a function needs to match the signature of a delegate (vice-versa), we need two delegates. We just use a boolean to decide which one is called in the update.

It is possible to use parameters as well, you would create a delegate with the appropriate signature for return value and parameter and pass the functions with the same signature but  I will not go into Action and Func, as it is well done in the FSM tutorials.

Now let's modify our AIScript with delegates. Minor modifications are needed:

AIScript Delegate code snippet

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

[RequireComponent(typeof(CharacterController))]
public class AIScript : MonoBehaviour
{
    // Cached variables
    CharacterController _controller;
    Transform _transform;

    //Movement variables
    float speed = 5f;
    float gravity = 100f;
    Vector3 moveDirection;
    float maxRotSpeed = 200.0f;
    float minTime = 0.1f;
    float velocity;
    float range;

    //Waypoint variables
    public string strTag;
    List<Transform> waypoint;
    int index;

    //Added variables
    delegate void DelFunc();
    delegate IEnumerator DelEnum();
    DelFunc delFunc;
    DelEnum delEnum;

    void Start()
    {
		if(string.IsNullOrEmpty(strTag))Debug.LogError("No waypoint tag given");
        index = 0;
        _controller = GetComponent<CharacterController>();
        _transform = GetComponent<Transform>();
        range = 4;
        waypoint = GameObject.Find("PathObject").GetComponent<PathScript>().GetPath(strTag);
        animation["victory"].wrapMode = WrapMode.Once;

        //Added codes
        delFunc = this.Walk;
        delEnum = null;
    }

    //Modified update
    void Update()
    {
        if (delFunc != null){
            delFunc();
        }else if (delEnum != null){
            StartCoroutine(delEnum());
            delEnum = null;
        }
    }

    //Modified Walk
    void Walk()
    {
        if ((_transform.position - waypoint[index].position).sqrMagnitude > range)
        {
            Move(waypoint[index]);
            animation.CrossFade("walk");
        }
        else
        {
            switch (index)
            {
                case 0:
                    delFunc = null;
                    delEnum = this.Victory;
                    break;
                case 1:
                    delFunc = null;
                    delEnum = this.Wait;
                    break;
                default:
                    NextIndex(); break;
            }
        }
    }

    void Move(Transform target)
    {
        // Movement
        moveDirection = _transform.forward;
        moveDirection *= speed;
        moveDirection.y -= gravity;
        _controller.Move(moveDirection * Time.deltaTime);
        // Rotation
        var newRotation = Quaternion.LookRotation(target.position - _transform.position).eulerAngles;
        var angles = _transform.rotation.eulerAngles;
        _transform.rotation = Quaternion.Euler(angles.x,
         Mathf.SmoothDampAngle(angles.y, newRotation.y, ref velocity, minTime, maxRotSpeed), angles.z);
    }

    void NextIndex()
    {
        if (++index == waypoint.Count) index = 0;
    }

    //Modified animation functions
    IEnumerator Victory()
    {
        if (!animation.IsPlaying("victory")) animation.CrossFade("victory");
        yield return new WaitForSeconds(animation["victory"].length);
        NextIndex();
        delFunc= this.Walk;
    }
    IEnumerator Wait()
    {
        animation.CrossFade("idle");
        yield return new WaitForSeconds(2.0f);
        NextIndex();
        delFunc = this.Walk; 
    }
}

Our Update is now tinier, and we lost most of our boolean checks.  One good point of a delegate is that you can set it to null, meaning it simply points nowhere. What is so good about it is that we can check for nullity and use our delegate as boolean.

    if (delFunc != null){
        delFunc();
    }else if (delEnum != null){
       StartCoroutine(delEnum());
       delEnum = null;
    }

The line delEnum = null;  is there to avoid multiple calls of the coroutine. What you need to understand is the flow of our state-machine.

switch (index){
   case 0:
      delFunc = null;
      delEnum = this.Victory;
      break;
   case 1:
      delFunc = null;
      delEnum = this.Wait;
      break;
   default:
      NextIndex(); 
      break;
}

The switch simply sets the delFunc to null and delEnum to the appropriate action. Now, our coroutines are running, nothing is actually happening in the Update anymore. At the end of the coroutine delFunc is set back to this.Walk.

Our guy is fine walking around the place but he still does not do anything with us. Next, we see how to make him interact with the player.

Notice that the project includes two NPCs that do independent thing. With some more code, we could also define a different order of actions but I leave this one to you. As a hint, you could create an array of string to store animation names. Each NPC could then have a different order of actions. You would then pass the content of the array as parameter of the animation calls. [/alert]

Come closer (checking range)

Good, our NPC has a pattern of movement we stored and he looks more realistic than a simple movement from A to B, then B to C (now come on!!!). Still, if you add a First-Person-Controller and move around, you may have noticed that you can get close to him, even real close, he simply ignores you. It makes sense since we have not told him to do any particular action in case we would get close.

Trigger Collider:

Pros:

• Easy to use
• All done by the engine
• We get a reference to the colliding object

Cons:

• That is more the engine has to do

Using a trigger collider can be simple, we attach a sphere collider, set it to IsTrigger and then we can check collision. When something enters, we verify who it is using the reference the function created and apply the action. Good point it is done by the engine, every frame it takes all colliders and checks the distance between each triangle of the collider and see if any other collider intersects or is inside.

Distance checking:

Pros:

• Easy to use and implement

Cons:

• Depending on the function choice it can be expensive
• We need a reference to the object

Well, let's see two different cases in which one is better that the other. First, we have an enemy and we want to check collision with everything around (enemies, player and random NPCs). We cannot keep a reference of each and every one of them, on top of that, we would have to regularly call for any new object or any destroyed object. This is a case where the collider comes handy:

void OnTriggerEnter(Collider other){}

I get a reference automatically when anyone collides. This way, no need for arrays or lists of references. other is my reference and after the collision, the reference is destroyed. On the other hand, a whole Collider object  is created and destroyed calling the constructor and then the garbage collector and I need to check who collides with the NPC.

Now if I want my enemy to interact with a single object in particular, the player for instance and it might happen for various reasons and regularly, I might get a reference to the player at start and use it all along.

Transform _player;

void Start(){
   _player = GameObject.Find("Player").GetComponent<Transform>();
}

Now let's check if my player is in range.

We use the squared value (we already use it before on this tutorial) so that no square root is involved. Keep in mind that my squareRange is 100 so the actual distance is 10.

Transform _player;
Transform _transform;
float attackRange = 100f;
float closeRange = 4.0f;

void Start(){
   _transform = GetComponent<Transform>();
   _player = GameObject.Find("Player").GetComponent<Transform>();
   if(player == null)
      Debug.LogError("No player on scene");
}

function Update(){
    if(AIFunction())//Player in
}

bool AIFunction(){
    if((_transform.position - _player.position).sqrMagnitude < attackRange)return true;
    else return false;
}

Good, now we can just modify our function so that when in, the NPC follows us and when out, he gets back to his duty.

    bool AIFunction(){
        if((player.position - _transform.position).sqrMagnitude < attackRange){
           delFunc = this.Attack;
          return true;
       }else{
            delFunc = this.Walk;
            return false;
        }
    }

We  need modify our Update as such:

if(AIFunction()&& delEnum != null){
    StopAllCoroutines();
}

We call AIFunction that returns true , note that at this point, if we are in range, we are the target already. delEnum is checked so that if our NPC is doing his little animation, it will stop the animation and will follow us.

Now we have our guy minding his own business but he does not get too kindly on folks that come around so he attacks when you get too close but if you agree to leave then he gets back to his duty. By the way, he does not attack for now, so let's do it.

We need an Attack function:

void Attack(){
   if((player.position - _transform.position).sqrMagnitude > closeRange){
      Move(player);
      animation.CrossFade("walk");
  }else{
      print ("Slap slap!!");
   }
}

And finally, we modify our AI function:

bool AIFunction(){
   Vector3 direction = player.position - _transform.position;
   if(direction.sqrMagnitude < attackRange){
      delFunc = this.Attack;
      return true;
   }else{
      delFunc = this.Walk;
      return false;
   }
}

Depending on the distance we assign a different function.

This will do the trick but you probably noticed that whether you come from the front or behind the result is the same. Also, what if you are behind a tree or a house, checking the range, the NPC would know you are behind even though he cannot see you. Let's fix that in the next part.

I can see you (Line of sight)

In order to give some vision to our NPC we use a little vector trick. We use dot product and unit circle from trigonometry.

That tells us dot product of A and B is equal to product of the magnitude of A and B multiplied by cosin of the angle. Aie. Well actually it is way more simple than it looks. But it also shows that with some manipulation we can find the angle between two vectors.Look at the picture below.

What this tells us is that the NPC is at the center of the circle looking in the green vector direction. The player is the blue dot at the end of the black vector. We want to know the red angle and we can do that with the dot product.

Our dot product becomes green·black / |green|·|black| = cosΘ

It also tells us, that if the dot product returns a positive value, my player is in front of the NPC. We are getting closer.

Now, green is the transform.forward of our NPC and black is (player.position - transform.position). Mmm but hold on green is a unit vector so magnitude is 1 and I can make my black vector a unit vector as well without modify its direction property. Hooray!!!

Why hooray, because is I use the normalized version of my black vector the |green|·|black| part is equal 1 and dividing by 1 is like no division so I am left with transform.forward · (player.position - transform.position).normalized = cosΘ.

And that is it. I can use Vector3.Dot(transform.forward ,(player.position - transform.position).normalized)>0 and if this is true my guy is in front, the NPC sees him and attack.

if((player.position - _transform.position).sqrMagnitude < squareRange && 
      (Vector3.Dot((player.position - _transform.position).normalized, _transform.forward) >0)){}

We still have a problem, if we managed to get quickly behind the guy, he loses our sight.  So we need to modify our script so that when the NPC knows we are close, it will not lose sight until we get out of range. For this, I simply use a boolean.

bool chasing;
bool AIFunction()
{
     Vector3 direction = player.position - _transform.position;
     if (direction.sqrMagnitude < attackRange)
     {
         if (chasing)
         {
             delFunc = this.Attack;
             return true;
         }
         else
         {
             if (Vector3.Dot(direction.normalized, _transform.forward) > 0 )
             {
                 delFunc = this.Attack;
                 dhasing = true;
                 return true;
             }
             return false;
         }
     }
     else
     {
         if(chasing)delFunc = this.Walk;
         chasing = false;
         return false;
     }
 }

So we check if the player is in range AND if he is in sight. Then when he is seen, we set the boolean chasing to true. Next frame, it does not matter if we are behind him since he is aware of us. Only when we get far enough, then he gives up.

if(chasing){
   delFunc = this.Walk;
   chasing = false;
}
return false;

You might wonder about this bit above , well, we only want the NPC to get back to Walk if he has been chasing us and we got away from him. The rest of teh time we just return false.

Now how can we check if the NPC actually sees us. You do not want the NPC to see you if you are behind a wall. So we use Physics.Linecast. It will cast a line (as the name says) from one position to another and report if something is in between. But first, one side note about Linecast. If we use like this:

    if (!Physics.Linecast (_transform.position, player.position)) {
        //I see you
    }

You will notice that the NPC never sees you. The function returns true if something is in-between and skips our action if so. But the problem comes from our NPC itself. _transform.position is really likely to be positioned in the middle of the models, the Linecast will then automatically considered a collision with the collider of the NPC, two solutions to that. The simple one, add an empty game object right in front of the eye of the NPC with forward matching the view and casts the line from there. Good point about it, the NPC now sees from the eye level and I like this approach more actually as it matches realism.  Or we need to tell the compiler we want to ignore collision with the NPC using Layers.

Click Layers in the inspector, and select Add Layer. Select the User Layer 8 and add Vision, give that layer  to our player. We need to check if the line goes from the NPC eyes to our player position but our player also has a collider.

So we will modify a little our linecast function:

Transform _eyes;
int layerMask = 1 << 8;

void Start(){
    _eyes = transform.Find("Eyes");
    layerMask = ~layerMask;
}

void Update(){	
    Debug.DrawLine (_transform.position, _player.position, Color.yellow);
    if (!Physics.Linecast (_eyes.position, _player.position, layerMask)) {
           ("Did Hit "+hit.collider.gameObject.name);
    }
}

The layer variable uses some bitwise manipulation, instead of giving a particular value to the variable, we modify it by bit so we say to move to the 8th bit and turn it to 1-> 10000000. This kind of manipulation is widely used in communication and embedded-system, in game a little less...

The Start does another of those bitwise thingy, what we want is actually a bit like 01111111, so instead of 7 operations like the first one for each bit we can do it in two. ~ is a NOT operator just like ! but for bit, so it turns 0 into 1 and 1 into 0 and returns the invert byte (8bit). It is also called the complement. Let's not dig too much into bitwise manipulation shall we?

The Debug.DrawLine is just there for you to see the Linecast in the scene view. The linecast function checks every collision between our NPC and the player.If none then it means the NPC can see us.

So all we need here is this:

    bool AIFunction(){
        Vector3 direction = player.position - _transform.position;
        if (direction.sqrMagnitude < attackRange){
            if (chasing){
                delFunc = this.Attack;
                return true;
            } else{
                if (Vector3.Dot(direction.normalized, _transform.forward) > 0 &&
                    !Physics.Linecast(_eyes.position, player.position, layerMask)){
                        delFunc = this.Attack;
                        chasing = true;
                        return true;
                }
                return false;
            }
        }else{
            if(chasing)delFunc = this.Walk;
            chasing = false;
            return false;
        }
    }

Finally, our NPC starts to act reasonably. Last part we will look at is if our NPC is closer to a safe point, he will move there instead of attacking directly.

You may have notice I have added a script for the sword collision which is not a real collision. The issue being that we used an animation so collision won't do properly. A simple function will fix that problem.

using UnityEngine;
using System.Collections;

public class SwordScript : MonoBehaviour {

   Transform player;
   Transform _transform;
   float sqrRange = 3;

   void Start(){
      player = GameObject.Find ("Player").GetComponent<Transform>();
      if (player == null)
          Debug.LogError("No player on scene");
      _transform = GetComponent<Transform>();
   }

    void CollisionSword(){
        Vector3 direction = player.position - _transform.position;
	if (direction.sqrMagnitude < sqrRange){
		if(Vector3.Dot (direction.normalized,_transform.forward) > 0){
			//Add here your logic for decreasing player health
			print ("Hit");
		}
	}
    }
}

We are using a similar approach as for the line of sight, if we are close enough and facing the player at the moment of call then we get hit. The special thing here is that I used animation event. Select the NPC, then go to window in the menu bar and open up a animation window.
In the animation selection drop-down, select attackOwn (I had to create a new attack animation as imported animation are read-only). Around frame 13, you will notice a little white bar. This is an animation event. It just means at frame 13, I am calling the function that is given. By the way, you will probably see a (function not supported) message. Ignore it, it works. from what I have found, it seems only the functions attached to the first script on the object should be working. Nonetheless, it does work but give a warning.

When our guy gets close, he starts swinging and we get a message telling us we are getting hit.

We also add an attack function that is called when we are close enough to the player that simply launch the animation that will call the SwordCollision function.

Final code snippet

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

[RequireComponent(typeof(CharacterController))]
public class AIScript : MonoBehaviour{
    #region variables
    #region cached variables
    CharacterController _controller;
    Transform _transform;
    Transform player;
    Transform _eyes;
    #endregion
    #region movement variables
    float speed = 5;
    float gravity = 100;
    Vector3 moveDirection;
    float maxRotSpeed = 200.0f;
    float minTime = 0.1f;
    float velocity;
    float range;
    float attackRange;
    #endregion
    #region waypoint variables
    int index;
    public string strTag;
    List<Transform> waypoint;
    #endregion
    #region delegate variable
    delegate void DelFunc();
    delegate IEnumerator DelEnum();
    DelFunc delFunc;
    DelEnum delEnum;
    #endregion
    #endregion
    bool chasing;
    bool coroutineOn;
    int layerMask = 1 << 8;

    void Start(){
        _controller = GetComponent<CharacterController>();
        _transform = GetComponent<Transform>();
        _eyes = transform.Find ("Eyes");
        player = GameObject.Find("Player").GetComponent<Transform>();
        if (player == null)
            Debug.LogError("No player on scene");
        if (string.IsNullOrEmpty(strTag)) 
            Debug.LogError("No waypoint tag given");

        index = 0;
        range = 2.5f; attackRange = 200f;

        waypoint = GameObject.Find("PathObject").GetComponent<PathScript>().GetPath(strTag);
        animation["victory"].wrapMode = WrapMode.Once;

        delFunc = this.Walk;
        delEnum = null;

        chasing = false;
        layerMask = ~layerMask;
    }

    void Update()
    {
        if (AIFunction()&&coroutineOn) {
            StopAllCoroutines();
            coroutineOn = false;
        }

        if (delFunc != null){
            delFunc();
        }else if (delEnum != null){
               StartCoroutine(delEnum());
               delEnum = null;
        }
    }

    #region movement functions
    void Move(Transform target){
        //Movements
        moveDirection = _transform.forward;
        moveDirection *= speed;
        moveDirection.y -= gravity;
        _controller.Move(moveDirection * Time.deltaTime);
        //Rotation
        var newRotation = Quaternion.LookRotation(target.position - _transform.position).eulerAngles;
        var angles = _transform.rotation.eulerAngles;
        _transform.rotation = Quaternion.Euler(angles.x,
            Mathf.SmoothDampAngle(angles.y, newRotation.y, ref velocity, minTime, maxRotSpeed), angles.z);
    }

    void NextIndex(){
        if (++index == waypoint.Count) index = 0;
    }

    void Walk(){
        if ((_transform.position - waypoint[index].position).sqrMagnitude > range) {
            Move(waypoint[index]);
            animation.CrossFade("walk");
        }
        else{
            switch (index) {
                case 0:
                    delFunc = null;
                    delEnum = this.Victory;
                    break;
                case 1:
                    delFunc = null;
                    delEnum = this.Wait;
                    break;
                default:
                    NextIndex(); break;
            }
        }
    }

    void Attack(){
        if ((_transform.position - player.position).sqrMagnitude > range){
            Move(player);
            animation.CrossFade("charge");
        }else{
            animation.CrossFade("attackOwn");
        }
    }

    #endregion

    #region animation functions
    IEnumerator Victory() {
        couroutineOn = true;
        if (!animation.IsPlaying("victory")) animation.CrossFade("victory");
        yield return new WaitForSeconds(animation["victory"].length);
        NextIndex();
        delFunc = this.Walk;
        couroutineOn = false;
    }

    IEnumerator Wait(){
        couroutineOn = true;
        animation.CrossFade("idle");
        yield return new WaitForSeconds(2.0f);
        NextIndex();
        delFunc = this.Walk;
        couroutineOn = false;
    }
    #endregion

    #region AI function
    bool AIFunction(){
        Vector3 direction = player.position - _transform.position;
        if (direction.sqrMagnitude < attackRange){
            if (chasing){
                delFunc = this.Attack;
                return true;
            } else{
                if (Vector3.Dot(direction.normalized, _transform.forward) > 0 &&
                    !Physics.Linecast(_eyes.position, player.position, layerMask)){
                        delFunc = this.Attack;
                        chasing = true;
                        return true;
                }
                return false;
            }
        }else{
            if(chasing){
                delFunc = this.Walk;
                chasing = false;
            }
            return false;
        }
    }
    #endregion
}

Conclusion

You now have the basic to develop your NPC further. Hopefully that was useful and I hope it will ease a little the approach to the more advanced delegate tutorial.

So you learn how to get our little guy around without passing through walls and trees. He also sees you and run at you. You learn about simple delegates. Now it is your turn to get this to a higher level.

Hope you liked it.

Also, it took a little while and a lot of coffee to review all that and make it better but still, it could be that you see something wrong. Please report it so that we can make it even better. Also, if you feel some techniques should be used over the one provided, well then again, drop a comment.

Il existe un certain nombre de "pièges" qui ont frappé presque tous les débutants de Unity. Parfois, cela est dû au fait que vous débutez la programmation en général mais c'est parfois dû au fait que Unity utilise une méthode légèrement inhabituelle d'attacher plusieurs scripts sur un objet.
Cet aperçu tente de vous guider à travers ceux que nous voyons le plus souvent sur le forum de réponses Unity. Ce tutoriel s'adresse donc aux nouveaux venus, les noobs.

Les Traquenards

Comment accéder à une variable d'un autre script ou d'un autre objet

GetComponent(ScriptTarget).uneVariable = uneValeur;

GetComponent(ScriptTarget).UneMethode();

GetComponent<ScriptTarget>().uneVariable = uneValeur;
GetComponent<ScriptTarget>().UneMethode();

function OnTriggerEnter(reference : Collider) 
{ 
      reference.GetComponent(ScriptTarget).uneVariable = uneValeur; 
}

void OnTriggerEnter(Collider reference)
{
      reference.GetComponent<ScriptTarget>().uneVariable = une Valeur;
}

function OnCollisionEnter(reference : Collision)
{
       reference.collider.GetComponent(ScriptTarget).uneVariable = uneValeur;
}

void OnCollisionEnter(Collision reference)
{
      reference.GetComponent<ScriptTarget>().uneVariable = uneValeur;
}

var targetScript : TargetScript;       //Le script est directement placé dans l'emplacement de l'inspecteur 

function Update(){
     //Si nous avons une target et elle est prête à être utilisée
     if(targetScript && targetScript.uneVariable > 100){
         //Action
     }else{
         //Une autre action
     }
}

function OnTriggerEnter(other : Collider){
     //Vérifions si l'objet avec lequel nous entrons en collision peut être une target
     var target = other.GetComponent(ScriptTarget);
     if(target){
           //Si possible 
           targetScript = target;
     }
}

TargetScriptName targetScript;

void Start()
{
       targetScript = GameObject.Find("NomObjet").GetComponent<TargetScriptName>();
}

void Update()
{
      if(Vector3.Distance(targetScript.transform.position, transform.position) < 10)
      {
          targetScript.uneVariable -= uneValeur;
      }
}

for(var t : Transform in transform)
{
     target = t.GetComponent(TargetScriptName);
     target.DoSomething();
     target.someVariable = someValue;
}

foreach (Transform t : in transform)
{
     target = t.GetComponent<TargetScriptName>();
     target.Action();
     target.uneVariable = uneValeur;
}

Rigidbody, à quoi ça sert?

Comment s'assurer que les fonctions OnCollisionXXX et OnTriggerXXX sont appelées dans votre script.

Détecter l'Input convenablement

using UnityEngine;

public class Test:MonoBehaviour{
    void FixedUpdate(){
        if(Input.GetKeyDown(KeyCode.Space)){
           //Action
        }
    }
}

using UnityEngine;

public class Test:MonoBehaviour{
    bool action = false;
    void Update(){
         if(Input.GetKeyDown(KeyCode.Space)){
             action = true;
         }
    }
    void FixedUpdate(){
       if(action){
           //Action
           action = false;
        }
    }
}

Action dans le futur

float timer;
int attente;

void Update(){
    timer += Time.deltaTime;
    if(timer > attente){
        //Action
       timer = 0;
    }
}

using UnityEngine;
using System.Collections;
public class Test:MonoBehaviour{
    float timer;       
    int attente;
    bool inside;

    void Start(){
        timer = 0.0;
        attente = 2;
        inside = false;
    }

    void Update(){
        if(inside){
            timer += Time.deltaTime;
            if(timer > attente){
                //Action
               timer = 0;
           }
       }
    }

    void OnTriggerEnter(Collider other){
        if (other.gameObject.tag=="Joueur")inside = true;
    }
   void OnTriggerExit(Collider other){
        if (other.gameObject.tag =="Joueur"){
            inside=false;
            timer = 0;
        }
   }
}

void Start()
{
       //Détruire l'objet après 5 secondes
       Destroy(gameObject, 5);
}

int vie = 10;

void Update(){
       if(vie <= 0)
            //Détruire l'objet après 2 secondes
            Destroy(gameObject, 2);
}

#pragma strict
var check :boolean =true;
var i:int =0;

function Update () {
    if(Input.GetKeyDown(KeyCode.A)&&check){
        check = false;
        print("Dedans" + i++);
        WaitForIt();
    }
}
function WaitForIt(){
    yield WaitForSeconds(2.0f);
    check=true;
}

using UnityEngine;
using System.Collections;

public class Wait : MonoBehaviour {
    public bool check =true;
    int i =0;

    void Update () {
        if(Input.GetKeyDown(KeyCode.A)&&check){
            check = false;
            print("Inside" + i++);
            StartCoroutine(WaitForIt());
        }
    }
    IEnumerator WaitForIt(){
        yield return new WaitForSeconds(2.0f);
        check=true;
    }
}

function Start(){
      //Change l'object en bleu dans 2 sec
      Invoke("TurnMeBlue", 2);
}

void TurnMeBlue(){
       renderer.material.color = Color.blue;
}

var startPosition : Vector3;
var health = 100.0;
var respawning = false;

function Start(){
    startPosition = transform.position;
}

//Repositione l'objet
function Respawn(){
      transform.position = startPosition;
      health = 100;
      renderer.enabled = true;
      respawning = false;
}

//Cacher le personnage
function Hide(){
     renderer.enabled = false;
     transform.position = new Vector3(1000,1000,1000);
}

function Update(){
    if(health < 0 && !respawning){
         respawning = true;
         animation.Play("die");
         Invoke("Hide", 3);
         Invoke("Respawn", 10);
    }
}

float sante = 100f;

void Start()
{
    InvokeRepeating("Soigne", 2, 2);
}

void Soigne()
{
    sante = Mathf.Clamp(health + 1, 0, 100);
}

InvokeRepeating("Fonction",0,001f,2.0f);

function OnMouseUp()
{
     TournToi(Vector3(0,90,0),2);
}

function TourneToi(angle : Vector3, time : float)
{
     var maRotation = transform.rotation;
     var targetAngle = currentRotation.eulerAngles + angle;
     var targetRotation = Quaternion.Euler(targetAngle);
     var t = 0;
     while(t < 1)
     {
          transform.rotation = Quaternion.Slerp(maRotation, targetRotation, t);
          t += Time.deltaTime / time;
          yield null;
     } 
     transform.rotation = targetRotation;
}

Comment utiliser Vector3.Lerp

transform.position = Vector3.Lerp(depart, cible, ratio);

Vector3 _depart;
Vector3 _target;
float _t;

void Update()
{
     transform.position = Vector3.Lerp(_depart, _target, _t);
     _t += Time.deltaTime/2; //Take 2 seconds
}

public void SetTargetPosition(Vector3 newTargetPosition)
{
    _depart = transform.position;
    _target = newTargetPosition;
    _t = 0;
}

void Update(){
    transform.position = Vector3.Lerp(transform.position, target.position, Time.deltaTime);
    }

Stocker une liste d'objets qui peut grandir

using System.Collections.Generic;

//Definir une liste avec UniyScript
var myList = new List.<int>();
var anotherList = new List.<SomeClass>();

//Definir une liste avec C#
List<int> myList = new List<int>();
List<SomeClass> anotherList = new List<SomeClass>();

//Ajouter un élément à une liste
myList.Add(someValue);

//Ajouter de multiples éléments à la liste
myList.AddRange(someListOrArrayOfValues);

//Vider la liste
myList.Clear();

//Insérer dasn une liste
myList.Insert(1, someValue);

//Insérer de multiples éléments
myList.InsertRange(1, someListOrArrayOfValues);

//Retirer un élément en particulier
myList.Remove(someValue);

//Retirer à un index
myList.RemoveAt(1);

//Trouver l'index d'un élément
var index = myList.IndexOf(someValue);

//Trouver l'index d'un éleément avec une fonction en UnityScript
var index = anotherList.FindIndex(function(entry) entry.someValue == something);

//Faire un tableau avec une liste
var myArray = myList.ToArray();

//Trouver l'index d'un objet avec une fonction en C#
var index = anotherList.FindIndex((entry) => entry.someValue == something)

//Taille de la liste (nombre d'éléments)
var itemCount = myList.Count

//Définir un dictionnaire de string pour integer en UnityScript
var myDic = new Dictionary.<String, int>();

//Définir un dictionnaire de GameObject pour classe in UnityScript
var anotherDic = new Dictionary.<GameObject, SomeClass>();

//String pour int den C#
Dictionary<string, int> myDic = new Dictionary<string, int>();

//GameObejct pour classe en C#
Dictionary<GameObject, SomeClass> anotherDic = new Dictionary<GameObject, SomeClass>();

//Ajouter un élément
myDic["Something"] = someIntValue;

//Obtenir une valeur
var someValue = myDic["Something"];

//Obtenir une valeur complexe et modifier ses attributs
anotherDic[gameObject].someProperty = someValue;

//Vérifier si une valeur existe
if(myDic.ContainsKey("Something")) { }

//Retirer un élément
myDic.Remove("Something');

//Iteration de chaque clé en UnityScript
for(var key : String in myDic.Keys) { }

//Iteration de chaque valeur en C#
foreach(int value in myDic.Values) { }

//Vider le dictionnaire
myDic.Clear();

//Nombre de valeurs
var count = myDic.Count;

Comment bouger un rigidbody

Le Character Controller, à quoi donc que ça sert?

Vous pensez programmez en Java ou Javascript

La coroutine ne semble pas s'arrêter après le yield ou wait

void Update() {
    if(health < 0) {
           StartCoroutine(Die());
           Destroy(gameObject); //ou enabled = false;
    }
}

IEnumerator Die() {
       animation.Play("wobble");
       yield return new WaitForSeconds(3);
       //Cela n'arrivera jamais
       animation.Play("meurir");
}

bool estMort;
void Update() {
     if(estMort) return;
     if(health < 0) {
         StartCoroutine(Meurt());
     }
}

IEnumerator Meurt() {
      estMort = true;
      animation.Play("wobble");
      yield return new WaitForSeconds(3);
      animation.Play("meurir");
      yield return new WaitForSeconds(3);
      Destroy(gameObject);
}

Accéder un script en C# avec UnityScript et inverse

Modifier la rotation d'un objet avec Quaternion

transform.rotation.eulerAngles = new Vector3(100,0,100);

You should read this article if:

• You'd like to send AnimationStates over the network (including mixing transforms)
• You'd like to know how to imbue any object with new properties without leaking memory
• You'd like to learn more about garbage collection and weak references

Introduction

One of the perennial problems with Unity is that the back end is C++ and our coding interface is .NET.  The guys have done a great job but there are places where you just can't get to the values you need.  One classic example is Mixing Transforms that you add to animations to make them only play on part of the character.  You can add them and you can remove them, but only if you know what they are. In many circumstances you can find yourself adding mixing transforms in one piece of code and then needing to know what they are, perhaps to send them via an RPC call or to remove them, in a different function.

You could jump through hoops trying to solve that problem - having to store and manage a lot of new variables and classes to keep track of the information - and who knows when that object will be destroyed?  How will you free your memory? Will you lock the object forever and leak?  Quite possibly.

public class Extra
{
    public int anyVariablesYouLike;
}

...

anyObject.Get<Extra>().anyVariablesYouLike = 1;

A First Association - Animation Mixing

Ok so lets have a look at a basic way we could associate data with the AnimationState we want to mix - we could build a little helper class that allowed us to key objects off other objects:

public static class Extensions
{
    //Dictionary to hold our extensions
    static Dictionary<object, Dictionary<Type, object>> _extensions = new Dictionary<object, Dictionary<Type, object>>();

    //Get an associated extension class
    public static T Get<T>(this object o) where T : class, new()
    {
         //Do we have this object yet?
         if(!_extensions.ContainsKey(o))
         {
             //If not then add it
             _extensions[o] = new Dictionary<Type, object>();
         }
         //Do we have this associate type yet?
         if(!_extensions[o].ContainsKey(typeof(T)))
         {
             //If not create a new one
             _extensions[o][typeof(T)] = new T();
         }
         //Return the associate
         return _extensions[o][typeof(T)];

    }
}

Ok so with that class we can do anyObject.Get<AnyClass>() and it will give us an instance of that class!  The Dictionaries are giving us O(1) lookup so it should be very fast.  So we want to associate transforms with animations states, let's make up a class to do that.  We will use the names of the transforms so that we can find them on another computer if we send them via RPC.

	public class Mixing
	{
		public List<string> transforms = new List<string>();
	}

 Now lets add something to that class, using our Get<T> helper function.

Transform spine2;

public void SwingSword()
{
    var state = animation["swingSword"];
    //We'd probably only do this if we were 
    //walking - but for ease I'm leaving out
    //any testing for that
    state.AddMixingTransform(spine2);
    //Get a Mixing instance for this animation state and add the
    //name of our new transform
    state.Get<Mixing>().transforms.Add(spine2.name);
    state.enabled = true;
    state.weight = 1;
}

Ok so that will associate our Mixing class with this particular animation  - let's look at how we might send AnimationStates by RPC to another player.

We need a class suitable for RPC transmission that represents the AnimationState:

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

/// <summary>
/// Stores the animation state for a character
/// </summary>
public class StoredAnimationState
{
    /// <summary>
    /// The name of the animatoin
    /// </summary>
    public string name;
    /// <summary>
    /// Is the animation enabled
    /// </summary>
    public bool enabled;
    /// <summary>
    /// The current speed of the animation
    /// </summary>
    public float speed;
    /// <summary>
    /// The current progress through the animation
    /// </summary>
    public float time;
    /// <summary>
    /// The current weight of the animation
    /// </summary>
    public float weight;
    /// <summary>
    /// The current blend mode of the animation
    /// </summary>
    public AnimationBlendMode blendMode;
    /// <summary>
    /// The current layer of the animation
    /// </summary>
    public int layer;
    /// <summary>
    /// The current wrap mode of the animation
    /// </summary>
    public WrapMode wrapMode;
    /// <summary>
    /// The list of current mixing transforms for the animation
    /// </summary>
    public List<string> mixingTransforms = new List<string>();

    public override int GetHashCode()
    {
        return name.GetHashCode() ^ weight.GetHashCode();
    }

    public override bool Equals (object obj)
    {
        if(!(obj is StoredAnimationState))
            return false;
        var other = (StoredAnimationState) obj;
        return name == other.name && enabled == other.enabled &&
               Math.Abs(speed - other.speed) < Single.Epsilon && Math.Abs(weight - other.weight) < Single.Epsilon &&
               blendMode == other.blendMode && 
               layer == other.layer &&
               wrapMode == other.wrapMode &&
               mixingTransforms.Count == other.mixingTransforms.Count;

    }

    public StoredAnimationState()
    {
    }

    //Configure from an animation	
    public StoredAnimationState(AnimationState state)
    {
        name = state.name;
        enabled = state.enabled;
        speed = state.speed;
        time = state.time;
        weight = state.weight;
        blendMode = state.blendMode;
        layer = state.layer;
        wrapMode = state.wrapMode;
        mixingTransforms = state.Get<Mixing>().transforms;
    }

    /// <summary>
    /// Configure an existing animation state from the information in this transfer class
    /// </summary>
    /// <param name="animation"></param>
    public void Set(Animation animation)
    {
        var anim = animation[name];
        //Do our mixing transform match?
        //First check if we have the same number, if they match then check
        //the names
        if(anim.Get<Mixing>().transforms.Count != mixingTransforms.Count || !anim.Get<Mixing>().transforms.All(mixingTransforms.Contains))
        {
            //Remove all of the existing mixings
            foreach(var m in anim.Get<Mixing>().transforms)
            {
                anim.RemoveMixingTransform(animation.transform.Find(m));
            }
            //Update the list
            anim.Get<Mixing>().transforms = mixingTransforms;
            //Apply the new mixings
            foreach(var m in mixingTransforms)
            {
                anim.AddMixingTransform(animation.transform.Find(m), true);
            }

        }
        //Apply other variables
        anim.enabled = enabled;
        anim.weight = weight;
        anim.speed = speed;
        if(Mathf.Abs(anim.time - time) > 1)
            anim.time = time;
        anim.blendMode = blendMode;
        anim.layer = layer;
        anim.wrapMode = wrapMode;
    }

    /// <summary>
    /// Class to transfer a list of animation states
    /// </summary>
    public class AnimationTransfer
    {
        /// <summary>
        /// The animation state to be transferred
        /// </summary>
        public List<StoredAnimation> StoredAnimations;
        /// <summary>
        /// The representation of an animation state
        /// </summary>
        public class StoredAnimation
        {
            /// <summary>
            /// The name of the animation
            /// </summary>
            public string name;
            /// <summary>
            /// The data for the stored state of the animation
            /// </summary>
            public StoredAnimationState data;
        }
    }
}

Ok, so that's quite a lot of code - we've basically made a class that can represent an animation state, suitable for serialization.  It also knows how to apply itself back onto an animation.

Let's look at how we could send that to the other players:

public void SendAnimations()
{
      //Create a transfer structure
      var transfer = new StoredAnimationState.AnimationTransfer();
      //Create the list of stored animations
      transfer.StoredAnimations = 
         //All of the states in the current list
         animation.Cast<AnimationState>()
            //Only when enabled
            .Where(state=>state.enabled)
            //Create a stored animation
            .Select(state=>new StoredAnimationState.AnimationTransfer.StoredAnimation
                   { 
                        //Animation name
                        name = state.name, 
                        //Animation data
                        data = new StoredAnimationState(state) 
                   })
            .ToList();   
       //Serialize the data
       var m = new MemoryStream();
       var b = new BinaryFormatter();
       b.Serialize(transfer, m);
       //Send it
       networkView.RPC("ReceiveAnimations", RPCMode.Others, m.ToArray());

}

[RPC]
void ReceiveAnimations(byte[] data)
{
     //Get the transfer structure
     var m = new MemoryStream(data);
     var b = new BinaryFormatter();
     var transfer = (StoredAnimationState.AnimationTransfer)b.Deserialize(m);
     //Disable all animations (they will be re-enabled
     //if required)
     foreach(var state in animation.Cast<AnimationState>())
        state.enabled = false;
     //Set up all of the animations from the
     //transfer
     foreach(var state in transfer.StoredAnimations)
         state.data.Set(animation);
}

It Leaks Like a Sieve!!!

Yep, sorry to tell you - but without forcibly removing things from our _extensions Dictionary this code is sinking fast.  When you destroy the game objects, the memory won't be freed because we're holding on to those AnimationStates as keys in our Dictionary - if it happens a lot there will be vast memory usage.

Ye of Little Faith

I'm hoping that you don't think I've lead you down the garden path for no reason?  There is a way around this problem - but it's going to get techy.

What we need is to free our Mixing (or other extensions) when the AnimationState (or whatever the key is) is destroyed.  Of course they aren't getting destroyed because we're holding on to them.

Weak References

What we need to do first is to hold a weak reference to the AnimationState rather than a strong one.  .NET has the WeakReference type built in - so we can manage that.  Now two weak references to the same object are not going to have the same hash code - so we can't use them as the key in a Dictionary!  That's ok - all objects in .NET have a GetHashCode call that we can use to find out what it would be for our real key and use that instead.  It's an int by the way.

Genericising everthing we come up with a WeakTable<T> class that associates our objects.  We'll see this in a minute, for the moment we also need to remove our associates when the original key is garbage collected.

Its kind of hard to figure out when the Garbage Collector has run - but we can actually find out by creating some objects that have no references to them, and see when they are collected - using their finalization methods!  We borrow this from Jeff Richter:

//The following class is from:
//Jeff Richter - http://www.wintellect.com/CS/blogs/jeffreyr/archive/2009/12/22/receiving-notifications-garbage-collections-occur.aspx
public static class GCNotification {
   private static Action<Int32> s_gcDone = null; // The event’s field
   public static event Action<Int32> GCDone {
      add {
         // If there were no registered delegates before, start reporting notifications now 
         if (s_gcDone == null) { new GenObject(0); new GenObject(2); }
         s_gcDone += value;
      }
      remove { s_gcDone -= value; }
   }
   private sealed class GenObject {
      private Int32 m_generation;
      public GenObject(Int32 generation) { m_generation = generation; }
      ~GenObject() { // This is the Finalize method
         // If this object is in the generation we want (or higher), 
         // notify the delegates that a GC just completed
         if (GC.GetGeneration(this) >= m_generation) {
	        //Thread safe get of the s_gcDone delegate - will not be interrupted
            Action<Int32> temp = Interlocked.CompareExchange(ref s_gcDone, null, null);
			//Fire the event
            if (temp != null) temp(m_generation);
         }
         // Keep reporting notifications if there is at least one delegate
         // registered, the AppDomain isn't unloading, and the process 
         // isn’t shutting down
         if ((s_gcDone != null) && 
            !AppDomain.CurrentDomain.IsFinalizingForUnload() && 
            !Environment.HasShutdownStarted) {
            // For Gen 0, create a new object; for Gen 2, resurrect the
            // object & let the GC call Finalize again the next time Gen 2 is GC'd
            if (m_generation == 0) new GenObject(0);
            else GC.ReRegisterForFinalize(this);
         } else { /* Let the objects go away */ }
      }
   }
}

This class creates a couple of objects with no references, waits for them to be finalized by the Garbage Collector and when that happens it fires a GCDone event.  We can use this event as a cue to decide to check whether our weak references are still valid, the ones that aren't need to have their associated objects removed...

The final WeakTable<T> and static extension method Get<T> look like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
using System.Threading;

/// <summary>
/// Weak entry for the table
/// </summary>
class WeakEntry 
{
	/// <summary>
	/// The weak reference to the collectable object
	/// </summary>
	public WeakReference weakReference;
	/// <summary>
	/// The associated object with the reference
	/// </summary>
	public object associate;
}

/// <summary>
/// A weak table for a particular type of associated class
/// </summary>
public class WeakTable<T> : IDisposable where T : class, new()
{

	//When finished we can dispose of the notification
	public void Dispose()
	{
		GCNotification.GCDone -= Collected;
	}

	/// <summary>
	/// The references held by the table
	/// </summary>
	Dictionary<int, List<WeakEntry>> references = new Dictionary<int, List<WeakEntry>>();

	/// <summary>
	/// Gets an associated object give an index of another object
	/// </summary>
	/// <param name='index'>
	/// The object to use as an index
	/// </param>
	public T this[object index]
	{
		get
		{
			//Get the hash code of the indexed object
			var hash = index.GetHashCode();
			List<WeakEntry> entries;
			//Try to get a reference to it
			if(!references.TryGetValue(hash, out entries))
			{
				//If we failed then create a new entry
				references[hash] = entries = new List<WeakEntry>();
			}
			//Try to get an associated object of the right type for this
			//indexer/make sure it is still alive
			var item = entries.FirstOrDefault(e=>e.weakReference.IsAlive && e.weakReference.Target == index);
			//Check if we got one
			if(item == null) 
			{
				//If we didn't then create a new one
				entries.Add(item = new WeakEntry { weakReference = new WeakReference(index), associate = new T() });
			}
			//Return the associated object
			return (T)item.associate;
		}

	}

	/// <summary>
	/// Get an associate given an indexing object
	/// </summary>
	/// <param name='index'>
	/// The object to find the associate for
	/// </param>
	/// <typeparam name='T2'>
	/// The type of associate to find
	/// </typeparam>
	public T2 Get<T2>(object index) where T2 : T, new()
	{
		//Get the hash code of the indexing object
		var hash = index.GetHashCode();
		List<WeakEntry> entries;
		//See if we have a reference already
		if(!references.TryGetValue(hash, out entries))
		{	
			//If not the create the reference list
			references[hash] = entries = new List<WeakEntry>();
		}
		//See if we have an object of the correct type and that the
		//reference is still alive
		var item = entries.FirstOrDefault(e=>e.weakReference.IsAlive && e.weakReference.Target == index && e.associate is T2);
		if(item == null) 
		{
			//If not create one
			entries.Add(item = new WeakEntry { weakReference = new WeakReference(index), associate = new T2() });
		}
		//Return the associate
		return (T2)item.associate;
	}

	public WeakTable() 
	{
		//Setup garbage collection notification
		GCNotification.GCDone += Collected;
	}

	/// <summary>
	/// Called when the garbage has been collected
	/// </summary>
	/// <param name='generation'>
	/// The generation that was collected
	/// </param>
	void Collected(int generation)
	{
		//Remove the references which are no longer alive

		//Scan each reference list
		foreach(var p in references)
		{
			//Scan each item in the references and remove
			//items that are missing
			removeEntries.Clear();
			foreach(var r in p.Value.Where(r=>!r.weakReference.IsAlive))
				removeEntries.Add(r);
			foreach(var entry in removeEntries)
			{
				if(entry.associate is IDisposable)
					(entry.associate as IDisposable).Dispose();                      
				p.Value.Remove(entry);
			}
		}
	}

	List<WeakEntry> removeEntries = new List<WeakEntry>();

}

/// <summary>
/// Extension class to support getting weak tables easily
/// </summary>
public static class Extension
{
	static Dictionary<Type, WeakTable<object>> extensions = new Dictionary<Type, WeakTable<object>>();

	/// <summary>
	/// Get an associate for a particular object
	/// </summary>
	/// <param name='reference'>
	/// The object whose associate should be found
	/// </param>
	/// <param name='create'>
	/// Whether the associate should be created (defaults true)
	/// </param>
	/// <typeparam name='T'>
	/// The type of associate
	/// </typeparam>
	public static T Get<T>(this object reference, bool create = true) where T : class, new()
	{
		WeakTable<object> references;
		//Try to get a weaktable for the reference object
		if(!extensions.TryGetValue(reference.GetType(), out references))
		{
			//Verify that we should be creating it if missing
			if(!create)
				return null;
			//Create a new table
			extensions[reference.GetType()] = references = new WeakTable<object>();
		}
		//Get the associate from the table
		return (T)references.Get<T>(reference);
	}

}

//The following class is from:
//Jeff Richter - http://www.wintellect.com/CS/blogs/jeffreyr/archive/2009/12/22/receiving-notifications-garbage-collections-occur.aspx
public static class GCNotification {
   private static Action<Int32> s_gcDone = null; // The event’s field
   public static event Action<Int32> GCDone {
      add {
         // If there were no registered delegates before, start reporting notifications now 
         if (s_gcDone == null) { new GenObject(0); new GenObject(2); }
         s_gcDone += value;
      }
      remove { s_gcDone -= value; }
   }
   private sealed class GenObject {
      private Int32 m_generation;
      public GenObject(Int32 generation) { m_generation = generation; }
      ~GenObject() { // This is the Finalize method
         // If this object is in the generation we want (or higher), 
         // notify the delegates that a GC just completed
         if (GC.GetGeneration(this) >= m_generation) {
			//Thread safe get of the s_gcDone delegate - will not be interrupted
            Action<Int32> temp = Interlocked.CompareExchange(ref s_gcDone, null, null);
			//Fire the event
            if (temp != null) temp(m_generation);
         }
         // Keep reporting notifications if there is at least one delegate
         // registered, the AppDomain isn't unloading, and the process 
         // isn’t shutting down
         if ((s_gcDone != null) && 
            !AppDomain.CurrentDomain.IsFinalizingForUnload() && 
            !Environment.HasShutdownStarted) {
            // For Gen 0, create a new object; for Gen 2, resurrect the
            // object & let the GC call Finalize again the next time Gen 2 is GC'd
            if (m_generation == 0) new GenObject(0);
            else GC.ReRegisterForFinalize(this);
         } else { /* Let the objects go away */ }
      }
   }
}

Just note that we have had to switch around our Dictionary definition to use the type of the reference first, that's so we can get a WeakTable that knows about those references.

When we are finished with the associated classes we call IDisposable.Dispose on them in case they want to know that they are finished with.

Conclusion

This has been a pretty techy article, hopefully it makes some sense!  You should be able to see how associating a class of our own devising with something we don't control the lifetime of (like an AnimationState) is a powerful technique. Enjoy!