2. Guide du Scripting avec Wintermute [WME Resource Center]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== 2. Guide du Scripting avec Wintermute======

Nous avons, jusqu'ici, pu s'en passer au cours des quelques tests de WME, nous avons échappé à l’environnement des développeurs et maintenant vous devez certainement être impatient de progresser! Comme vous l'avez probablement deviné, le noyau de toutes les opérations de WME réside dans les scripts. Mais qu'est ce que le script?

Démarrons par le commencement. Tout logiciel est basé sur un noyau “action / réaction”. Ce qui veut dire en quelque sorte que quelque chose se passe et le programme y répond. L'action peut être n'importe quoi allant d'un clique de souris du joueur à, par exemple, le temps qui passe. Bon, revenons à ma question - Qu'est ce qu'un script? **C'est un programme, qui défini les actions à prendre en compte et comment y répondre.**

Typiquement votre jeu WME sera construit de plusieurs Scripts. Disons que vous cliquez avec la souris sur une porte. Vous aurez besoin d'un script qui fera dire à votre personnage "la porte est verrouillée". J’espère que vous comprenez ce que je dit là. Plus nous avancerons dans ce chapitre, plus nous verrons de choses fantastiques de WME, mais nous allons commencé par le début. 

Le cœur de la programmation de WME réside dans les commandes. Les commandes indiquent à WME quelle action effectuer. Nous pouvons avoir un tas de commandes différentes allant de la simple opération mathématique (addition, soustraction, etc...) à la commande plus complexe tel que ça, par exemple

<code script>Game.ChangeScene("une_scene.scene");</code>

qui fait changer la scène actuelle à WME. Mais regardons les rudiments de la création de script(Scripting). Nous allons commencer par quelque chose qui s’appelle **Variable**. Qu'est ce qu'une variable? C'est une boite dans laquelle vous pouvez stocker des informations. Dans WME (contrairement au C++ par exemple) vous pouvez stocker n'importe quel type d'information dans votre variable (chaine, objet, nombre).

Regardons un exemple :

<code script>var myvar = "Hello World";</code>

Le mot-clé var déclare un variable locale appelée myvar laquelle a été remplies avec le texte //Hello World//. Plus tard nous ferrons appelle au texte de la variable par exemple avec:

<code script>Game.Msg(myvar);</code>

Cette ligne affichera Hello World sur l'écran du jeu.

//**Règle de syntaxe no.1**

Comme vous pouvez le voir, toutes les commandes finissent par un point-virgule ;
De plus WME est très sensible au Majuscules/Minuscules! myvar n'est pas la même chose que MyVar. Garder bien ça en tête!//

La règle très importante est que dans chaque script nous déclarons une variable **qu'une seule fois**. Ensuite nous y ferrons référence sans le mot-clé //var//.

Voyons quelques manipulations de base avec les variables:

<code script>
var myvar = "Hello World";
Game.Msg(myvar);

myvar = 1;		// nous stockons le chiffre 1 dans notre variable
myvar = myvar + 1;  // Nous ajoutons 1 au chiffre stocké
Game.Msg(myvar);	// Nous affichons le résultat (chiffre 2)

myvar = myvar * 2; // on multiplie par 2
myvar = myvar / 4; // divise par 4

myvar = "Le résultat est " + myvar + "!";
Game.Msg(myvar); //Affiche Le résultat est 1!
</code>

//**Règle de syntaxe no.2**//

<code script>
Si vous voulez commenter quelque chose, utilisez // pour une ligne simple de commentaire
ou /* */ pour un bloc de commentaires. Les blocs commentées ou commandes ne serons pas exécutés 

Exemple:

var a = 1; // Nous stockons 1 dans la variable a

/*  Ce bloc 
   var a=1;
   a = a +1;
   a = 0;
   ne sera jamais exécuté */
</code>

