[Apprendre le GML] 2 - Condition

Apprendre le GML

Conditions

Sommaire

Simple condition
Opérateurs de comparaison
Le mot clé 'else'
Conditions multiples

1. Simple condition

Il seras souvent utile de faire un test avant de faire une action.
Par exemple si je veux afficher un message lorsque ma barre d'espace
est pressée, et bien il va falloir utiliser un nouveau concept : les conditions, représentées par le mot clé if.

Le if est de la forme :

if( <condition> ) // Si la condition est vérifiée
{
<instructions> // On effectue les instructions
}

Les accolades {} servent a définir un bloc d'instructions, si il y a plus
d'une instruction a effectuer en fonction de la condition.
Si il n'y a qu'une seule instruction, alors les accolades sont inutiles.

exemple (draw) :

Code:: draw_text(16, 16, "appuyez sur espace")

if( keyboard_check(vk_space) ) // on vérifie que la touche espace est pressée
{
draw_text(16, 32, "vous pressez espace") // Si oui on affiche notre texte
}

Explications :
le if vérifie que la condition qui suit est vrai.
Si elle est vrai il va effectuer l'instruction suivante, sinon il va la passer.

Une condition est vrai si elle est égale a true, qui est une constante définie par GM et qui vaut 1 (et signifie vrai).
Si une condition est fausse elle est égale a false, qui équivaut a 0 (et signifie faux).

En gros le if regarde juste si la condition qui suit est égale a 1 ou 0.

La fonction keyboard_check(vk_space) renvoie deux valeurs possibles : 0 si espace n'est pas pressé, et 1 sinon.
Nous pouvons donc l'utiliser directement comme condition.

keyboard_check est une fonction qui prend comme paramètre la touche dont on veux connaitre l'état (pressé ou non).
Il faut lui mettre comme paramètre une constante de GM qui définie une touche.
En voici quelques unes :
vk_space : espace
vk_left : gauche
Pour les lettre il faut utiliser la fonction ord(char)
ord('A') : la lettre A

notes:
Sous GM une condition est vrai si sa valeur est strictement positive, fausse sinon.
Ce n'est pas très important mais c'est bon a savoir.

2. Opérateurs de comparaison

Voici la liste des opérateurs de comparaison :
== : teste si égal
> : teste si plus grand
>= : teste si plus grand ou égal
< : test si plus petit
<= : teste si plus petit ou égal
!= : teste si n'est pas égal

Grâce a ces opérateurs, vous pourrez utiliser des conditions plus intéressantes.
Par exemple :
Create

Code:: temps=0

Draw

Code:: if( temp < 100 )
{
draw_text(16, 64, temps)
temps += 1
//Le += signifie incrémentation. temps += 1 équivaut a temps = temps +
//Il est possible aussi de décrémenter avec -=
}

if( temp == 100 )
draw_text( 16, 64, "la variable temps est arrivée a 100" )

Le ! signifie not, non en français. C'est une négation booléenne :
non vrai = faux
non faux = vrai
Sous GM :
!true = false <==> !1 = 0
!false = true <==> !0 = 1 car true et false correspondent respectivement a 1 et 0

Un test renvoie toujours une valeur booléenne (1 ou 0).
Exemples :
1 == 2 -> faux, renvoie donc 0 (false)
0 < 5 -> vrai, revoie 1 (true)
5 != 10 -> vrai, revoie 1

3. Le mot clé 'else'

Nous savons faire des tests avec le if, mais il se peut que l'on veuille écrire un code de la forme :
Si ma condition est vérifiée alors instruction 1, sinon si ma condition n'est pas vérifiée instruction 2.
Nous découvrons donc un nouveau mot clé : else ( sinon en fr )

Voici sa forme :
if(<condition>)
{
<instruction 1>
}
else
{
<instruction 2>
}

Et voici un exemple (draw) :

Code:: if(temp < 50) {
draw_text(16, 16, temp)
temp += 1
}
else
draw_text(16, 16, "temp est arrive a 50")

4. Conditions multiples

Regardez le code qui suit, il sert a vérifier que a = b = c :

Code:: a = 5
b = 2
c = 4

if(a == b) {
if(a == c)
draw_text(16, 16, "a = b = c")
else
draw_text(16, 16, "a, b, et c n'ont pas tous la même valeur")
}
else
draw_text(16, 16, "a, b, et c n'ont pas tous la même valeur")

C'est un code bien fastidieux pour la simple vérification que nous voulons faire.
Heureusement il existe des opérateur fait pour ne pas a avoir a imbriquer plusieurs conditions : les opérateurs booléens.

