Differences

This shows you the differences between the selected revision and the current
version of the page.

--- fr:wmebook:ch2 2011/10/17 16:25
+++ fr:wmebook:ch2 2011/10/19 13:12 current
@@ Line 118: / Line 118: @@
-====== 2.1 Les tableaux magiques ======
+====== 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:
@@ Line 224: / Line 225: @@
-====== 2.2 les Conditions ======
+====== 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:
@@ Line 353: / Line 356: @@
 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 ======
-There are many times when we want to use repeating actions. WME provides a couple of ways how can we accomplish that.
+Il y a plein de fois où on veut utiliser une action répétitive. WME fournit diverses façons de réaliser cela.
-We’ll start with the first way how to cycle – with the command **for**. This command is usable if we know the exact number of repetitions. Let’s say that we want to 10 times print the word //Hell//.
+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>
@@ Line 367: / Line 376: @@
 </code>
-Let’s see what’s going on in here. The **for** command consists of 3 parts separated by semicolons. First part is where to start. In our case we start with a variable //a// set to 0. The second part is when to end. This is a bit tricky – **for** command ends when the second part, which is a condition, turns false! This means that it will loop until a<10. As soon as a turns 10, it will end. The last part is how to change the variable. We can use addition, substraction, multiplication, division, you name it... So in our case with each pass of the cycle, the variable a is increased by 1. Also note, that I’ve used curly brackets here even if it’s only one command in. Sometimes it’s more readable, but I’ll leave it to your preference.
+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: The cycle runs 10 times. We’re starting with 0. Get used to 0 based start logic. It’s the source of many coding problems.
+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. Printing ten times Hell isn’t THAT useful for game creating. Is it? Let’s see what more we can do. And this time we’re going to use Arrays for that.
+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>
@@ Line 385: / Line 394: @@
 </code>
-As you can see, we’ve easily printed all array elements on the screen. I hope you’re starting to get the right impression of the usage.
+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é.
-Another type of loop is so called **while** loop. This loop is used when we don’t know exactly how many times it should loop, but we know when it should stop.
+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>
@@ Line 398: / Line 407: @@
 </code>
-This probably useless example again evaluates the expression in while and if it’s true, it executes the block. So in other words, while a is not equal to 5, set another random number to it.
+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:**
-Now you’re probably wondering what is going on with that Sleep(1); command. This is a bit more advanced issue, but if you tried the loop without the Sleep, your game would freeze and sometimes even your computer too. Why? Because the while loop would loop and loop and loop eating a lot of processor power. And the rest of the engine, which takes care of the timer and other things would never get the priority! So the whole WME would just loop. And if you’re unlucky and Random won’t be on your side returning all other numbers than 5, your computer will have serious problems. Function Sleep() which takes time in milliseconds doesn’t do anything  obvious. Waiting one millisecond can hardly be noticed, but it returns control from this script to other processes! So your game will never get stuck
+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.