ASTUCE: Toujours nommer votre variable de façon intelligente ou vous ne retrouverez plus ce qu'il y a de stocké à l’intérieur. Bien sur que c'est marrant de nommer une variable petitNainRouge mais si vous regarder votre code 5 mois plus tard, vous essayerez désespérément de comprendre pourquoi cette variable marrante est là.Une autre pratique courante c'est d'utiliser les minuscules ou les Majuscules c'est la façon de mettre en majuscules les lettres dans votre nom de variable. Par exemple une variable devant contenir le nombre d’ingrédient ajoutés dans la bouilloire peut être appelée par exemple ingredientsBouilloire.

Comme vous avez le remarquer, j'ai parlé de quelque chose appelé **variable locale**. le mot //locale// signifie, que la variable n'est valide que dans le script où elle a été déclarée. Imaginé que vous ayez deux scripts tel que test1.script et test1.script que vont être exécutés à suivre:

**fichier test1.script**

<code script>
var a = 10;
Game.Msg(a); //affiche 10
</code>

**fichier test2.script**

<code script>
var a = a + 1; 
Game.Msg(a); //affiche 1, parce que la variable n'est valide que dans CE script seulement et du coup sa valeur par défaut est 0
</code>

Mais comment faire si on veut partager des valeurs d'un script à un autre? Pour ça nous avons une autre sorte de variable appelée variable globale. Cette variable est déclarée en utilisant le mot-clé **global** et est valide dans tout le jeu!

//**Règle de syntaxe no.3**
Dans chaque script où l'on veut utiliser une variable globale, ne devons déclarer cette variable par le mot-clé global. //

Et maintenant c'est l'heure de faire de arithmétique: 

<code script>
  var a = 1 + 3;  // a = 4
  a = 3 - 3;  // a = 0
  a = 3 * 3; // a = 9 (* multiplier par)
  a = 3 / 3; // a = 1 (/ diviser par)
</code>

Regardons notre exemple précédent à nouveau en supposant que test1.script est exécuté en premier et qu'ensuite c'est test2.script:

**fichier test1.script**
<code script>
  global a = 10;
  Game.Msg(a); //affiche 10
</code>

**fichier test2.script**
<code script>
   global a = a + 1; 
   Game.Msg(a); //affiche 11, parce que la variable est valide pour tout le jeu.
</code>

Pour un exemple dans la réalité, disons que vous ayez un bouton dans une scène et que si vous pressez ce bouton, vous voulez qu'une porte dans une scène complétement différente s'ouvre. Vous déclare tout simplement une variable globale et la mettez sur true si le bouton a été appuyé. Dans la scène, où se trouve la porte, vous testez simplement cette variable globale et si c'est égale à true, vous ouvrez la porte. Simplement pour clarifier le terme "true", il y a 2 valeurs spéciales qui peuvent être mis dans les variables - **true** et **false** (vrai et faux). On en saura plus sur elles quand nous verront les conditions. 

Nous avons découvert avec succès les variables, mais patience - il y a bien plus sur elles. Nous n'en sommes qu'au début.





====== 2.1 Les tableaux magiques ======

Avant de commencer à parler de tableaux, je vais vous donner un exemple d'un réel problème dans les jeu. Imaginez que vous ayez une porte protégée par digicode. vous devez tapez les 4 chiffres correctement pour que la porte s'ouvre. Vous avez différentes façons de faire cela. Commençons par la pire:

//Choix terrible: // Depuis le chapitre suivant vous auriez certainement créer 4 variables différentes (par exemple code1, code2, code3, code4) et mis les chiffres tapés dedans. Puis vous les auriez contrôlé une par une pour voir si elles correspondent. 

//Choix extrêmement compliqué: // Vous avez une variable et utilisant une multiplication et des mathématiques, vous créez un nombre que vous comparerez ensuite avec le nombre résultat.

**Choix intelligent: vous utilisez un tableaux.**

Vous pouvez imaginer in tableau composé de variables. Vous référencez ces variables en les **indexant** dans un tableau de variable. Cet index est un nombre commençant par 0. Je parie qu'un exemple vaudrais mieux qu'un milliers de mots. Nous allons définir une variable myArray et remplir 3 champs du tableau.