a) Opérateur 'and'

L'opérateur and permet de vérifier plusieurs conditions en une seule. Il s'utilise de cette manière :
if( <condition> and <condition2> and [...] and <conditonN> ) { <instructions> }

Simplifions maintenant le code vu précédemment :

Code:: a = 12
b = 12
c = 12

if( a == b and a == c )
draw_text(16, 32, "a = b = c")
else
draw_text(16, 32, "a, b, et c n'ont pas tous la même valeur")

Comme vous pouvez le voir le code deviens beaucoup plus court et propre. L'utilisation du and n'est pas négligeable
alors apprenez a l'utiliser le plus possible !

Fonctionnement du and :
Tout d'abord il faut savoir que and est un opérateur. On l'utilise comme un + ou un - .
Il obéit au règles qui suivent :
a and b = true si a et b sont égal a true
a and b = false si a ou b est égal a false
C'est un opérateur logique. Pas besoin d'apprendre ses règles par cœur, car vous les connaissez déjà par 'logique'.

mémo :
Une information est vrai si la totalité des données qui la constitue sont vrai.
Il suffit d'une seule donnée fausse pour falsifier l'information globale.

Important :
Le and peut être écrit d'une autre manière : &&
J'utilise par habitude &&, il faudra donc vous y faire, et surtout il ne faut pas être surpris par cette syntaxe que l'on retrouve énormément.

Informations facultatives :
En logique (électronique) le and est la multiplication binaire. Vous pouvez le vérifier car
true * true = true <==> 1*1 = 1
true *false = false <==> 1*0 = 0
false*false = false <==> 0*0 = 0 ce qui correspond aux règles du and.

Code:: if( (a==b)*(a==c) ) draw_text(16, 32, "a = b = c")
else draw_text(16, 32, "a, b, et c n'ont pas tous la même valeur")

est donc une autre manière d'écrire le code précédant.

b) L'opérateur 'or'

Cet opérateur 'ou inclusif' permet tout comme le and de simplifier de nombreuses conditions.
Il permettra de voir si une des multiples conditions passées au if sont vrai.

Nous allons, comme précédemment simplifier un code :

Code:: if(keyboard_check(vk_left)) draw_text(16, 32, "vous pressez une fleche")
else if(keyboard_check(vk_right)) draw_text(16, 32, "vous pressez une fleche")
else if(keyboard_check(vk_up)) draw_text(16, 32, "vous pressez une fleche")
else if(keyboard_check(vk_down)) draw_text(16, 32, "vous pressez une fleche")
else draw_text(16, 32, "vous ne pressez aucune fleche")

Avec l'utilisation du or cela donne :

Code:: if( keyboard_check(vk_left) or keyboard_check(vk_right)
or keyboard_check(vk_up) or keyboard_check(vk_down) )
draw_text(16, 48, "vous pressez une fleche")
else
draw_text(16, 48, "vous ne pressez aucune fleche")

Tout comme le and, le or est un opérateur logique très intuitif, que vous devez utiliser sans modération :p

Voici les règles de or :
true or true = true
true or false = true
false or false = false

Important : Le or s'écrit aussi || , habituez vous donc a cette syntaxe très utilisée.

Supplément : Comme le and qui est la multiplication booléenne dans l'algèbre de bool, le or lui est l'addition.

c) L'opérateur 'xor'

Après le ou inclusif voici le ou exclusif. Il est peu utilisé, mais peut être qu'un jour vous vous souviendrez
de lui dans une situation biscornue :p

Voici un exemple de son utilisation :

Code:: draw_text(16, 16, "pressez une touche fleche")

if( keyboard_check(vk_left) xor keyboard_check(vk_right)
xor keyboard_check(vk_up) xor keyboard_check(vk_down) )
draw_text(16, 32, "vous pressez une seule fleche")
else
draw_text(16, 32, "vous ne pressez pas qu'une seule fleche")

Pour l'exemple il se peut que lorsque l'on presse gauche bas et droite ça ne fonctionne pas.
C'est du au fait que le clavier ne supporte pas certaines combinaisons de touches, et ce n'est pas notre algorithme qui est faux.

Règles du xor :
true xor true = false
true xor false = true
false xor false = false

Important : Le xor se note aussi ^^ , a ne pas oublier.

Supplément : Le xor peut être écrit sous forme de and et de or : a xor b = (a and !b) or (!a and b)

La suite ici

» condition variable
» condition de position - paths
» Petit problème sur une condition if
» deux touches comme condition
» [Résolu] Variable selon une condition