Structures de contrôle en C#

Lors de la programmation en C#, un langage de programmation orienté objet utilisé dans le développement de jeux Unity, il est essentiel de comprendre les structures de contrôle. Ils vous permettent de contrôler le flux d'exécution du programme et de prendre des décisions en fonction des conditions. Les structures de contrôle en C# incluent des instructions conditionnelles, des boucles et des sauts.

Instructions conditionnelles

Les instructions conditionnelles permettent au programme de prendre des décisions basées sur des conditions spécifiques. Ils sont indispensables pour créer des jeux interactifs et réactifs. Les principales instructions conditionnelles en C# sont if, else if, else et switch.

If : L'instruction « if » teste une condition et exécute un bloc de code si la condition est vraie. Par exemple :

si (Vie du joueur > 0) { // Code pour continuer le jeu }

Else if : l'instruction « else if » est utilisée pour tester plusieurs conditions. Si la condition « si » est fausse, la condition « sinon si » est testée. Si la condition « else if » est vraie, le bloc de code correspondant est exécuté. Par exemple :

si (Vie du joueur > 70) { // Code pour le statut 'Sain' } sinon si (Vie du joueur > 30) { // Code pour le statut 'Blessé' }

Else : l'instruction « else » est utilisée lorsque toutes les conditions précédentes sont fausses. Le bloc de code à l’intérieur de « else » est exécuté. Par exemple :

Continuez dans notre application.

Vous pouvez écouter le livre audio écran éteint, recevoir un certificat gratuit pour ce cours et accéder également à 5 000 autres cours en ligne gratuits.

Ou poursuivez votre lecture ci-dessous...

Téléchargez l'application

si (Vie du joueur > 70) { // Code pour le statut 'Sain' } sinon si (Vie du joueur > 30) { // Code pour le statut 'Blessé' } autre { // Code pour le statut 'Critique' }

Switch : L'instruction 'switch' est utilisée pour sélectionner un bloc de code à exécuter parmi plusieurs options. Chaque option est appelée « cas », et le programme exécutera le bloc de code correspondant à la valeur de la variable. Par exemple :

changer (niveau du joueur) { cas 1: // Code pour le niveau 1 casser; cas 2 : // Code pour le niveau 2 casser; défaut: // Code pour niveaux inconnus casser; }

Boucles

Les boucles vous permettent d'exécuter un bloc de code plusieurs fois. Ils sont utiles pour les tâches répétitives. Les principaux types de boucles en C# sont for, while et do-while.

For : La boucle « for » est utilisée lorsque vous savez combien de fois le bloc de code doit être répété. Par exemple :

pour (int i = 0; i < 10; i++) { // Code à répéter 10 fois }

While : La boucle « while » est utilisée lorsque vous souhaitez que le bloc de code soit répété tant qu'une condition est vraie. Par exemple :

pendant que (Vie du joueur > 0) { // Code pour continuer le jeu }

Do-while : La boucle « do-while » est similaire à la boucle « while », mais la condition est testée après l'exécution du bloc de code. Cela garantit que le bloc de code est exécuté au moins une fois. Par exemple :

de { // Code pour jouer une partie } while (Vie du joueur > 0) ;

Talons

Les instructions Jump vous permettent de contrôler le déroulement du programme en accédant à d'autres parties du code. Les principales instructions de saut en C# sont break, continue et return.

Break : L'instruction 'break' est utilisée pour quitter la boucle ou le commutateur en cours. Par exemple :

pour (int i = 0; i < 10; i++) { si (je == 5) { casser; } // Code à répéter jusqu'à ce que i soit égal à 5 }

Continuer : L'instruction 'continue' est utilisée pour ignorer le reste de la boucle en cours et démarrer l'itération suivante. Par exemple :

pour (int i = 0; i < 10; i++) { si (je == 5) { continue; } // Code à répéter, sautant lorsque i est égal à 5 }

Return : L'instruction 'return' est utilisée pour terminer l'exécution de la fonction en cours et renvoyer une valeur. Par exemple :

int Somme(int a, int b) { renvoyer a + b ; }

En résumé, les structures de contrôle en C# sont fondamentales pour programmer des jeux avec Unity. Ils vous permettent de contrôler le flux d'exécution du programme, de prendre des décisions basées sur des conditions et d'effectuer des tâches répétitives. La maîtrise de ces structures de contrôle vous permettra de créer des jeux plus complexes et interactifs.