Les boucles en C#

Nous avons vu précédemment comment exécuter une portion de code une seule fois si une condition est vraie. Cette fois-ci, nous allons apprendre à exécuter une portion de code plusieurs fois tant que la condition reste vraie.

Les boucles while

Le fonctionnement des boucles while ressemble beaucoup aux structures conditionnelles comme if(), que nous avons vues précédemment. Cependant, cette fois, nous utilisons le mot-clé while, comme dans l'exemple suivant :

using UnityEngine;

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


    void Start()
    {
		while(vie >  2)
		{
			Debug.Log("ta vie est supérieur a 2!");
			vie--;
		}
    }

    void Update()
    {    

    } 
}

 Regardons la ligne suivante :   

while(vie >  2)

Dans cette boucle, la condition est vérifiée avant le début de chaque itération. La boucle continue de s'exécuter tant que la variable vie est supérieure à 2.

Remarquez également la ligne suivante :

vie--;

Si nous ne diminuons pas la valeur de vie à chaque itération, la boucle s'exécutera indéfiniment, ce qui entraînera un plantage du jeu, car la condition vie > 2 restera toujours vraie et le code sous la boucle ne s'éxécutera jamais.

Si vous faites quelque chose comme ceci :

using UnityEngine;

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


    void Start()
    {
		while(vie ==  10)
		{
			Debug.Log("ta vie est pleine!");
		}
    }

    void Update()
    {    

    } 
}

Votre ordinateur commencera à ralentir et Unity sera complètement figé. Il est donc crucial de toujours prévoir une condition qui permet à la boucle de se terminer. 

Pourquoi utiliser une boucle alors que nous avons Update ?

Certains d'entre vous se demanderont pourquoi utiliser des boucles alors que la méthode Update fait quelque chose de similaire. En fait, tout dépend de la manière dont vous construisez votre jeu. Une boucle vous permet de contrôler plus précisément son exécution et de la faire arrêter à un moment donné, tandis que Update est exécutée en permanence, à chaque frame.

Pour l'instant, vous manquez encore de connaissances pour exploiter pleinement les boucles, donc faites-moi confiance : les boucles sont essentielles !

Exemple avec un tableau

Reprenons les tableaux que nous avons vus dans la page précédente, et essayons d'afficher toutes les données qu'ils contiennent. Voici un exemple de code à essayer :

using UnityEngine;

public class Stats : MonoBehaviour
{
	private int[] statistique = {10,5,2};
	private int index = 0;

    void Start()
    {
		while(index <= 2)
		{
			Debug.Log(statistique[index]);
			index += 1;
		}
    }

    void Update()
    {    

    } 
}

Analysons ce code. Ici, nous avons une boucle qui affiche les éléments du tableau statistique. La variable index contient l'indice de l'élément que nous voulons lire. À chaque itération, nous incrémentons la valeur de index de 1, ce qui permet d'afficher l'élément suivant du tableau. Puisque notre tableau contient 3 éléments, nous devons arrêter la boucle lorsque index est supérieur à 2, car l'indice 3 n'existe pas. Rappelez-vous que les indices commencent à 0, donc dans ce cas, les indices disponibles sont 0, 1 et 2. 

Obtenir la taille d'un tableau et l'utiliser dans une boucle

Jusqu'à présent, nous avons utilisé des tableaux dont nous connaissions exactement le nombre d'éléments. Mais comment faire si nous ignorons la taille du tableau à l'avance ? Si nous essayons d'accéder à un indice qui n'existe pas, cela provoquerait une erreur et pourrait faire planter le jeu.

Pour éviter cela, nous pouvons utiliser la propriété Length d'un tableau (oui, les tableaux sont des objets en C#, tout comme les chaînes de caractères). Cela revient à faire ceci :

using UnityEngine;

public class Stats : MonoBehaviour
{
	public int[] statistique = {10,5,2};
	private int index = 0;
	private int tailleDuTableau; // ne peux pas utiliser Length tout de suite.

    void Start()
    {
		tailleDuTableau = statistique.Length; 
		Debug.Log("Taille: " + tailleDuTableau); // affiche Taille: 3

		while(index < tailleDuTableau)
		{
			Debug.Log(statistique[index]);
			index += 1;
		}
    }

    void Update()
    {    

    } 
}