<code script>
var myArray;

myArray[0] = "Hello World"; 
myArray[1] = "Je suis votre premier tableau";
myArray[2] = "OUUUAIIS!";
</code>

Et bien sur on peut faire:

<code script>
Game.Msg(myArray[1]);
</code>

ou même

<code script>
var a = 1;
Game.Msg(myArray[a]); 
</code>

ce qui affichera la même chose car la variable a contient le nombre 1.


//**Règle de syntaxe no.4**
Nous disons à WME que nous voulons accéder au tableau en utilisant index de l'élément entre crochets.//

Si on revient a notre exemple réel avec la porte codée, nous pouvons facilement mettre le code entier dans une seule variable.

<code script>
var doorCode;

doorCode[0] = 5; 
doorCode[1] = 2;
doorCode[2] = 3;
doorCode[3] = 7;
</code>

D'accord. Maintenant les codeurs curieux se demande déjà pourquoi on utilise pas quelque chose comme ça:

<code script>
var doorCode = "5";

doorCode = doorCode + "2";
doorCode = doorCode + "3";
doorCode = doorCode + "7"; // le résultat sera 5237 dans une variable.
</code>

Bien, on pourrais, mais alors - comment faire si vous avez un code de porte plus complexe et vous vouliez changer, par exemple, le troisième chiffre lorsque tous les quatre ont été rentrés? Ca rend la chose un peu plus complexe et aussi - nous sommes en train de montrer les tableaux donc utilisons les.

Des que vous aurez l'habitude de les utiliser dans les scripts, vous trouverez plein d'utilités aux tableaux. La principale force des tableaux reside dans l'indexage. Vous pouvez accéder à la valeur de l'indice par programmation et c'est pourquoi nous allons examiner maintenant dans un autre exemple concret.

Vous avez surement vu comment les jeux les mieux conçus utilise différentes réponses pour une action de sorte que ce ne soit pas trop ennuyeux. Regardons comment on peu faire ça et utilisons un tableau pour cela. Nous allons aussi introduire une nouvelle commande appelée **Random** (aléatoire).  

Random est une //fonction// qui retourne un nombre aléatoire dans une plage spécifiée. Nous parlerons des fonctions et comment elles fonctionnent plus tard, pour le moment prenez les comme quelque chose qui fonctionne sans se demander pourquoi.

<code script>
var answerArray;
answerArray[0] = "C'est coincé!";
answerArray[1] = "Je peux pas le bouger!";
answerArray[2] = "Pas de chance. Ça ne bougera pas!";

var reply = Random(0,2); // Nous remplissons la variable reply avec un nombre au hasard entre 0 et 2

Game.Msg(answerArray[reply]); //On peut donc facilement afficher une réponse au hasard de notre série
</code>

Je pense que vous devez être un petit peu fatigué de parler //variable// Nous nous pencherons donc maintenant sur différentes choses pour revenir un peu plus tard à la grande partie appelés **objets**.


























====== 2.2 les Conditions ======

Habituellement nous savons ou nous allons. Nous avons parlé précédemment de l’exemple d'une porte et d'un bouton, nous avons perler de tester si le bouton etait appuyé. Mais comment faire ce test? Nous avons une commande de condition appelé **if** (si) qui le fait pour nous. Encore une fois commençons par du code:

<code script>
var a = 1;

if (a == 1) Game.Msg("A égal à 1"); // Cette ligne peut être lu : Si a est égal à 1 exécute la commande suivante 
</code>

Cet exemple complétement inutilisable vous donne une première impression de ce que sont les conditions. Comme les test sont syntaxiquement plus compliqué nous allons nous focaliser sur la bas du test.

Comme vous pouvez le voir, la condition est entre parenthèses.

//if (Insérer une condition ici) do quelque chose;// ce qui peut être traduit par : si (Insérer une condition ici) fait quelque chose

