Unity - Roguelike 2D

using UnityEngine;
using System.Collections;

namespace Completed
{
    // Enemy hérite de MovingObject, notre classe de base pour les objets mobiles. La classe Player hérite aussi de cette classe.
    public class Enemy : MovingObject
    {
        public int playerDamage;                            // Le nombre de points à enlever au joueur lors d'une attaque.
        
        
        private Animator animator;                          // Variable de type Animator pour garder une référence vers le composant Animator de l'ennemi.
        private Transform target;                           // Déplacement vers lequel on essaie d'aller à chaque tour. 
        private bool skipMove;                              // Booléen pour déterminer si l'ennemi doit passer son tour ou se déplacer.
        
        
        // La fonction Start surcharge la fonction virtuelle Start de la classe de base.
        protected override void Start ()
        {
            // Enregistre cet ennemi à l'instance de GameManager en l'ajoutant à la liste des ennemis. 
            // Cela permet au GameManager de faire les commandes de déplacement.
            GameManager.instance.AddEnemyToList (this);
            
            // Récupère et stocke une référence sur le composant Animator.
            animator = GetComponent<Animator> ();
            
            // Trouve le GameObject Player en utilisant son tag et stocke une référence de son composant Transform.
            target = GameObject.FindGameObjectWithTag ("Player").transform;
            
            // Appelle la fonction Start de la classe de base.
            base.Start ();
        }
        
        
        // Surcharge la fonction AttemptMove de la classe MovingObject pour intégrer la particularité de Enemy à sauter des tours.
        // Voir les commentaires de MovingObject pour plus d'informations sur le fonctionnement de la fonction AttemptMove.
        protected override void AttemptMove <T> (int xDir, int yDir)
        {
            // Vérifie si skipMove est à true. Dans ce cas, le mettre à false et sauter le tour.
            if(skipMove)
            {
                skipMove = false;
                return;
                
            }
            
            // Appelle la fonction AttemptMove de la classe de base.
            base.AttemptMove <T> (xDir, yDir);
            
            // Maintenant que l'ennemi s'est déplacé, définit skipMove à true pour sauter le prochain tour.
            skipMove = true;
        }
        
        
        // La fonction MoveEnemy est appelée par le GameManger chaque tour pour indiquer à chaque ennemi d'essayer de se déplacer vers le joueur.
        public void MoveEnemy ()
        {
            // Déclare les variables pour les directions X et Y. Leur valeur varie entre -1 et 1.
            // Ces valeurs nous permettent de choisir parmi les directions cardinales : haut, bas, gauche et droite.
            int xDir = 0;
            int yDir = 0;
            
            // Si la différence de position est proche de zéro (Epsilon) faire ce qui suit :
            if(Mathf.Abs (target.position.x - transform.position.x) < float.Epsilon)
                
                // Si la coordonnée Y de la cible (joueur) est plus grande que la coordonnée Y de cet ennemi, alors la direction en Y est 1 (pour se déplacer vers le haut). Sinon, c'est -1 (pour se déplacer vers le bas).
                yDir = target.position.y > transform.position.y ? 1 : -1;
            
            // Si la différence de position est proche de zéro (Epsilon) faire ce qui suit :
            else
                // Vérifie si la coordonnée X de la cible et plus grande que celle de cet ennemi. Dans ce cas, définit la direction en X à 1 (pour se déplacer vers la droite), sinon c'est -1 (pour se déplacer vers la gauche).
                xDir = target.position.x > transform.position.x ? 1 : -1;
            
            // Appelle la fonction AttemptMove en lui passant le paramètre générique Player, car Enemy se déplace et espère rencontrer un Player
            AttemptMove <Player> (xDir, yDir);
        }
        
        
        // La fonction OnCantMove est appelée si Enemy essaie de se déplacer vers un espace occupé par un Player. Surcharge la fonction OnCantMove de la classe MovingObject 
        //et prend un paramètre générique T par lequel nous passons le composant que nous souhaitons rencontrer, dans ce cas, le joueur.
        protected override void OnCantMove <T> (T component)
        {
            // Déclare hitPlayer et le définit à la valeur du composant rencontré.
            Player hitPlayer = component as Player;
            
            // Appelle la fonction LoseFood en lui passant playerDamage, le nombre de points de nourriture à enlever.
            hitPlayer.LoseFood (playerDamage);
            
            // Définit le déclencheur de l'attaque de l'animator pour démarrer l'animation d'attaque.
            animator.SetTrigger ("enemyAttack");

        }
    }
}