Nous avons appris à effectuer des opérations mathématiques dans la page précédente. Cette fois-ci, nous allons découvrir comment exécuter des portions de code en fonction de certaines conditions.

Les conditions : Un pilier de la programmation

En programmation, les conditions sont très simples à utiliser. Elles permettent de définir des blocs de code qui s'exécutent seulement si certaines conditions sont remplies. Les mots-clés les plus utilisés sont if (si) et else (sinon). Regardons un exemple.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;

    void Start()
    {
		if(vie == 0)
		{
			Debug.Log("Le joueur est mort!");
		}
    }

    void Update()
    {    

    } 
}

Testez le code. Normalement, rien ne se passe. En effet, la condition dans if(vie == 0) n'est pas vraie, car nous avons initialisé la variable vie à 10. Comme la condition est fausse (la vie n'est pas égale à 0), le bloc de code à l'intérieur de if ne sera pas exécuté.

Note importante : Pour vérifier une égalité, nous utilisons == (deux signes égal), contrairement à l'assignation de valeur où un seul signe égal est utilisé.

Maintenant, essayons avec vie égal à 0.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 0;

    void Start()
    {
		if(vie == 0)
		{
			Debug.Log("Le joueur est mort!");
		}
    }

    void Update()
    {    

    } 
}

Cette fois, le bloc if s'exécute, car la condition vie == 0 est vraie, ce qui signifie que le joueur est mort...

Sinon (else) ?

Supposons maintenant que vous souhaitiez afficher un message si le joueur n'est pas mort. Vous pouvez utiliser else pour définir un bloc de code à exécuter lorsque la condition de if n'est pas remplie.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;

    void Start()
    {
		if(vie == 0)
		{
			Debug.Log("Le joueur est mort!");
		}
		else
		{
			Debug.Log("Le joueur est vivant...");
		}
    }

    void Update()
    {    

    } 
}

Ici, si la condition if(vie == 0) est fausse, le bloc else sera exécuté, et le message "Le joueur est vivant..." sera affiché.

Vérifier plusieurs conditions avec if, else if, et else

Imaginons maintenant que vous souhaitiez afficher un message différent en fonction du nombre de points de vie du joueur. Vous pouvez utiliser else if pour tester plusieurs conditions.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;

    void Start()
    {
		if(vie == 0)
		{
			Debug.Log("Le joueur est mort!");
		}
		else if(vie == 10)
		{
			Debug.Log("Le joueur est en pleine forme");
		}
		else if(vie == 1)
		{
			Debug.Log("Le joueur est presque mort");
		}
		else
		{
			Debug.Log("Le joueur est vivant...");
		}
    }

    void Update()
    {    

    } 
}

Dans cet exemple. Le code est lu de haut en bas. Il vérifie d'abord si la vie du joueur est égale à 0. Si ce n'est pas le cas, il teste ensuite si la vie est égale à 10, et ainsi de suite. Si l'une des conditions est vraie, le code correspondant est exécuté, et les autres conditions ne sont pas vérifiées, même si elles sont également vraies. Nous avons donc uniquement la phrase suivant d'affichée.

"Le joueur est en pleine forme"

Les variables bool (vrai/faux)

Les conditions en programmation retournent une valeur de type booléen (vrai ou faux). Cela permet de contrôler l'exécution du code.

Il est possible de créer une variable de type bool et de lui assigner une valeur de true (vrai) ou false (faux). Par exemple :

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;
	private bool vivant = true;

    void Start()
    {
		if(vivant)
		{
			Debug.Log("Le joueur est viant!");
		}
		else
		{
			Debug.Log("Le joueur est mort");
		}
    }

    void Update()
    {    

    } 
}

Ici, nous avons créé une variable vivant de type bool, qui vaut true. Lorsque nous vérifions la condition if(vivant), elle est vraie, donc le code du bloc if est exécuté.

Comprendre les variables de type bool est essentiel, car de nombreuses fonctionnalités dans Unity les utilisent. Par exemple, la gravité d'un composant Rigidbody est en réalité une variable bool. Selon sa valeur, l'objet subira ou non la gravité. 

Tester d'autres conditions

Jusqu'à présent, nous avons vérifié si une variable était égale à une autre, mais il existe d'autres opérateurs pour tester des conditions. Par exemple, avec les signes < (plus petit que) et > (plus grand que), vous pouvez comparer des nombres.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;

    void Start()
    {
		if(vie > 5)
		{
			Debug.Log("la santé du joueur est bonne!");
		}
		else
		{
			Debug.Log("Le joueur va bientôt mourrir");
		}
    }

    void Update()
    {    

    } 
}

