[Apprendre le GML] 4 - Les boucles

Apprendre le GML

Les boucles

Sommaire

La boucle 'repeat'
La boucle 'while'
La boucle 'do'
La boucle 'for'
L'instruction 'break'
L'instruction 'continue'

Nous attaquons ici une partie très importante : Les Boucles !
Les boucles nous permetrons de faire des choses qui nous paraissaient avant
totalement impossible ou trop longues a coder.
Elles sont le ciment de la programmation, et il faudras être très attentif.

1. La boucle 'repeat'

La boucle la plus simple d'utilisation est définie par le mot clé repeat.
Elle répèteras n fois l'instruction qui la suit.

Voici sa forme :
repeat(nombre_iterations)
{
<instructions>
}

Exemple d'utilisation :

Code:: a = 0
repeat(10) {
draw_text(64, 16+16*a, a)
a += 1
}

De suite on comprend que les boucles nous permettrons de gagner beaucoup de lignes de code.
C'est exactement ce qu'elles nous permettrons de faire.
repeat est très simple a utiliser et a comprendre, mais les autres boucles sont un peu plus compliqués, alors entrainez vous a les utiliser !

Aussi le principe des boucles est toujours le même. On pourrais s'arrêter et n'utiliser que repeat.
Seulement vous verrez par la suite que les autres boucles nous permettrons de gagner énormément de temps, et de simplifier notre syntaxe.

2. La boucle 'while'

Nous voici a la boucle while (tant que) de la forme :
while( <condition> )
{
<instruction>
}

Cette boucle ne s'arrêtera que quand la condition dans ses parenthèses seras fausse.
Sinon elle continue a faire des tour de boucles (itérations).
Elle est utile quand on ignore le nombre de boucle qu'il faudra a notre algorithme pour résoudre notre problème, effectuer sa tache.

Exemple :

Code:: /*Nous voulons faire un algo qui compte le nombre de coups c qu'il
faut pour obtenir un certain nombre compris entre 0 et n en tirant des
nombres aléatoires.*/

nombre_voulu = 33
n = 1000
c = 0
rand = 0

while(rand != nombre_voulu)
{
rand = floor(random(n))
c += 1
}

Une des boucles les plus utilisées, entrainez vous jusqu'à la maitriser Wink

3. La boucle 'do'

Encore une boucle, très ressemblante a while, et assez rarement utile, mais a connaitre : la boucle do (faire)

do
{
<instructions>
}
until(<condition>)

until signifie 'jusqu'à ce que'
Pas besoin de s'étendre sur cette boucle, car elle est exactement pareil que while, sauf que la condition est vérifiée après l'instruction et non pas avant.
Ce qui fait que l'instruction seras au moins exécutée une fois, même si la condition est fausse.

4. La boucle 'for'

Voici de loin la boucle la plus importante et la plus utilisée.
La boucle for (pour) peut être utilisée comme un while, mais elle sert surtout a la base a faire un certain
nombre de boucles défini tout en modifiant une variable (ou même plusieurs) a chaque itération.
Bien sur il existe de nombreuses autre possibilités dans son utilisation, mais elles sont beaucoup plus rares.

Syntaxe :
for(<instruction1> ; <expression> ; <instruction2>)
{
<instruction3>
}

Fonctionnement :
A la première itération, <instruction1> va être exécutée, ensuite il va y avoir évaluation de <expression>.
Si on obtient false lors de l'évaluation, on arrête la boucle, sinon on continue.
A partir de la deuxième itération, <instruction2> va être exécutée, et il va y avoir a nouveau évaluation de <expression>
afin de savoir si on continue ou non la boucle. De même pour les itération suivantes.

La boucle for est très utilisée pour déclarer un tableau et le remplir de valeurs en quelques lignes au lieu de définir chaque case manuellement.
Bien sur elle est utilisée pour toute sorte de choses, que l'on verras par la suite.

Notes : Il est possible d'imbriquer des boucles for.

Exemples :

Code:: //Déclaration d'un tableau a une dimension de taille 20
for(i=0 ; i<20 ; i+=1)
{
tab[i] = 0 // J'initialise toutes les cases a zéro
}

Code:: //Il est possible de mettre des blocs dans <instruction1> et <instruction2>
for({i=0 j=0}; i<20; {i+=1 j+=i+1 draw_text(16 + j, 16*i, "salut")}) {} //Et on obtient un code farfelu

Code:: //un petit dessin
for(i=0; i<16; i+=1)
draw_line(640 - i*16, 0, 640, 16*16 - i*16)

//petit dégradé
for(i=0; i<256; i+=1)
draw_line_color(96+i,0,96+i,64 + 10*sqrt(i),make_color_hsv(i,255-min(abs(mouse_y/2), 255),255),0)

//cercle arc en ciel
for(i=0; i<100; i+=1)
draw_circle_color(500, 140, 100-i, c_white, make_color_hsv(i*3+mouse_x/2, 255, 255), 0)

5. L'instruction 'break'

Maintenant que nous avons appris a utiliser toutes les boucles une question devrais vous venir a l'esprit : comment arrêter une boucle n'importe quand ?
C'est a sa que sert l'instruction break (casser). S'il est placé dans une boucle il va l'arrêter instantanément et le programme va passer a la suite.
C'est un mot clé très important et très utilisé, alors retenez le.

Exemple :

Code:: //Prouvons la puissance du break en cassant une boucle infinie :
while(true) {
break
} //Hop on passe a la suite, et le programme continue

5. L'instruction 'continue'

Une dernière chose a apprendre avant de cloturer les boucles : continue (continuer).
Ce mot clé sert dans une boucle a sauter le code qui le suit et passer a l'itération suivante.
Il permet de simplifier l'écriture du code et alléger le contenu de notre boucle en conditions (le plus souvent).

La suite ici