Le test lui-même peut être fait par la logique suivante:

  -  Si nous voulons tester si quelque-chose est égal à quelque-chose alors on utilise

Si nous voulons tester si quelque-chose est égal à quelque-chose alors on utilise <code script>==</code> Exemple: <code script>if (a == 1)</code>
  - Si nous voulons tester si quelque-chose n'est pas égal à quelque-chose alors on utilise <code script>!=</code> Exemple: <code script>if (a != 1)</code>
  - Si nous voulons tester si quelque-chose est supérieur à quelque-chose alors on utilise <code script>></code> Exemple: <code script>if (a > 1)</code>
  - Si nous voulons tester si quelque-chose est inférieur à quelque-chose alors on utilise <code script><</code> Exemple: <code script>if (a < 1)</code>
  - Si nous voulons tester si quelque-chose est inférieur ou égal à quelque-chose alors on utilise <code script><=</code> Exemple: <code script>if (a <= 1)</code>
  - Si nous voulons tester si quelque-chose est supérieur ou à quelque-chose alors on utilise <code script>>=</code> Exemple: <code script>if (a >= 1)</code>

Pour les variables (sont appelées booléens dans ce cas) qui sont true (vraies) ou false (fausses) on peut utiliser un raccourcit:

<code script>
var a = true;
if (a) Game.Msg("c'est vrai!");
if (!a) Game.Msg("c'est faux!");
</code>

Mais le plaisir ne s’arrête certainement pas là! Nous pouvons faire des tests bien plus complexes mais pour les comprendre, nous allons regarder autre chose.

Retour au début:

Prenons notre "if (a == 1)" et si on donnais préalablement la valeur 1 à notre variable //a//, nous pourrions ainsi lire la condition si 1 est égal à 1. Cet état est **vrai**.

Si on donnais la valeur 2 à la variable //a//, nous pourrions lire la condition si 2 est égal à 1. Cet état est **faux**.

Ceci elle la logique élémentaire de l'informatique en général. Les ordinateurs sont remplis cette logique vrai/faux et nous devons faire avec.

WME lit la condition et fait une évaluation. Si l’état est vrai, il exécute la commande, si l’état est faux, WME ne fait rien et continue. Regardez ceci:

Si nous revenons sur notre cas concret du bouton qui ouvre la porte, on pourrais écrire un script qui gère l’événement quand le bouton à été cliqué comme ceci:

<code script>
global buttonCliked = true;
</code>

et puis dans l'autre script tester la porte comme cela:

<code script>
global buttonCliked;
if (buttonCliked) do quelque-chose qui ouvre la porte;
</code>

Bon maintenant que nous avons vu les bases des conditions, nous pouvons regarder comment tester plus d'une chose en même temps.

  - On utilise l'opérateur **&&** si on veut que les 2 conditions soient vraies. **if (a > 1 && a < 10)** signifie que //a// doit être supérieur à 1 et inférieur à 10
  - On utilise l'opérateur **||** si on veut qu'au moins une des conditions soit vraie. **if (a == "John" || b == 1)** signifie que //a// doit être égal à John ou que la variable //b// doit être égal à 1.

Si on on veut grouper quelques conditions on utilise là encore des parenthèses:

**if ( (a>1 && a<10) || (b =="John") )** est un des tests les plus complexes. Il exécutera la commande suivante si la variable //a// est supérieur à 1 ET inférieur à 10 OU if la variable //b// contient John.

//**Règle de syntaxe no.5**
Si on veut exécuter plusieurs commande dans la condition, vous utilisez des **accolades** pour englober les commandes qui seront exécutées.//

Exemple:
<code script>
if (a == 2) {
  Game.Msg("Hi!");
  Game.Msg("Hi again!");
}</code>//Les 2 commandes seront exécutées si la variable a est égale à 2//

