Les instructions if et else sont les plus importantes instructions de tout langage de programmation : elles vont vous permettre de décider si une partie de votre code devra être exécuté ou non. Basiquement, le code est exécuté si la condition est vérifiée :

Mettons que la condition soit : a == b et que a = b (a, b deux entiers). Dans ce cas, la condition renvoie VRAI (true) et l'instruction sera exécutée.

Dans ce cas-ci, notre « instruction » tiens sur une ligne : vous pouvez omettre les accolades. Si votre code fait plusieurs lignes, vous devez utiliser les accolades :

Maintenant, nous avons notre condition : néanmoins, il ne se passe rien si celle-ci est fausse. Pour cela, on va utiliser la structure else (sinon) :

(On suppose que « instruction1 » et « instruction2 » sont sur une ligne)
Ainsi, si on reprend notre exemple : on teste a == b, et dans ce cas a > b. Alors l' « instruction2 » sera exécutée au lieu de l'«instruction1».

Vous pouvez bien sur combiner les else et les if : reprenons notre exemple :

Nous vérifions donc successivement :

Nous avons indenté notre exemple pour bien vous montrer une chose importante à savoir (ça peut être la cause d'erreurs pour des conditions plus compliquées) : dans un premier temps, on vérifie si a = b, et dans ce cas on va effectuer l'instruction a = b, si a != b alors on va vérifier en premier lieu si a > b, puis en second lieu si ce n'est pas le cas si a < b et enfin si aucune des expressions n'est vérifiée on exécute l'instruction 'a=a'.

Si vous n'avez pas compris, focalisez vous sur les mots 'premier' et 'seconds' : l'ordre des conditions importe, c'est-à-dire que vous ne pourrez pas avoir de condition 'a < b' sans avoir de conditions 'a == b' et 'a > b'.

Au passage, vous noterez l'inutilité totale du else : nous avons vu chacun des cas possibles.

Voici des exemples de conditions plus compliquées (elles proviennent d'un script en PHP) : vous noterez l'utilisation des parenthèses pour bien séparer les différentes parties de la condition.

Il s'agit sûrement d'horreurs pour quelqu'un qui débute, mais ces cas là ne sont pas inexistants. Vous aurez vous aussi peut-être besoin de faire d'aussi longues conditions. Pour éviter les erreurs, vous avez plusieurs méthodes :

Vous pouvez décomposer la condition :
(Note : en PHP les variables ne sont pas typées par défaut. Dans le cas des NWScripts vous devrez déclarer des entiers)

Ce qui nous donne :

Ce qui, vous l'avouerez est plus lisible, ou plus compréhensible. Néanmoins, vous stockez des variables supplémentaires pour RIEN. C'est tout l'avantage de la deuxième solution :

Tout de suite, cela prend bien plus de place mais cette méthode est plus utile : premièrement, on n'utilise pas de sous variables, deuxièmement en général le compilateur accepte cette forme, et troisièmement on peut plus facilement savoir ce qui se passe exactement à l'intérieur de notre condition : c'est le but de l'indentation.

Enfin, nous vous avions parlé de l'opérateur ternaire ( « ? : ») : celui-ci permet de faire une condition « if ( condition ) { instruction } else {} » sur une ligne : il a cependant de grandes différences avec le couple if/ else : il ne permet pas d'effectuer toutes les instructions voulues, ça n'est pas son but. Son but ? C'est d'affecter à une variable une valeur en fonction d'une condition.
Voilà la syntaxe générale :

(On a mis « = » mais ça peut être += , etc.)

Par exemple :

Cet opérateur ternaire est très pratique, mais évitez d'en abuser. Par exemple évitez ceci :

La condition étant la même dans les deux cas, préférez plutôt ceci :

Un autre aspect pratique de la programmation est la boucle. Si on reprend notre exemple sur les variables globales :

Ici, on a écrit 100 fois CreateItemOnObject( "item", oPlayer ); ! Maintenant, avec les boucles, on va pouvoir réduire ceci et corriger cette erreur. L'avantage étant que vous réduirez ainsi la taille de vos scripts (sachant qu'ils sont limités à 512 Ko avec le patch 1.26).

Pour effectuez 100 fois l'instruction CreateItemOnObject( "item", oPlayer ); nous avons trois structures de contrôle qui vont nous permettre de réduire notre code.

La première, c'est l'instruction while, la seconde, l'instruction for et enfin la troisième do ... while.

Voici la syntaxe de while :

Ici tant que la condition sera VRAIE alors l'instruction sera effectuée. L'instruction est supposée permettre à la condition d'être fausse à un moment : si tel n'est pas le cas, alors vous créerez une boucle infinie ce qui représente bien entendu un danger.

Voici un exemple de boucle simple :

Et un exemple de boucle infinie :

Dans d'autres cas, on peut avoir :

Il s'agit d'un autre type de boucle infinie : ici, on teste la condition i différent de 10 et on empêche que i soit égal à 10.

Voici notre exemple réécrit avec la boucle while :

Vous voyez ? Notre exemple est tout de suite plus propre. Mais ... nous avons oublié de mettre i++ pour que la boucle puisse se fermer...

(Note : on peut mettre i++ avant CreateItemOnObject)

L'instruction while permet de créer des boucles simplement, sans trop s'embêter. Néanmoins, il faudra penser à chaque fois à mettre une instruction permettant d'arrêter la boucle.

L'autre façon de créer des boucles, c'est avec l'instruction for : celle-ci est plus « sécuritaire » puisque dans sa déclaration vous devez indiquez l'état de départ, la condition à vérifier et une instruction qui sera évaluée à chaque itération (une itération = un passage dans la boucle).

Voici la syntaxe :

expression_depart : correspond à l'état initial : cette expression est exécutée lors de la première itération. Le plus souvent, il s'agit de définir la valeur initiale d'un entier : i = 0.

condition : tout comme l'instruction while il vous faut une condition pour que la boucle puisse tourner. Le plus souvent on teste la valeur d'un entier (si celle-ci est inférieure à x par exemple) : i < x;

instruction1 : il s'agit d'une instruction qui est exécutée quoiqu'il arrive. Cette instruction doit permettre de fermer la boucle : par exemple, i++.

instruction2 : instruction à exécuter.

Voici notre exemple réécrit avec la boucle for :

Note : on commence à 1 et on va jusqu'à 100 inclus, ce qui nous fait bien 100 objets de créés.

C'est à peu près tout ce qu'il y a à savoir sur les fonctions. Nous verrons plus loin dans cette section deux autres instructions qui sont très utiles avec les boucles.

Dans notre exemple avec la boucle For nous ne sommes pas forcés de mettre les accolades car notre instruction ne tient que sur une seule ligne.

De même, avec la boucle while :

Ce qui peut s'écrire :

Ici on pré incrémente i : ce qui veut dire que lors de la première itération de la boucle, i vaut 1 et pas 0 : c'est pour cela que l'on doit utiliser l'opérateur « inférieur ou égal à ».

Il existe aussi un troisième type de boucle : do ... while. Voici sa syntaxe :

Dans ce type de boucle, le code est d'abord exécuté (même si la condition est fausse) et la condition est ensuite vérifiée.

Voici notre exemple :

ou

L'instruction switch est en fait une sorte de if mais imbriqué : vous allez tester la valeur d'un entier (généralement) et en fonction des différents cas, vous utiliserez une instruction switch.

Voici un exemple :

Avec switch ceci donnerait :

Rien de bien compliqué dans cet exemple : cependant, vous remarquerez l'instruction break, dont nous reparlerons plus tard : celle-ci permet de sortir du bloc switch.

Voici un exemple sans ce break :

Au sortir du bloc switch j aura la valeur suivante : 1 si i = 2, 2 si i = 1, et 3 si i = 0.

Les instructions break (que nous avons entrevue au paragraphe précédent) et continue sont surtout utilisées pour les boucles (sauf pour break, qui est aussi utilisée dans switch) : break va comme son nom le suppose arrêter l'exécution de la boucle (ou de l'instruction switch le cas échéant) tandis que continue va elle passer à l'itération suivante en ignorant le code située après continue.