La condition vie > 5 vérifie si la variable vie est plus grande que 5. Si vous voulez tester si la vie est plus petite que 5, vous utilisez vie < 5.

Si vous voulez aussi tester si une valeur est plus grande ou égale à 5, vous utilisez >=, et pour plus petite ou égale, vous utilisez <=.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 5;

    void Start()
    {
		if(vie >= 5)
		{
			Debug.Log("la santé du joueur est bonne!");
		}
		else
		{
			Debug.Log("Le joueur va bientôt mourrir");
		}
    }

    void Update()
    {    

    } 
}

Tester si une condition n'est pas égale

Si vous voulez tester si une condition n'est pas égale à une valeur, vous utilisez le signe !=.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 9;

    void Start()
    {
		if(vie != 10)
		{
			Debug.Log("Le joueur n'a pas toutes sa vie");
		}
		else
		{
			Debug.Log("Le joueur a toutes sa vie");
		}
    }

    void Update()
    {    

    } 
}

Dans cet exemple, if(vie != 10) vérifie si la variable vie n'est pas égale à 10. Comme vie vaut 9, la condition est vraie et le code du bloc if est exécuté.

Vous pouvez aussi utiliser cette logique avec des variables bool.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 9;
	private bool vivant = true;

    void Start()
    {
		if(!vivant)
		{
			Debug.Log("Le joueur est mort");
		}
		else
		{
			Debug.Log("Le joueur est vivant");
		}
    }

    void Update()
    {    

    } 
}

Ici c'est un peu moins évident a comprendre.  Dans l'exemple, !vivant vérifie si vivant est faux. Si vivant vaut true, la condition retourne false et le bloc else est exécuté. 

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 9;
	private bool vivant = false;

    void Start()
    {
		if(!vivant)
		{
			Debug.Log("Le joueur est mort");
		}
		else
		{
			Debug.Log("Le joueur est vivant");
		}
    }

    void Update()
    {    

    } 
}

Ici, la condition n'a pas changé, seule la valeur de la variable vivant a été modifiée. Cette fois, la condition est vraie, car nous vérifions si la variable vivant vaut false. En d'autres termes, nous demandons si false est égal à false, ce qui est bien le cas. La condition étant vraie, le code à l'intérieur de la structure if s'exécute.

Je comprends que cela puisse être difficile à saisir pour certains. Si c'est votre cas, je vous encourage à prendre un moment pour tester et bien assimiler ce concept.

Vérifier plusieurs conditions avec && (et) et || (ou)

Enfin, vous pouvez combiner plusieurs conditions en utilisant && (et) et || (ou).

Avec && (et), toutes les conditions doivent être vraies pour que le bloc de code s'exécute.

 

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;
	private bool vivant = true;

    void Start()
    {
		if(vie ==  10 & vivant)
		{
			Debug.Log("Le joueur a 10 vie et est vivant!");
		}
    }

    void Update()
    {    

    } 
}

Ici, la condition if(vie == 10 && vivant) vérifie si la vie est égale à 10 et si le joueur est vivant.

Vous pouvez aussi en utiliser plusieurs.

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 10;
	private bool vivant = true;

    void Start()
    {
		if(vie ==  10 & vivant & vie > 5)
		{
			Debug.Log("Le joueur a 10 vie et est vivant et a plus que 5 point de vie");
		}
    }

    void Update()
    {    

    } 
}

Maintenant, passons au signe ||.  Avec || (ou), une seule des conditions doit être vraie pour que le bloc de code s'exécute. 

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int vie = 3;
	private bool vivant = true;

    void Start()
    {
		if(vie ==  10 || vivant)
		{
			Debug.Log("Le joueur a soit 10 vie ou est vivant");
		}
    }

    void Update()
    {    

    } 
}

Ici, le bloc if s'exécute si l'une des deux conditions est vraie, même si l'autre est fausse. 

En conclusion

Vous avez maintenant appris à utiliser les conditions en programmation, ainsi que le type bool. Ces concepts sont fondamentaux et largement utilisés dans la programmation de jeux avec Unity. N'hésitez pas à expérimenter pour bien les comprendre !

Dans la prochaine page du cours, nous apprendrons à utiliser un nouveau type de variable, les tableaux.

À bientôt.