Je pense que vous vous etes deja demandé si vous voulez tester une certaine condition mais vous voulez traiter seulement si l’état est //faux//. Et c'est là que la command **else** (sinon) entre en jeu. 

<code script>
var a = 1;

if (a == 1)
{
	Game.Msg("C'est encore vrai.");
	a = 10;
}
else
	Game.Msg("Tout faux dans le code.");

</code>
Vous pouvez, bien sûr, combiner le else avec plusieurs if jusqu’à l'absurde.

If est évidemment pratique, mais il il y a un exemple ou vous pouvez résoudre la situation d'une bien meilleur manière. Cette manière élégante s’appelle **switch** (aiguiller). 

Ce que **switch** fait c'est d'aiguiller le programme vers différents chemin en fonction d'une variable.

Laisser moi vous montrer un exemple:
<code script>
var a = Random(0,3); //ça, nous connaissons déjà!
var b = "";

switch(a)
{
	case 0:
		Game.Msg("Choix 0");
		b = "Salut";
		break;
	case 1:
		Game.Msg("Choix 1");
		b = "Au revoir";
		break;
	default:
		Game.Msg("Tous les autres choix");
		b = "Que faire?";
}
</code>

D'accord. Là il se passe un paquet de chose. Premièrement nous avons aiguillé le code en fonction de la variable //a//. Celle-ci peut être un nombre compris entre 0 et 3 (a cause de la fonction random). Si a est égal à 0 alors nous rejoignons directement la première branche jusqu’à ce qu'on atteigne la commande **break;** Si cette commande n’était pas là, WME parcourrais toutes les branches jusqu’à ce qu'il en trouve une! Donc si vous voulez terminer la branche utilisez **break:**

Chaque branche est définie par le mot-clé **case** (cas). La syntaxe spécifique de **case** est que vous devrez définir ce que doit être la variable contenu dans switch si vous voulez prendre cette branche. Et apres cette valeur mettre deux points (**:**).

Nous pouvons aussi tester des chaines avec par exemple *case "épée":* 

Et là encore - nous imbriquons le tout dans des accolades. Nous allons voir beaucoup d'accolades plus tard.

BUG: Ne pas utiliser de boucles à l’intérieur des branches case. Elles ne fonctionnent pas. If vous en avez besoin, écrivez une //fonction// (expliqué plus tard) qui contient la boucle. Cette parade fonctionne. 







====== 2.3. Les boucles ======

Il y a plein de fois où on veut utiliser une action répétitive. WME fournit diverses façons de réaliser cela.

Nous allons commencer par la première façon de faire un cycle - avec la commande **for** (pour). Cette commande est utilisable si vous connaissez le nombre exacte de répétitions. Disons que vous vouliez repeter 10 fois le mot //Hell//.

<code script>
for (var a=0; a<10; a = a+1)
{
   Game.Msg("Hell");
}
</code>

Regardons ce qui ce passe là. la commande **for** constituée de 3 parties séparé par des points virgules. première partie c'est d'où l'on part. dans notre cas on démarre avec une variable //a// défini à 0. la seconde partie c'est quand qu'on arrête. C'est un peu délicat - **for** dit d’arrêter quand la seconde partie, qui est une condition, devient faux! Ça veux dire que ça tourne tant que a<10. Dès que a passe à 10, ça s’arrête. La dernière partie c'est comment la variable évolue. On peut utiliser addition, soustraction, multiplication, division, et j'en passe... Donc dans notre cas a chaque passe du cycle, la variable a est incrémentée de 1. Notez aussi, que j'ai utilisé là des accolades même s'il y a qu'une seule commande dedans. Quelque fois c'est plus lisibles, mais ça sera à vous de voir comme vous préférez.

Important: le cycle tourne 10 fois. Nous sommes parti avec 0. Habituez vous à démarrer par 0 c'est une la logique de base. C'est la source de nombreux problèmes de code.

Hmm. Afficher 10 fois Hell n'est PAS très utile pour créer un jeu. N'est pas? Voyons ce qu'on peut faire de plus. Et cette fois on va utiliser des tableaux pour cela.

