Unity - Roguelike 2D

using UnityEngine;
using System.Collections;

namespace Completed
{
    // Le joueur hérite de MovingObject, notre classe de base pour les objets qui peuvent se déplacer. Les ennemis héritent aussi de celle-ci.
    public class Player : MovingObject
    {
        public float restartLevelDelay = 1f;        // Temps d'attente en secondes pour redémarrer le niveau.
        public int pointsPerFood = 10;              // Nombre de points à ajouter aux points de nourriture du joueur lorsqu'il récupère de la nourriture.
        public int pointsPerSoda = 20;              // Nombre de points à ajouter aux points de nourriture du joueur lorsqu'il récupère un soda.
        public int wallDamage = 1;                  // Nombre de dégâts que le joueur inflige à un mur.
        
        
        private Animator animator;                  // Utilisé pour stocker une référence vers le composant d'animation du joueur.
        private int food;                           // Utilisé pour stocker le nombre total de points de nourriture au cours du niveau.
        
        
        // Surcharge de la fonction Start de MovingObject
        protected override void Start ()
        {
            // Récupère une référence vers le composant d'animation du joueur.
            animator = GetComponent<Animator>();
            
            // Récupère le nombre de points de nourriture stocké dans GameManager.instance entre les niveaux.
            food = GameManager.instance.playerFoodPoints;
            
            // Appelle la fonction Start de la classe de base MovingObject.
            base.Start ();
        }
        
        
        // Cette fonction est appelée lorsque le comportement passe désactivé ou inactif.
        private void OnDisable ()
        {
            // Lorsque le joueur est désactivé, stocke le nombre de points de nourriture dans le GameManager, afin de le recharger au prochain niveau.
            GameManager.instance.playerFoodPoints = food;
        }
        
        
        private void Update ()
        {
            // Si ce n'est pas le tour du joueur, quitte la fonction.
            if(!GameManager.instance.playersTurn) return;
            
            int horizontal = 0;     // Utilisé pour stocker la direction du déplacement horizontal.
            int vertical = 0;       // Utilisé pour stocker la direction du déplacement vertical.
            
            
            // Récupère les entrées du gestionnaire d'entrées, l'arrondit en un entier et le stocke dans horizontal pour définir la direction sur l'axe des X.
            horizontal = (int) (Input.GetAxisRaw ("Horizontal"));
            
            // Récupère les entrées du gestionnaire d'entrées, l'arrondit en un entier et le stocke dans vertical pour définir la direction sur l'axe des Y.
            vertical = (int) (Input.GetAxisRaw ("Vertical"));
            
            // Vérifie si le déplacement est horizontal, si c'est le cas vertical est mis à zéro.
            if(horizontal != 0)
            {
                vertical = 0;
            }
            
            // Vérifie si l'une des deux valeurs n'est pas à zéro.
            if(horizontal != 0 || vertical != 0)
            {
                // Appelle AttemptMove en passant le paramètre générique Wall, afin que le joueur puisse interagir avec s'il en rencontre un (en l'attaquant).
                // Passe horizontal et vertical en paramètres pour indiquer la direction du joueur.
                AttemptMove<Wall> (horizontal, vertical);
            }
        }
        
        // AttemptMove surcharge la fonction AttemptMove de la classe de base MovingObject.
        // AttemptMove prend un paramètre générique T qui, pour le joueur, sera un Wall et prend aussi deux entiers pour la direction X et Y du joueur.
        protected override void AttemptMove <T> (int xDir, int yDir)
        {
            // Chaque fois que le joueur se déplace, réduit le nombre de points de nourriture.
            food--;
            
            // Appelle la méthode AttemptMove de la classe de base, en passant le composant T (dans ce cas, un Wall) et la direction de déplacement.
            base.AttemptMove <T> (xDir, yDir);
            
            // hit nous permet de référencer le résultat d'un lancer de rayon effectué dans la fonction  Move.
            RaycastHit2D hit;
            
            // Si la fonction Move retourne true, cela indique que le joueur peut se déplacer dans un espace vide.
            if (Move (xDir, yDir, out hit)) 
            {
                // Appelle RandomizeSfx du SoundManager pour jouer le son du déplacement, en lui passant deux clips audio.
            }
            
            // Comme le joueur s'est déplacé et a perdu des points de nourriture, vérifions si la partie n'est pas finie.
            CheckIfGameOver ();
            
            // Définit le booléen playersTurn du GameManager à false comme le tour du joueur est fini.
            GameManager.instance.playersTurn = false;
        }
        
        
        // La fonction OnCantMove surcharge la fonction abstraite OnCantMove de MovingObject.
        // Elle prend un paramètre générique T qui, dans le cas du joueur, est un mur que le joueur peut attaquer et détruire.
        protected override void OnCantMove <T> (T component)
        {
            // Définit hitWall avec le composant passé en paramètre.
            Wall hitWall = component as Wall;
            
            // Appelle la fonction DamageWall du Wall que nous attaquons.
            hitWall.DamageWall (wallDamage);
            
            // Définit le déclencheur d'attaque du contrôleur d'animation du joueur pour jouer l'animation d'attaque.
            animator.SetTrigger ("playerChop");
        }
        
        
        // La fonction OnTriggerEnter2D est envoyée lorsqu'un autre objet entre dans la boite de collision de cet objet (physique 2D seulement).
        private void OnTriggerEnter2D (Collider2D other)
        {
            // Vérifie si le tag de l'objet en collision est une sortie.
            if(other.tag == "Exit")
            {
                // Appelle la fonction Restart pour démarrer le prochain niveau avec un retard de restartLevelDelay (1 seconde par défaut).
                Invoke ("Restart", restartLevelDelay);
                
                // Désactive le joueur, car le niveau est terminé.
                enabled = false;
            }
            
            // Vérifie si le tag de l'objet en collision est de la nourriture.
            else if(other.tag == "Food")
            {
                // Ajoute pointsPerFood au nombre de points de nourriture du joueur.
                food += pointsPerFood;
                
                // Désactive l'objet de nourriture avec lequel le joueur est en collision.
                other.gameObject.SetActive (false);
            }
            
            // Vérifie si le tag de l'objet en collision est un soda.
            else if(other.tag == "Soda")
            {
                // Ajoute pointsPerSoda au nombre de points de nourriture.
                food += pointsPerSoda;
                
                
                // Désactive l'objet de soda avec lequel le joueur est en collision.
                other.gameObject.SetActive (false);
            }
        }
        
        
        // Redémarre la scène.
        private void Restart ()
        {
            // Charge la dernière scène chargée, dans ce cas Main, la seule scène du jeu.
            Application.LoadLevel (Application.loadedLevel);
        }
        
        
        // La fonction LoseFood est appelée lorsqu'un ennemi attaque le joueur.
        // Elle prend un paramètre 'loss' qui spécifie le nombre de points perdus.
        public void LoseFood (int loss)
        {
            // Définit le déclencheur du contrôleur d'animation pour déclencher l'animation playerHit.
            animator.SetTrigger ("playerHit");
            
            // Soustrait le nombre de points de nourriture du total.
            food -= loss;
            
            // Vérifie si le jeu est terminé.
            CheckIfGameOver ();
        }
        
        
        // La fonction CheckIfGameOver vérifie si le joueur n'a plus de points de nourriture et si cela est le cas, termine la partie.
        private void CheckIfGameOver ()
        {
            // Vérifie le nombre de points de nourriture total.
            if (food <= 0) 
            {
                
                // Appelle la fonction GameOver de GameManager.
                GameManager.instance.GameOver ();
            }
        }
    }
}