Reprenons notre exemple de boucle infinie : même si c'est déconseillé, une boucle infinie est parfois souhaitable, il faut juste prévoir une condition inévitable afin que la boucle puisse être interrompue.

Dans cet exemple, on ne passait jamais par 10 causant ainsi une boucle infinie. On pourrait bien sûr utiliser la forme suivante :

Mais pour bien montrer l'utilisation de break, nous ne ferons que corriger notre exemple :

Ici, nous avons l'assurance que la boucle ne sera pas infinie : quand i sera supérieur à 9, alors la boucle sera interrompue ainsi que le code qui suit l'instruction break. Par exemple :

Lorsqu'on testera la valeur de i, i vaudra 10 mais pas 100 comme le laisse supposer l'exemple. Si vous voulez que i prenne la valeur de 100 : vous devrez placer l'instruction i = 100; avant le break.

L'utilisation de break est strictement la même avec les boucles for, et do while (ainsi que le bloc switch, bien que dans le bloc switch il y ait largement moins de chances d'obtenir une boucle infinie... et pour cause !)

La seconde instruction, continue, va vous permettre de passer à l'itération suivante en ignorant le code suivant « continue ».

Par exemple : vous voulez construire un script qui fait varier la variable i de 1 à 25. Et tout les 5, vous voulez ajouter '+1' à la variable j.

L'exemple est très simple : si le reste de la division entière de i par 5 ne vaut pas 0, on continue la boucle jusqu'à atteindre une valeur de i telle que i % 5 = 0 (i Modulo 5). Quand on atteint cette valeur de i alors on incrémente j.

Ceci vous montre aussi qu'avec l'instruction continue on « part » directement à l'itération suivante sans se soucier du reste.

L'instruction continue fonctionne aussi avec les boucles while et do ... while.