<code script>
var myArray;
myArray[0] = "Hi!";
myArray[1] = "How’s it goin’!";
myArray[2] = "Bye!";

for (var a=0; a<3; a = a+1)
{
   Game.Msg(myArray[a]);
}
</code>

Comme vous pouvez voir, nous avons facilement affiché tous les élements du tableau à l'écran. J'espere que vous commencez à avoir une bonne impression sur l'utilité. 

Un autre type de boucle qui est appelé boucle **while** (tant que). Cette boucle est utilisée quand on ne sais pas exactement combien de temps ça doit tourner, mais vous savez quand ça devrait s’arrêter.

<code script>
var a = 0;
while (a != 5)
{
  a =  Random(0,5);
  Sleep(1);
}
</code>

Cet exemple probablement inutile encore une fois évalue l'expression dans le while et si c'est vrai, il exécute le bloc. En d'autre terme, tant que a n'est pas egal à 5, mettre un autre nombre aléatoire dedans.

**Important:**
Maintenant vous vous demandez surement qu'est ce que vient faire là cette commande Sleep(1);. Il s'agit d'un problème un peu plus poussé, mais si vous essayez la boucle sans le Sleep, votre jeu va bloquer et parfois l'ordinateur aussi. Pourquoi? Parce que la boucle while voudra tourner et tourner bouffant un tas de ressource du processeur. Et le reste du moteur, fera attention au timing et les autres chose ne seront pas la priorité! Alors l'ensemble WME voudra seulement tourner. Et si vous êtes pas chanceux et que le random n'est pas de votre coté, donnant tout les autres nombre que 5, votre ordinateur aura de sérieux problèmes. La fonction Sleep() qui exige du temps en millisecondes ne fait pas quelque chose de gênant. Une pause d'une milliseconde est difficilement percevable, mais elle permet au processus de reprendre la main sur script! Ainsi votre jeu ne sera jamais bloqué.

Il y a aussi une autre utilité pour les boucles **while** - qu'on appelle //boucle sans fin//.

Ça peut être illustré par cet exemple:
<code script>
while (1)
{
   //faire quelque chose ici;//
   Sleep(1);
}
</code>

ces boucles sont vraiment sympa pour faire quelque chose en processus de fond que vous auriez besoin d’étendre sur l'ensemble du jeu. Par exemple, vous pouvez vérifier si la musique de fond joue et si elle stoppe, vous pouvez jouer une autre chanson de la play-list ou dans le projet de démonstration ce processus gère l'affichage des légendes (score par exemple).




====== 2.4. Les Fonctions ======

Comme nous avons pu le voir dans le cas de Sleep() ou Random(), il y a des chose appelés Fonction. Une fonction est un tres gros gain de temps, parce qu'elle prend en charge plusieurs lignes de code. Imaginez cet exemple : Vous voulez afficher dix fois le mot Hell. Mais vous voulez le faire plus d'une fois dans votre code. Sans les fonctions vous devriez faire ca:

<code script>
for (var a=0; a<10;a=a+1) Game.Msg("Hell");
Game.Msg("1");
for (a=0; a<10;a=a+1) Game.Msg("Hell"); // Notez que j'ai viré le var comme il était déjà déclaré avant.
Game.Msg("2");
for (a=0; a<10;a=a+1) Game.Msg("Hell"); 
Game.Msg("3");
</code>

Fouillis, non? Nous allons nous simplifier la tache en utilisant une **fonction**. Une focntion c'est un morceau de code réutilisable. C'est défini ^par le mot-clé **function**, nommé à votre guise et des parenthèses dans lesquelles vous pouvez éventuellement mettre quelques paramètres. La sortie de la fonction est designé par le mot-clé **return;** Noter que return oblige à quitter immédiatement la fonction, on peut donc l'utiliser avec quelque code de logique à branches. Donc la déclaration de base pourrait être comme ceci : 

