On retrouve les conditions dans beaucoup de langages, mais qu'est ce que les conditions?
C'est ce que nous allons essayer de comprendre durant ce chapitre.
Une condition sert à tester une variable. Dans votre vie de tous les jours vous êtes confronté à de nombreuses conditions, plus ou moins sympathiques, par exemple :
CitationSi j'ai donné deux euros à la boulangère, alors j'ai du pain.
Ou encore :
CitationSi je n'ai pas un donné deux euros à la boulangère, alors je n'ai pas de pain.
Cette deuxième condition vas être une conséquence de la première et vice versa.
Donc dans un programme de jeu ça pourrait donner :
Code : Algorithme - Sélectionner1
2
| Si je meurs
Alors j'ai perdu la partie |
Ici en Axe Parser avec V qui est égal à 1 s'il reste une vie, ou V est égal à 0 s'il ne reste aucune vie :
Code : Axe Parser - Sélectionner1
2
3
| :If V=0
:Disp "Game Over"
:End |
Si l'on examine ce code avec précision :
Code : Axe Parser - Sélectionner
S'il n'y a plus de vie.
Code : Axe Parser - Sélectionner
On affiche
Game Over.
Code : Axe Parser - Sélectionner
Toute structure conditionnelle se termine par un End. Celui ci est présent pour signaler à notre programme que notre condition est terminé, et que le code reprend son cours normal. Si il n'y a pas de End, ou qu'il y a un End en trop, vous aurez une erreur
ERR:BLOCK lors de la compilation.
"V=0" ? ça ressemble drôlement à des booléens !
C'est là que je voulais en venir, le principal intérêt sera d'utiliser des booléens dans des conditions, et croyez moi ça facilite vraiment la vie!
On a vue précédemment les conditions les plus courtes :
Code : Axe Parser - Sélectionner1
2
3
4
| :If (maCondition)
:.le code à exécuter
:End
:.toujours terminer par un End! |
Note : maCondition sera donc une opération booléenne!
Maintenant, si l'on veut exécuter un code quand la condition est vraie, et un autre quand est est fausse, on utilisera Else de la façon suivante :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :If (maCondition)
:.le code à exécuter si la condition est VRAI
:Else
:.sinon on exécute le code suivant
:."code suivant"
:End
:.(on oublie pas le End) |
Mais mon code va vite fait se remplir de If, Else et End !
Oui! C'est un programme!
Mais je vous rassure, on peut organiser ses conditions, grâce à une autre commande : ElseIf
Elseif sera utilisé comme ceci :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
| :If (maPremièreCondition)
:.le code à exécuter si la condition est vraie
:Elseif (maDeuxièmeCondition)
:.sinon si la deuxième condition est vraie, on exécute le code suivant
:."code suivant"
:Else
:.sinon ce code est exécuté.
:End |
Par exemple je reprend notre système de vie :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :If V=0
:Disp "Game over"
:Elseif V=1
:Disp "Il ne vous reste plus qu'une vie !"
:Else
:Disp "Vous êtes en parfaite santé"
:End |
Bon, jusque la ce n'est pas trop compliqué? j'espère que non, car maintenant on va rajouter les calculs booléens (que vous maitrisez parfaitement

) dans ces conditions.
La puissance des conditions prend tout son ampleur lorsqu'on la mélange avec les tests logiques que l'on a vu précédemment :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| :If A=0
:.Mon code
:End
:If A≠0
:.Mon code
:End
:If A<0
:.Mon code
:End
:If A>0
:.Mon code
:End
:If A≥0
:.Mon code
:End
:If A≤0
:.Mon code
:End |
Puis les comparateurs logiques :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
| :If (A=0) and (B≠8)
:.Mon code
:End
:If (A<0) or (B>8)
:.Mon code
:End
:If (A≥0) xor (B≤8)
:.Mon code (ne sera jamais exécuté ici)
:End |
Ici on a vu les conditions les plus simples à comprendre. Mais grâce aux booléens, on peut simplifier l'écriture suivante :
Code : Axe Parser - Sélectionner1
2
3
| :If A=1
:.le code s'exécutera si A est VRAI
:End |
En celle ci :
Code : Axe Parser - Sélectionner1
2
3
| :If A
:.le code s'exécutera si A est VRAI
:End |
Ici, A s'exécutera si il est plus grand ou égale à 1
Et si A est négatif, il n'y a pas un moyen plus simple que If A≠0
Si il y existe les conditions inversé, j'allais en parler

.
En faite, les conditions inversés sont exactement pareil que les conditions normale. On rajoutera juste le point d'exclamation
! :
Code : Axe Parser - Sélectionner1
2
3
| :!If A
:.Si A est FAUX, on exécute ce code
:End |
Il marchera donc pour toutes les variantes de la structure conditionnelle vu précédemment :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
| :!If (maCondition)
:.le code à exécuter si la condition est FAUX
:Else
:.sinon on exécute ce code
:End |
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :!If V
:Disp "Game over"
:Else!if V>1
:Disp "Il ne vous reste plus qu'une vie !"
:Else
:Disp "Vous êtes en parfaite santé"
:End |
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
| :!If (A=0) and (B≠8)
:.Mon code
:End
:!If (A<0) or (B>8)
:.Mon code
:End
:!If (A≥0) xor (B≤8)
:.Mon code (sera toujours exécuté ici)
:End |
Ce type de condition est plus dur à comprendre car en plus de tester une conditions, il va agir sur la variable testé en la décrémentant de 1 à chaque fois qu'elle est testé. Quand cette variable atteint 0, elle est restitué à sa valeur maximum que l'on aura définie.
Code : Axe Parser - Sélectionner1
2
3
| :DS<(VARIABLE,VALEURMAXIMUM)
:.code1
:End |
Un exemple de conditions décrémentés :
Code : Axe Parser - Sélectionner
La première fois que la condition sera testé, X=3, comme X n'est pas égale à 0 on enlève 1 à X et le code1 est ignoré, la deuxième fois X=2, pareil on enlève 1 et on ignore code1, la troisième fois X=1, on enlève 1 et on ignore toujours le code1. La quatrième fois X=0, le code1 est exécuté, et X=3.
Mais comment cette condition peut être testé plusieurs fois dans le même code?
Cela tombe bien, c'est le sujet de notre prochain chapitre :
Les boucles.