Analysons cet exemple. Dans ce code, nous avons créé une variable tailleDuTableau de type int, qui contiendra le nombre d'éléments de notre tableau. Dans la méthode Start, nous obtenons la taille du tableau comme ceci :

tailleDuTableau = statistique.Length; 

Dans notre cas, statistiques.Length vaut 3.

Nous utilisons ensuite cette variable pour indiquer que la boucle doit s'exécuter tant que index est inférieur à tailleDuTableau (c'est-à-dire 3).

while(index < tailleDuTableau)

Notez qu'en C# classique, il aurait été possible d'initialiser la variable tailleDuTableau directement lors de sa déclaration, comme ceci :

private int tailleDuTableau = statistique.Lenght; 

Cependant, Unity ne permet pas d'utiliser la propriété Length directement lors de la déclaration d'une variable de classe. Cela est dû à des limitations spécifiques à Unity dans la gestion de l'initialisation des propriétés de classe.  Nous n'entrerons pas dans les détails ici, mais sachez que vous ne pouvez pas utiliser une autre variable comme valeur lorsque vous définissez les propriétés de votre classe. 

Simplification avec d'autres types de boucles

La boucle while n'est pas la seule disponible en C#. Il existe aussi les boucles foreach et for.

Commençons par la plus simple : la boucle foreach. Cette boucle est spécialement conçue pour parcourir les tableaux. Essayons ce code :

using UnityEngine;

public class Stats : MonoBehaviour
{
	public int[] statistique = {10,5,2};

    void Start()
    {
        foreach (int valeur in statistique)
        {
            Debug.Log("Valeur : " + valeur);
        }
    }

    void Update()
    {    

    } 
}

Ici, c'est beaucoup plus simple : nous n'avons plus besoin de connaître la taille du tableau ni de gérer un index qui augmente à chaque boucle.

Analysons les paramètres de cette boucle. Premièrement, nous avons int valeur. Cela crée une variable valeur de type int qui prendra successivement la valeur de chaque élément du tableau. La syntaxe in statistiques indique que la boucle parcourt le tableau statistiques. À chaque itération, la variable valeur prendra la valeur de l'élément suivant du tableau, jusqu'à ce que tous les éléments aient été traités.

Bref, c'est beaucoup plus simple et pratique. Cependant, la boucle foreach est principalement utilisée pour lire des tableaux, donc son usage est plus limité.

La boucle for

Passons maintenant à l'autre type de boucle, la boucle for. Voici un exemple :

using UnityEngine;

public class Stats : MonoBehaviour
{
	public int[] statistique = {10,5,2};

    void Start()
    {
        for (int i = 0; i < statistique.Length; i++)
        {
            Debug.Log("Valeur à l'index " + i + " : " + statistique[i]);
        }
    }

    void Update()
    {    

    } 
}

 

La boucle for se compose de trois paramètres, séparés par des points-virgules :

1. Initialisation : int i = 0 — On initialise une variable i à 0.
2. Condition : i < statistiques.Length — La boucle s'exécute tant que i est inférieur à la taille du tableau.
3. Incrémentation : i++ — À chaque itération, on incrémente i de 1.

Cette structure est plus compacte que la boucle while que nous avons utilisée précédemment. Cependant, elle peut être plus difficile à comprendre au début. L'avantage de la boucle for est que la variable i est uniquement accessible à l'intérieur de la boucle. Cela permet d'éviter de modifier par erreur l'index en dehors de la boucle.

En résumé, la boucle for permet d'écrire un code plus propre et plus concis, tout en limitant la portée de la variable d'index à la boucle elle-même. 

Conclusion

Ce que vous devez retenir de cette page :

• Il existe trois types de boucles en C# : while, foreach et for.
• Utilisez foreach pour parcourir un tableau et les deux autres pour des boucles plus générales.
• Pour travailler avec des tableaux de taille variable, vous pouvez utilisez la propriété Length pour obtenir la taille du tableau et l'utiliser dans vos boucles.

Les boucles sont un outil puissant pour le contrôle du flux dans vos jeux. Elles vous permettent de répéter des actions sans devoir écrire plusieurs fois le même code.

Courage, vous avez presque terminé les bases essentielles de la programmation en C#. Il ne nous reste plus qu'à apprendre la création de méthodes pour clôturer ce chapitre. Ensuite, nous passerons à la pratique en réutilisant tout ce que nous avons vu dans ce chapitre.