<code script>
function Hell()
{
  for (a=0; a<10;a=a+1) 
  Game.Msg("Hell"); 
  return;
}

Hell();
Game.Msg(1);
Hell();
Game.Msg(2);
Hell();
Game.Msg(3);
</code>

Vous voyez, c'est beaucoup plus lisible. Mais c'est qu'un début. Imaginez qu'a chaque passage vous deviez écrire 10 fois un mot différent. C'est là que les fonction commence réellement à donner un coup de pied. Nous allons redéfinir notre fonction en ajoutant deux paramètres et la renommer en writeText par exemple.
 
<code script>
function writeText(what,count) 
{
  for (a=0; a<count;a=a+1) 
  Game.Msg(what); 
  return;
}

writeText("Hell",10);
writeText("on",2);
writeText("Earth",5);
</code>

Dans la fonction les paramètres fonctionnent comme des variables locales qui ne sont valable qu'a l’intérieur de la fonction. Ainsi notre fonction a deux paramètres. Le premier désigne quoi écrire et le second combien de fois il doit être écrit. Notre programme ecrirai 10 fois //Helle//, 2 fois //on// et 5 fois //Earth//. Comme vous pouvez le voir, cette fonction simplifie encore plus notre tâche.

Donc nous savons introduire des données dans la fonction, mais les fonctions peuvent aussi nous retourner des donnée. L'exemple type de ce genre de fonction est Random. Comme nous l'avons vu précédemment, Random attend 2 paramètres et retourne un résultat. Nous pouvons faire pareil au moyen du mot-clé **return**. Écrivons une fonction simple:

<code script>
function estPlusGrand(nombre1, nombre2)
{
     if (nombre1 > nombre2) return true;
     return false;
}

if (estPlusGrand(1,7)) Game.Msg("Le nombre est supérieur");
else
  Game.Msg("Le nombre est inférieur");
</code>

//**Règle de syntaxe no. 6**
Le nom de la fonction ne doit contenir que des caractères alphanumérique et ne doit pas avoir d'espace.//

Tout devrais être plus clair à ce niveau. Si ça ne l'est pas, s'il vous plait revoyez le chapitre précédent avant que vous ne puissiez plus comprendrez ce qui arrive. La seul chose important est que nous sommes passé à la commande **if**, au lieu de notre bonne vieille comparaison directe, une //fonction//,qui retourne true ou false. La commande **if** évalue la fonction (qui dans se cas retourne //false//) et exécute le bloc //else//.


====== 2.5. Les Includes ======

Comme nous venons de voir les fonctions peuvent etre vraiment utiles mais il y a hic. Il n'y a pas de façon de définir une fonction globale. Il existe bien deux solutions - Grâce aux Includes et aux Objects. Parlons des Includes. 

Si vous avez regardé un peu dans les projets démo de WME, vous avez vu, que tous les script commence par la ligne

<code script>#include "scripts\base.inc"</code>

Cette ligne ajoute des le départ le contenu du fichier scripts\base.inc dans ce fichier. A quoi ça sert? Bien, par exemple, si vous ne voulez pas de déclarer vos variables globales à chaque fois que vous en avez besoin dans un nouveau script, il suffit de les mettre dans un fichier .inc et de les inclure. Si vous les mettez dans votre fichier base.inc, vous aurez cette ligne automatiquement incluse à cause du modèle scène. Utile n'est ce pas? Mais c'est pas tout. Vous pouvez aussi mettre vos fonctions couramment utilisées dans certaines fichiers include et les inclurent, si bien que vous n'aurez plus besoin de les copier / coller dans tous les scripts où vous en avez besoin. Notez qu'il n'y a pas de point-virgule à la fin de ligne include!

**Important:**
Ne jamais initialiser vos variables dans les fichiers include. Elles seraient réinitialisée a chaque inclusion de votre script.






====== 2.6. Les Objets ======

Le dernier chapitre est dédié à un parie vraiment cool du langage de programmation de WME - Les Objets.

Nous allons démarrer doucement avec la réflexion suivante. Imaginez que vous ayez un objet du monde réel. disons une table. Évidemment le terme table est plutôt abstrait - elle peut être faite de plastique, bois, métal ou autre, elle peut avoir plusieurs couleurs, elle peut être chère ou pas. Ça serais pas génial d'avoir toutes les informations sur cette table ensembles? 

<code script>
var table;

table.Material = "bois";
table.Color = "noire";
table.Price = 100;

Game.Msg(table.Price);
</code>

Ce que nous avons fait ici est que nous avons défini une variable, mais au lieu d’accéder directement a cette variable, nous avons défini quelques //Attributs// à cette variable. Nous ne pouvons plus utiliser la variable comme une simple boite. Elle est devenue un objet pour nous.

Maintenant vous devez certainement penser "C'est bien beau tout ça, mais comment faire si nous avons 10 tables. Avons-nous besoin de 10 variables et de les déclarer comme ça? Ça sera de nouveau le bazar".

Bon, la magie des Objets n'est pas seulement dans les //attributs//, mais aussi dans les **méthodes**. Une méthode c'est une fonction normale, qui appartient à l'objet. Toutes les fois que vous avez utilisé Game.Msg et seulement maintenant vous découvrez, que c'est une méthode de l'objet Game. Le pire est, que presque tout ce dont vous aurez accès du côté de WME est orienté objet et c'est sûr vous allez rencontrer votre dose d'objets.

Mais revenons à notre tâche en cours - comment pouvons-nous réellement définir un objet pour être plus souple qui as seulement quelques attributs?

Premièrement nous allons créer un fichier de définition d'objet. appelons-le table.script.

<code script>
#include "scripts\base.inc"

method initialize(material, color, price)
{
   this.Material = material;
   this.Color = color;
   this.Price = price;
}
</code>

//**Règle de syntaxe no. 5**
Si nous voulons accéder à un attribut ou une méthode d'un objet, nous utilisons le point comme vu dans l'exemple précédent.//

Comme nous le voyons là, nous sommes à l’intérieur de l'objet donc on ne peut plus utiliser table.Material etc... parce que nous ne savons pas comment la variable englobant notre table sera appelée. C'est pourquoi nous avons un identifiant spécial appelé **this** qui pointe sur l'objet lui-même. De cette façon ça définira toujours l'attribut à la bonne variable.

Dans le script nous voulons créer un tel objet, nous devons d’abord le créer:

<code script>
var table = new Object("table.script"); 
</code>

et puis nous pouvons configurer les propriétés de l'objet ainsi

<code script>
table.initialize("bois","noire",100);
</code>

Cela paraît déjà beaucoup plus souple, mais nous pouvons aller encore un peu plus loin. Disons que nous allons créer un jeu sur un vendeur de table qui aura 10 tables différentes. Pourquoi ne pas utiliser un tableau pour elles?

<code script>
for (var a=0;a<10;a=a+1)
{
   tables[a] = new Object("table.script");
}
</code>

Mais voilà il y a un piège! Vous ne pouvez pas faire quelque chose comme: **tables[a].initialize();** parce WME ne supporte pas la notation de point pour tableaux ou des objets imbriqués. Pas plus que vous ne pouvez pas faire quelque chose comme Game.Scene.SomeAttribute parce WME ne supporte qu'un seul point imbrication. Mais il y a une solution de contournement grâce à la variable temporaire.


Le premier cas serait réécrit comme:
<code script>
var tmp = tables[a];
tmp.initialize("bois","noire",100);
</code>

et l'autre comme:

<code script>
var tmp = Game.Scene;
tmp.SomeAttribute = 1;
</code>

Je pense que cela devrait être suffisant pour vous permettre de commencer avec les scripts. Le reste est juste une application de ce que vous venez d'apprendre. Je suis sûr que vous n'aurez aucune difficulté à comprendre ce qui se passe maintenant.