Differences

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

--- fr:wmebook:ch3 2011/10/18 14:22
+++ fr:wmebook:ch3 2011/10/25 13:49 current
@@ Line 1: / Line 1: @@
-====== 3. Premier tour dans les entrailles de WME ======
+====== 3. Premier pas dans les entrailles de WME ======
 Nous avons découvert les outils et nous avons appris les bases du script, il maintenant temps de voir comment ces connaissances s'applique à la conception d'un jeu. Avant de commencer ce tour nous allons d'abord faire un bref survol des types de fichiers que vous allez utiliser dans WME (et je recommande fortement d'utiliser cette convention de nomination):
 ***.script** – sont les fichiers qui contiennent le programme proprement dit.
-***.inc** – sont les fichiers Include qui peuvent etre intégré dans les fichiers de script. Leur but est de vous faire économiser des centaines de lignes de code, qui serait autrement répéter dans plusieurs fichiers. Le parfait exemple de ceci est le fichier data\scripts\base.inc. Vous intégrerez ce fichier dans presque tous les scripts.
+***.inc** – sont les fichiers Include qui peuvent être intégré dans les fichiers de script. Leur but est de vous faire économiser des centaines de lignes de code, qui serait autrement répéter dans plusieurs fichiers. Le parfait exemple de ceci est le fichier data\scripts\base.inc. Vous intégrerez ce fichier dans presque tous les scripts.
 ***.scene** – est le fichier qui contient la définition de la scène tel que défini dans l'éditeur de scène. Bien que vous puissiez définir ce fichier à la main, c'est beaucoup plus confortable d'utiliser sceneEdit pour faire le sale boulot.
 ***.sprite** – produit de l'éditeur de sprite
@@ Line 11: / Line 11: @@
 ***.font** – est le fichier de définition de police. C'est une interface entre la police effective et celle de WME. Actuellement, il existe deux types de polices pris en charge - de type bitmap et true-type.
 ***.window** – est un fichier de définition des éléments de fenêtre GUI.
-***.image** – s'agit d'un conteneur spécial pour stocker une image (avec la possibilité de tiling, etc.) Ceci est utile pour les éléments de l'interface graphique.
+***.image** – s'agit d'un fichier spécial pour stocker une image (avec la possibilité de tiling, etc.) Ceci est utile pour les éléments de l'interface graphique.
-***.button** – est un conteneur pour les définitions bouton.
+***.button** – est un fichier contenant la définitions des boutons.
-**EN COURS DE TRADUCTION**
-Also WME has preset a couple of special files which you can also change, but those are defaults:
-**default.game** and **startup.settings** are files created by Project Manager and stored in the first (main) game package.
+De plus WME a quelques fichiers spéciaux prédéfinis que vous pouvez également changer, mais ceux-ci sont par défaut:
-**string.tab** located at the same place contains the localization table for the texts.
-**items.items** contains the definition of inventory items used in the game (data\items)
-**responses.def** is the file which defines how the dialogue window would look like.
-**inventory.def** is the file which defines how the inventory box looks like (data\interface)
-But enough of that and let’s start with the most simple thing – the scene tweaking. If we explore the contents of any of created scenes in the explorer, we’ll see that there is always a scene file and a folder **scr** which contains the file **scene_init.script**
+**default.game** et **startup.settings** sont des fichiers créés par le Gestionnaire de projet et stockés dans le Package (principal) du jeu.
+**string.tab** situé au même endroit contient la table de localisation pour les textes. **(TRADUCTION A REVOIR)**
+**items.items** contient la définition des objets de l'inventaire utilisé dans le jeu (data\items)
+**responses.def** est le fichier qui définit la manière dont la fenêtre de dialogue devrait ressembler.
+**inventory.def** est le fichier qui définit à quoi ressemble la boite de l'inventaire (data\interface)
-Wme reads the scene file for the current scene, prepares all //nodes// as defined in the scene file, attach all scripts which are present in the scene file and run the file called **scene_init.script**. This is the file which we’ll examine now and I’ll add my comments to it:
+Mais assez parlé de cela et nous allons commencer avec la chose la plus simple - les ajustements de scène. Si nous explorons le contenu de l'une des scènes créées dans l'explorateur, nous allons voir qu'il y a toujours un fichier de scène et un dossier **scr** qui contient le fichier **scene_init.script**
+WME lit le fichier de scène de la scène courante, prépare tous les //nœuds// tel que défini dans le fichier de scène, joint tous les scripts qui sont présents dans le fichier de scène et exécute le fichier appelé **scene_init.script**. C'est le fichier que nous allons examiner maintenant et je vais y ajouter mes commentaires:
 <code script>
 #include "scripts\base.inc"
-// here comes the stuff which initializes the scene
+// voici les trucs qui initialise la scène
-actor.SkipTo(733, 562); 		// We position actor to a certain position
+actor.SkipTo(733, 562); 		// On positionne l'acteur a une certaine position
-actor.Direction = DI_DOWN;	// we set the direction she faces
+actor.Direction = DI_DOWN;	// On définit la direction vers laquelle il fait face
-actor.Active = true;			// we make it visible for the scene
+actor.Active = true;			// On fait qu'il soit visible pour cette scène
-////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// scene state
+// état de la scène
-global Statewarehouse; 	// We create a global variable which has the same name as
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// the scene prepended by State
+global Statewarehouse; 	// On créé une variable globale qui a le même nom que la scène précédé du mot State
-// default values
+// Valeurs par defauts
-if(Statewarehouse==null)  	//We run the game for the very first time so the value was
+if(Statewarehouse==null)  	//Nous lançons le jeu pour la première fois donc la valeur n'a pas été encore initialisée
-{				// not  initialized yet
+{
-  Statewarehouse.Visited = false;  //We’ve never been in the scene yet
+  Statewarehouse.Visited = false;  //Nous n'avons jamais été dans la scène encore
 }
 ////////////////////////////////////////////////////////////////////////////////
-// setup scene according to state variables
+// scène de configuration en fonction des variables d'état
 ////////////////////////////////////////////////////////////////////////////////
-if(!Statewarehouse.Visited) //If we’ve never been in the scene
+if(!Statewarehouse.Visited) //Si nous n'avons jamais été dans la scène
 {
-  Statewarehouse.Visited = true; //Set that we’ve been there
+  Statewarehouse.Visited = true; //Définir que nous sommes venu ici.
-  // this is our first visit in this scene...
+  // ceci est notre première visite dans cette scène ...
 }
 </code>
-Now this may look to you as an overkill script for something as similar as checking if we were in some scene or not but trust me, there’s more to it than meets the eye. This is actually very clever script which counts with many different possibilities. It counts with the game which was newly started, it counts with a scene revisiting, it counts with the fact that you can have on enter special events. Remember those cinematic moments when you played an adventure, walked in some room only to see the bridge collapsing? You wouldn’t want to see it collapse every time you visit that scene. Once is enough for sure.
+Maintenant cela peut vous paraitre débile comme script qui ne fait rien d'autre que de vérifier si nous somme aller dans une scène ou pas, mais croyez-moi, il y a plus qu'il n'y parait. Ceci est un script vraiment très astucieux qui compte avec beaucoup de possibilités différentes. il compte pour le jeu qui a été récemment lancé, il compte pour une scène revisitée, il compte du fait que vous pouvez avoir un événement spécial à l'entré de la scène. Rappelez-vous ces moments cinématographiques quand vous avez joué à une aventure, marchant dans une scène seulement pour voir le pont s'effondrer? Vous ne voudriez pas le voir s'effondrer à chaque fois que vous visitez cette scène? C'est sûr une fois suffit.
-So now when we uncovered what’s going on in this script, it’s actually very simple. As there are thousands of different methods, I’ve decided to choose the non violent way how to present them when needed, although Max was very unhappy with me last time, I've consulted nonviolent approaches.
+Alors maintenant, que nous avons découvert ce qui se passe dans ce script, c'est vraiment très simple. Comme il y a des milliers de méthodes différentes, j'ai décidé de choisir la manière douce façon de les présenter si besoin, même si Max étaient très malheureux avec moi la dernière fois, j'ai consulté des approches non-violentes.
-Let’s look at one example from the beginning of the script.
+Regardons un exemple du début du script.
 <code script>
@@ Line 66: / Line 65: @@
 </code>
-We know that objects have their **methods** which are identified by .name(); notation. So plain and simple we’re calling method SkipTo() of our actor object. “actor” is a global variable which contains an actor object and is declared in different script. Now someone stands up and shouts at me: “You liar, you told us, that every global variable must be declared explicitly in the script by a keyword global.” Ha, I would reply, but it’s of course true. It’s there, but neatly hidden in the included file base.inc See the power of includes? You don’t have to declare an actor, whom you would use for almost every script. You simply put it in the include file and that’s it. Template does the rest.
+Nous savons que les objets ont leurs **méthodes** qui sont identifiable par leurs notation .name();. Alors purement et simplement nous appelons la méthode skipTo () de notre objet acteur. "actor" est une variable globale qui contient un objet acteur et est déclarée dans différent script. Maintenant, quelqu'un se lève et hurle: «Vous êtes un menteur, vous nous avez dit, que chaque variable globale doit être déclarée explicitement dans le script par un mot-clé global." Ha, je répondrais, que vous avez raison.Mais elle est là, mais sagement caché dans le fichier include base.inc. Vous constatez la puissance des includes? Vous n'avez pas à déclarer un acteur, que vous utiliserez pour presque chaque script. Il vous suffit de le mettre dans le fichier include et c'est tout. Le modèle fait le reste.
-So let’s get back to our actor object and look at the very first methods we saw + add two more very useful methods:
+Donc revenons à notre objet acteur et regardons les méthodes que nous avons vu en tout premier et ajouter deux autres méthodes très utiles:
-//**Actor object methods and attributes**//
+//**les méthodes et attributs de l'objet acteur**//
-**actor.SkipTo(x,y);**  - places an actor to a specified screen position. Always double check, that this position is inside of a region.
+**actor.SkipTo(x,y);**  - place un acteur à une position de l'écran donnée. Toujours ré-vérifier, que cette position est à l'intérieur d'une région.
-**actor.Direction = ?;** - is an attribute which sets the direction actor is looking. We have 8 constants (DI_UP, DI_DOWN, DI_LEFT, DI_RIGHT, DI_UPRIGHT, DI_UPLEFT,  DI_DOWNRIGHT, DI_DOWNLEFT)
+**actor.Direction = ?;** - est un attribut qui définit la direction dans laquelle l'acteur attend. Nous avons 8 constantes (DI_UP, DI_DOWN, DI_LEFT, DI_RIGHT, DI_UPRIGHT, DI_UPLEFT,  DI_DOWNRIGHT, DI_DOWNLEFT)
-**actor.Active = true / false;** - is an attribute common to all nodes and actors which makes them active or inactive (visible or invisible).
+**actor.Active = true / false;** - est un attribut commun à tous les noeuds et acteurs qui le rend actif ou inactif (Visible ou invisible).
-**actor.GoTo(x,y);** - instead of direct placing of the actor, actor walks to specified coordinates
+**actor.GoTo(x,y);** - au lieu de placer directement l'acteur, l'acteur se dirige vers coordonnées spécifiées.
-**actor.Talk(string);** - actor says a text line.
+**actor.Talk(string);** - L'acteur dit une ligne de texte.
-So I bet you’re eager to try the new methods in action. Let’s work on our **scene_init.script** then! Open the scene_init.script file located in //data->scenes->warehouse->scr// folder. Note that from now on, when I’ll refer to the scene_init.script you’ll find it easily without my assistance. Locate the line **actor.Active = true;** and add some more lines behind this one so you’ll get the following result:
+Donc je parie que vous êtes impatient d'essayer les nouvelles méthodes en action. Travaillons sur notre **scene_init.script** alors! Ouvrez le fichier scene_init.script situé dans le dossier //data->scenes->warehouse->scr//. Notez qu'à partir de maintenant, lorsque je ferai référence à scene_init.script vous le trouverez facilement, sans mon aide. Localisez la ligne **actor.Active = true;** et ajoutez quelques lignes de plus derrière celle-ci de sorte vous obteniez le résultat suivant:
 <code script>
@@ Line 83: / Line 82: @@
 actor.GoTo(365,561);
 actor.Direction = DI_DOWN;
-actor.Talk("What a beautiful warehouse!");
+actor.Talk("Quel magnifique entrepôt!");
 </code>
-Save your script and run the game from the Project Manager. Before we go on, let’s speak about one of the most important aspects of the game programming in WME. **WME produces a file called wme.log which is placed in the project root directory.** This is a critical file where all problems / script errors etc. are stored. So if you for example make a typo in the script, the game just simply states Script compiler error, but this file tells you what file and on which line contains this error. So learn to open it often or your work will be very slow.
+Enregistrez votre script et lancez le jeu depuis le gestionnaire de projet. Avant que nous continuions, nous allons parler de l'un des plus importants aspects de la programmation du jeu dans WME.**WME génère un fichier appelé wme.log qui est placé dans le répertoire racine du projet.** C'est un fichier erreurs où tous les problèmes, erreurs de script, etc... sont stockées.Donc, si par exemple vous faite une faute de frappe dans le script, le jeu va tout simplement alerter de l'erreur au compilateur de scripts, mais ce fichier vous indique quel fichier et quelle ligne contient cette erreur. Apprenez donc à l'ouvrir souvent ou votre travail sera très lent.
-Oh-key. Let’s move on and try some interaction with the Scene. Open the warehouse scene in the scene edit again and select the door region entity we’ve created earlier. Click on the **scripts** button. And here click on **“New script”** button.
+Oh-key. Bougeons et essayons quelques interactions avec la scène. Ouvrez la scène d'entrepôt (warehouse) dans l'éditeur de scène à nouveau et sélectionnez l'entité région de la porte, que nous avons créé plus tôt.
+Cliquez sur le bouton **scripts**. Et puis sur le bouton **“New script”** (Nouveau script).
 {{wmebook:c5_1.jpg|}}
-In the next dialogue select template “empty.script” on the left side and press ok.
+Dans la boite de dialogue suivante, sélectionnez modèle "empty.script" sur le côté gauche et appuyez sur OK.
 {{wmebook:c5_2.jpg|}}
-This operation will create an empty file called **door.script** and place it in the scr folder. It also attaches the file to the entity so from now on you’re able to catch interaction with our door. Press OK again and **save your scene**. Now open the newly created file which contains the following:
+Cette opération va créer un fichier vide appelé **door.script** et le placer dans le dossier scr.
+Elle attache également le fichier à l'entité à partir de maintenant vous êtes capable de récupérer une interaction avec notre porte. Appuyez sur OK à nouveau et **enregistrer votre scène**. Maintenant, ouvrez le fichier nouvellement créé, qui contient les éléments suivants:
 <code script>
@@ Line 109: / Line 111: @@
 </code>
-As you can see it’s not very useful. It has include of our old friend **base.inc** but apart from that it doesn’t do anything. We need to expand it a bit. I was briefly explaining **events** in the script chapter and now it’s time to use them. Change the script so it will read:
+Comme vous pouvez le voir ce n'est pas très utile. Il a intégré notre bon vieil ami **base.inc** mais à part ça il fait rien du tout. Nous devons le développer un peu.J'ai brièvement expliqué **les évènements** dans le chapitre script et maintenant il est temps de les utiliser. Changer le script pour lire:
 <code script>
@@ Line 115: / Line 117: @@
 on "LeftClick"
 {
-	actor.Talk("I've clicked on the door");
+	actor.Talk("J'ai cliqué sur la porte");
 }
 </code>
-Save the script, run the game and click left mouse button on the door. Voila! We’ve defined our first interaction with the game world. We’ll expand more on that but before I’ll offer you a set of most useful events which are available from the WME side.
+Sauvegardez le script, lancez le jeu et cliquez sur la porte avec le bouton gauche de la souris. Voila! Nous venons de définir notre première interaction avec le monde du jeu. Nous allons développer plus à ce sujet mais avant je vais vous offrir une liste de la plupart des événements utiles qui sont disponibles dans WME.
-**on "LeftClick"** – Left mouse button was clicked over the node.
+**on "LeftClick"** – Bouton gauche de la souris a été cliqué sur le nœud (entité).
-**on "RightClick"** – Right mouse button was clicked over the node.
+**on "RightClick"** – Bouton droit de la souris a été cliqué sur le nœud (entité).
-**on "MiddleClick"** – Middle mouse button was clicked over the node.
+**on "MiddleClick"** – Bouton milieu de la souris a été cliqué sur le nœud (entité).
-**on "LeftDoubleClick"** – Left mouse button was double-clicked over the node.
+**on "LeftDoubleClick"** – Bouton gauche de la souris a été double-cliqué sur le nœud (entité).
-**on "RightDoubleClick"** – Right mouse button was double-clicked over the node.
+**on "RightDoubleClick"** – Bouton droit de la souris a été double-cliqué sur le nœud (entité).
-There are more events to use, but for the start we’ll be ok with these.
+Il y a bien plus d'événements à utiliser, mais pour le début ça devrait aller avec ces derniers.
-The scripts attached to the node have another interesting feature, they are parts of the object so you can access their properties by the identifier **this**. Let’s experiment with this concept a bit. Change the actor.Talk to read:
+Les scripts attachés au nœud ont une autre caractéristique intéressante, Ils sont des partie de l'objet vous pouvez donc accéder à leurs paramètres par l'identifiant **this**.
+Faisons l'expérience un peu avec ce concept. Changer le actor.Talk pour avoir:
 <code script>
@@ Line 134: / Line 138: @@
 </code>
-If you save the script and run the game, upon clicking on the door actor says “Door”. Does it ring a bell? But of course, it’s a **Name** we’ve set in the scene edit. As you can see, what we set in the Scene Editor is easily accessible from the script which brings us to yet another actor method:
+Si vous sauvegardez et lancez le jeu, lorsque vous allez cliquer sur la porte l'acteur dira "Door". Ça vous dit quelque chose? Mais bien sûr, c'est le **nom** nous avons mis dans l’éditeur de scène.Comme vous pouvez le voir, ce que nous avons établi dans l'éditeur de scène est facilement accessible à partir du script ce qui nous amène à une autre méthode pour l'acteur:
-**actor.GoToObject(Node);** - Goes to coordinates specified in the Scene Editor under “Walk to” and then turns to the direction specified in the same place.
+**actor.GoToObject(Node);** - Va aux coordonnées spécifiées dans l'éditeur de scène dans "Walk to" et se tourne alors vers la direction indiquée au même endroit.
-But we also know that the entity is represented by a keyword this. Can’t it be simpler than that? Try to rewrite your event handler to:
+Mais nous savons aussi que l'entité est représentée par le mot-clé this. Ca peut pas être plus simple que ça? Essayez de réécrire votre gestionnaire d'événement pour avoir:
 <code script>
@@ Line 148: / Line 152: @@
 </code>
-Provided you’ve set correctly the coordinates in the scene editor, actor should go to the door and says the word “Door”.
+Normalement si vous avez réglé correctement les coordonnées dans l'éditeur de scène, l'acteur doit aller à la porte et dire le mot "Door".
-Last experiment with our infamous door for now is setting their **Active** property to false and thus disabling the door hotspot after we click it.
+Dernière expérience avec notre fameuse porte le moment est de régler son paramètre **Active** sur False et donc de désactiver le hot-spot de la porte après l'avoir cliqué.
 <code script>
@@ Line 161: / Line 165: @@
 </code>
-We’ve scratched surface of two objects so far. Actor object and Region Entity object, which we referenced by keyword **this** and hid it through setting its attribute **Active** to false.
+Nous avons égratigné en surface deux objets jusqu'ici. L'objet acteur et l'objet élément Région, que nous avons référencé par mot-clé **this** et caché en réglant son attribut **Active** sur false.
-Let me return back to the image we’ve seen at the beginning and look at this very image from a developers point of view.
+Laissez-moi revenir sur l'image que nous avons vu au début et regarder cette même image d'un point de vue des développeurs.
 {{wmebook:ch1diag.jpg|}}
-Now it won’t probably surprise you that the main game object is called **Game**. You can also see that everything in this diagram is derived from the Game object. If we look at our door entity from this point of view to see where it’s hidden, we’d go this way:
+Maintenant, ça ne vous surprendra probablement pas que l'objet principal du jeu soit appelé **Game**(jeu). Vous pouvez aussi voir que tout dans ce schéma est dérivé de l'objet du jeu. Si nous regardons notre entité door (porte) de ce point de vue pour voir où elle est cachée, nous devrions aller par ce chemin:
 Game -> Scene -> Door.
-We know, that we can reference Scene as Scene, but don’t let this fool you.((Remember that nested notation problem?)) The scene is in demo actually defined in the **game.script** which is the master brain of the game as follows:
+Nous savons que nous pouvons référencer un Scène comme Scène, mais ne vous laissez pas tromper.((Rappelez-vous ce problème de notation imbriqué?))La scène est, dans la démo, en réalité définie dans le **game.script** qui est le cerveau maitre du jeu comme cela:
 <code script>Scene = Game.Scene;</code>
-In the base.inc our Scene is defined as **global Scene;** and because we include **base.inc** into all our files, we can readily reference Scene object from everywhere.
+Dans base.inc notre scène est définie comme la **global Scene;** et parce que nous incluons **base.inc** dans tous nos fichiers, nous pouvons facilement faire référence un objet Scène de partout.
-As we can guess, Game object would serve for the global purposes of the game while Scene object would be useful for per Scene operations. Let me introduce you to the most used functions which represent very well each object.
+Comme on peut le deviner, l'objet jeu servirait pour des besoins globale du jeu tandis que l'objet Scene serait utile pour les opérations par scène. Laissez-moi vous présenter les fonctions les plus utilisées qui représentent très bien chaque objet.
-**Game.ChangeScene(filename);** is a function which changes the scene. It takes as an argument path to the .scene file
+**Game.ChangeScene(filename);** est une fonction qui change la scène. Il prend comme arguments un chemin vers le fichier. Scène
-**Scene.GetNode(NodeName);** is a function which returns the object named NodeName from the scene.
+**Scene.GetNode(NodeName);** est une fonction qui retourne l'objet nommé NodeName de la scène.
-We’ll do something, which would demonstrate the power of WME now. Return to your warehouse scene in scene edit and let’s tweak it a bit. First we should create a new region and call it Exit. Position it to the left bottom corner as on the following image (you should immediately discover by now that it’s the red shape). Also note the position in the scene tree. If you put it above the floor, the mechanism presented wouldn’t work because the floor region would cover the Exit region and this way the Exit region would never get his voice. Last thing which remains to do is to attach a script to this region. Use an empty template and save the scene.
+Nous allons voir maintenant, quelque-chose qui va démontrer la puissance de WME. Retournez à votre scène de l’entrepôt (warehouse) dans l’éditeur de scène et apportons-y quelques modifications. Premièrement nous devrions créer une nouvelle région et l’appeler Exit. La positionner dans le coin inférieur gauche comme sur l'image suivante (vous devriez immédiatement découvrir à présent que c'est la forme rouge). Notez aussi la position dans l'arborescence de la scène. Si vous la placé au dessus le sol (floor), le mécanisme présenté ne fonctionnera pas parce que la région floor recouvrirai la région Exit et de cette façon la région Exit ne serais jamais vue. La dernière chose qui reste à faire est d'attacher un script à cette région. Utilisez un modèle vierge et enregistrer la scène.
 {{wmebook:c5_3.jpg|}}
-Before we go on, let’s discuss two more events (we already know Mouse related events).
+Avant de poursuivre, nous allons discuter de deux autres événements(Nous connaissons déjà les événements en lien avec la souris).
-**on "ActorEntry"** occurs when actor enters the current region. This is the basic logic behind so called trap regions. Trap regions mean that actor triggers an event upon entering certain portion of the screen.
+**on "ActorEntry"** survient lorsque l'acteur entre dans la région courante. Ceci est la logique de base derrière ce qu'on appelle les régions pièges. Région piège signifie que l'acteur déclenche un événement en entrant dans certaine zone de l'écran.
+**on "ActorLeave"** survient lorsque l'acteur quitte la région courante.
-**on "ActorLeave"** occurs when actor leaves the current region.
+La dernière chose qui nous aurions besoin pour cet exemple est de prendre au joueur le contrôle du jeu.Ceci est la partie vitale d'une conception de jeu réussie. Nous voulons déclencher une scène et en plein milieu le joueur clique ailleurs, le personnage n'a pas fini toute la séquence et vous êtes coincé dans une boucle interminable.C'est le genre de cauchemar qu'ont rencontrés de nombreux créateurs nous allons donc l'éviter tant que c'est encore possible.
-Last thing we’d need for this example is taking the game out of player’s control. This is the vital part of successful game design. We want to trigger a scene and in the middle player clicks somewhere else, character didn’t finish the whole sequence and you’re stuck in an unsolvable loop. This kind of nightmare met many designers so let’s avoid it while we still can.
+**Game.Interactive = true / false;** Prend le contrôle du jeu au joueur ou lui rend. Toujours se rappeler de remettre le jeu en mode interactif ou votre jeu va bloquer et les joueurs vont se fâcher. Il faut donc toujours penser au mode non-interactif comme un bloc.(avec un début et une fin)
-**Game.Interactive = true / false;** Takes the game out of players control or returns it back. Always remember to return the game back to Interactive mode or your game will be stuck and players will get angry. So always think of the noninteractive mode as of a block.
+Nous allons essayer de combiner ces idées dans notre premier jeu à logique complexe.
-We’ll try to combine those ideas into our first more complex game logic.
+D'abord nous allons modifier le **door.script** pour qu'il ressemble à ça:
-First we’ll adapt the **door.script** to look like this:
 <code script>
 on "LeftClick"
 {
-	Game.Interactive = false;    // We want our player to make more things at once and we don't want to be interrupted.
+	Game.Interactive = false;    // Nous voulons que notre joueur fasse plusieurs choses à la fois et nous ne voulons pas être interrompu.
 	actor.GoToObject(this);
-	this.Active = false;  // We disable the door so the hotspot is not visible or active anymore.
+	this.Active = false;  // Nous désactivons la porte afin que le hot-spot ne soit plus visible ou active du tout.
-	actor.Talk("Oh no. The door is welded shut.");
+	actor.Talk("Oh non. La porte est soudé.");
-	Game.Interactive = true; // Allow player to play some more.
+	Game.Interactive = true; // Permet au joueur de jouer de nouveau.
 }
 </code>
-Then we open the **exit.script** and add a new event there. The file should look like this:
+Ensuite nous ouvrons le  **exit.script** et ajoutons un nouvel événement dedans. Le fichier devrait ressembler à ça:
 <code script>
 #include "scripts\base.inc"
-on "ActorEntry"  //Actor entered the Exit region
+on "ActorEntry"  //L'acteur entre dans la région Exit
 {
 	Game.Interactive  = false;
-	var door = Scene.GetNode("Door"); //We get the object corresponding to the scene name door into a variable named door
+	var door = Scene.GetNode("Door"); // Nous mettons dans la variable nommé door un objet correspondant au nom de porte de la scène
-	if (door.Active) // If door was not clicked, it was not disabled, so this path will be used
+	if (door.Active) // Si la porte n'a pas été cliqué, elle n'a pas été désactivé, ce voie sera utilisé
 	{
-		actor.Talk("I don't want to return to my flat before I am sure I can't enter the warehouse!");
+		actor.Talk("Je ne veux pas retourner à mon appart avant d’être sûr que je ne peux pas entrer dans l'entrepôt!");
 	}
-	else //we know that the door is welded shut so we can leave the scene
+	else //nous savons que la porte est soudée donc nous pouvons quitter la scène
 	{
-		actor.Talk("Oh well, there really is no way how could I enter that damn warehouse");
+		actor.Talk("Eh bien, il n'y a vraiment aucun moyen d'entrer dans ce foutu entrepôt");
 		Game.ChangeScene("scenes\room\room.scene");
 	}
@@ Line 233: / Line 236: @@
 </code>
-Okay. Time to explain what’s going on in here. Our thought process as a game designer was that player needs to enter the warehouse but the warehouse is welded shut. We for some reason need our player to discover the fact that the door is welded shut so the game could proceed. So we decided to allow him to change the scene only after he discovered that the warehouse was welded shut.
+Okay. Il est temps de vous expliquer ce qui se passe là. Notre processus de réflexion comme un concepteur de jeu que le joueur est besoin d'entrer dans l’entrepôt mais la porte est soudée. Pour une raison quelconque, nous avons besoin que notre joueur découvre le fait que la porte est soudée de sorte que le jeu puisse continuer. Nous décidons donc de l'autoriser à changer de scène seulement après qu'il n'ai découvert que la porte de l’entrepôt est soudée.
-Code-wise we have the region which would be normally used as an exit region, but we’ve added the condition that until the door region was active (which means that player didn’t click on it because if he did, the door region turns inactive), player can’t leave the screen.
+Explication du code, nous avons la région qui devrait normalement être utilisé comme une région de sortie, mais nous avons ajouté la condition que tant que la région de la porte (door) était active (Ce qui veut dire que le joueur n'as pas cliqué dessus, parce que s'il l'avait fait la région de la porte serais passée inactive), le joueur ne peut pas quitter l'écran.
-Save all scripts and run the game. Test the game thoroughly so you’re sure that you really understand the coding behind this logic. It’s one of the critical aspects of adventure game designing and if you get this right, you’ll be in no time creating your own adventures.
+Sauvegarder tous les scripts et lancer le jeu. Testez le jeu à fond de sorte que vous soyez sûr que vous comprenez vraiment le codage derrière cette logique. C'est l'un des aspects essentiels de la conception de jeu d'aventure et si vous y arrivé bien, vous saurez en un rien de temps créer vos propres aventures.
 **Important:**
-Critical thing to know is how path in wme works in general. We’ve seen in **Game.ChangeScene("scenes\room\room.scene");** that we didn’t start with the data path. That’s totally correct! Write it thousand times – I’ll never include the root package name in the referenced path. Why? Because this would work only in debug mode, and when you compile your game in the packages and send it around, it won’t work. The same applies to all files (images, sounds etc.). Never reference files outside of packages. They’ll work in debug mode, but they won’t get compiled and you’ll be in it for the worst nightmares. Think of package as of a virtual root directory and all references should be starting from that point. More about that in the chapter about packages.
+Chose essentielle à savoir c'est comment fonctionne les chemins dans WME en général. Nous avons vu dans **Game.ChangeScene("scenes\room\room.scene");** que nous n'avons pas commencé par le chemin des données. C'est tout à fait correcte! Écrivez-ça mille fois – Je n'inclurais jamais le nom du Package racine dans le chemin référencé. Pourquoi? Parce que cela fonctionnerait uniquement en mode debug, et lorsque vous compilez votre jeu dans les packages et le distribuez, ça ne marchera pas. La même chose s'applique à tous les fichiers (images, sons, etc.) Jamais référencer les fichiers en dehors des packages. Ils fonctionnerons en mode débogage, mais ne serons pas compilé et vous serez dans le pire des cauchemars. Pensez au Packages comme des répertoires racines virtuels et que tout référencement devrait partir de ce point. On en saura plus à ce sujet dans le chapitre sur les Packages.
-Let’s move on to the last part of this chapter, which will cover the daemon issue. We’ll start right off with our first daemon. Before we explain how it works, we’ll have to take a look at a few new methods:
+Passons à la dernière partie de ce chapitre, qui couvrira les problèmes de Daemon (programme fonctionnant en tache de fond). Nous allons commencer tout de suite avec notre premier démon(Daemon). Avant d'expliquer comment ca marche, nous allons jeter un œil sur quelques nouvelles méthodes:
-**Game.AttachScript(filename);** - Attaches a new script file to the Game object, making it global for the whole game. This script is attached until it’s detached or ends.
+**Game.AttachScript(filename);** - Attache un nouveau fichier de script à l'objet jeu (Game), ce qui le rend global pour le jeu entier. Ce script est attaché jusqu'à ce qu'il soit détaché ou se termine.
-**Game.DetachScript(filename);** - Detaches script from the Game object.
+**Game.DetachScript(filename);** - Détache un script de l'objet jeu (Game).
-**Scene.AttachScript(filename);** - Attaches a new script file to the current scene,  making it active until player doesn’t change the current scene, or script is detached or ends.
+**Scene.AttachScript(filename);** - Attache un nouveau fichier de script à la scène courante, le rendant actif tant que le joueur ne change pas de scène courante, ou qu'il soit détaché ou se termine.
-**Scene.DetachScript(filename);** - Detaches script from the Scene object.
+**Scene.DetachScript(filename);** - Détache un script de l'objet Scène.
-We can of course attach script to the scene object in the Scene Editor or script to Game object in the Project Manager, but we want our script to be attached in the middle of the gameplay.
+Nous pouvons évidemment attacher un script à l'objet Scène dans l'éditeur de scènes ou un script à l'objet Jeu (Game) dans le gestionnaire de projets, mais nous voulons que notre script soit attaché au milieu du jeu.
-Next command we’d learn is totally necessary for the daemon writing. It’s command Sleep.
+La commande suivante que nous allons apprendre est absolument nécessaire pour écrire les Daemons. C'est la commande Sleep.
-**Sleep(time);** - Pauses the script for certain amount of milliseconds.
-Sleep serves two purposes. First - it lets the script wait for certain amount of time and second - it hands the program flow to other threads. Here’s the typical daemon pitfall:
+**Sleep(time);** - Met en pause le script pendant un certain nombre de millisecondes.
+Sleep a deux fonctions. Première - il permet au script d'attendre certaine quantité de temps, et la deuxième - elle donne la main au flux du programme pour d'autre tâches. Là c'est le piège typique des Daemon:
 <code script>
 var a = 0;
-while (1) // infinite loop, the same as while(true)
+while (1) // Boucle sans fin, c'est pareil que while(true)
 {
    a = a + 1;
@@ Line 266: / Line 270: @@
 </code>
-**Never do this. It’ll halt your computer. Script takes over the whole processing power and the rest of the game never get control back. This way also Windows never gets control back which results in hung up computer.** So how to fix this?
+**Ne jamais faire cela. Ça va stopper votre ordinateur.Le Script prend toute la puissance de traitement et le reste du jeu ne peu plus reprendre le contrôle. En faisant cela, Windows non plus ne pourra recuperer la main ce qui entraine une extinction de l'ordinateur.** Alors comment résoudre ce problème?
 <code script>
@@ Line 278: / Line 282: @@
 </code>
-This daemon is correct (remember our previous chapter), because it hands over the control from the script. One millisecond is here only formally. The important fact is that you DO hand over the control.
+Ce Daemon est correcte (Souvenez vous du chapitre précédent), parce que ca peut reprend la main sur le script. Une milliseconde c'est ici symbolique. Le fait important est que vous donner la main.
-So enough theory and let’s make some daemon fun with the commands, we’ve just learned. Oh wait. We’d need one more command:
+Bon assez de théorie et façon quelques Daemon marrants avec les commandes que nous venons juste de voir. Oh attendez. Nous aurions besoin d'une commande supplémentaire:
-**Game.Msg(text);** - although we’ve seen it before let’s recap that it displays an onscreen debug message. Very useful command.
+**Game.Msg(text);** - Bien que nous l'ayons vu auparavant rappelons qu'elle affiche un message de débogage à l'écran.
-What we’re going to do is a funny little timed sequence, which occurs in our warehouse scene. The scenario is as follows. Player examines the door to discover that there’s a time bomb attached to it. If he can’t exit quickly enough, the Scene is reloaded (it’s the hardcore-adventure-fan-way how to tell the player, that he has died).
+Ce que nous allons faire est un drôle de petite séquence chronométrée, qui va se passer dans notre scène de l'entrepôt. Le scenario est le suivant. Le joueur examine la porte et découvre qu'il y a une bombe attachée dessus. S'il ne sort pas assez rapidement, la scène est rechargée (c'est la façon "fan d'aventures hardcore" de dire au joueur, qu'il est mort).
-First we’ll create the new script in the scr folder (from the empty template) and name it **bomb.script**.
+Premièrement nous allons créer le nouveau script dans le répertoire scr (à partir d'un modèle vierge (Empty template) ) et le nommer **bomb.script**.
-Tip: if you get more skilled, you can add the new files manually by creating a text file with a script extension created in the corresponding folder.
+Astuce : si vous êtes plus expérimenté, vous pouvez ajouter les nouveaux fichiers manuellement en créant un fichier texte avec une extension script créé dans le dossier correspondant.
-Then we modify the **door.script** so it’ll read the following:
+Ensuite modifiez **door.script** pour avoir cela:
 <code script>
@@ Line 296: / Line 301: @@
 on "LeftClick"
 {
-	Game.Interactive = false;    // We want our player to make more things at once and we don't want to be interrupted.
+	Game.Interactive = false;    // Nous voulons que notre joueur fasse plusieurs choses à la fois et nous ne voulons pas être interrompu.
 	actor.GoToObject(this);
-	this.Active = false;  // We disable the door so the hotspot is not visible or active anymore.
+	this.Active = false;  // Nous désactivons la porte afin que le hot-spot ne soit plus visible ou active du tout.
-	actor.Talk("Oh no. There's a timed bomb attached to the door! I have to find an exit before it explodes.");
+	actor.Talk("Oh non. Il y a une bombe à retardement attachée à la porte! Je doit m’échapper avant qu'elle n'explose.");
 	Scene.AttachScript("scenes\warehouse\scr\bomb.script");
-	Game.Interactive = true; // Allow player to play some more.
+	Game.Interactive = true; // Permet au joueur de jouer de nouveau.
 }
 </code>
-I’ve hilighted the line which attaches our new script and thus starting the countdown.
+J'ai ajouté la ligne qui attache notre nouveau script et donc démarre le compte à rebours.
-Now let’s look at the **bomb.script** contents.
+Maintenant regardons le contenu de **bomb.script**.
 <code script>
 #include "scripts\base.inc"
-for (var timer=6;timer>-1;timer = timer -1)  // let's set up a loop which would go down from 6 to 0.
+for (var timer=6;timer>-1;timer = timer -1)  // Mettons en place une boucle qui passerait de 6 à 0.
 {
-	Game.Msg("Countdown: " + timer); //Let's display how much time do we have left.
+	Game.Msg("compte à rebours: " + timer); //Affichons combien de temps il nous reste
-	Sleep(1000); // Sleep one second (and also hand the game over to other threads)
+	Sleep(1000); // Pause une seconde (et laisse aussi la main au jeu pour d'autres tâches)
 }
-Game.Interactive = false; //Death cutsene
+Game.Interactive = false; //Scène de la mort
-actor.Talk("I've just died. Let's try again");
+actor.Talk("J'suis mort. Essayez encore.");
 Game.ChangeScene("scenes\warehouse\warehouse.scene");
 var door = Scene.GetNode("Door");
-door.Active = true; // If we die, we need to return the door to its active state or we'll never discover the bomb again.
+door.Active = true; // Si nous mourons, nous avons besoin de remettre la porte à son état actif ou nous ne pourrons pas découvrir la bombe de nouveau.
 Game.Interactive = true;
 </code>
-And the last change we’ll make is to the **exit.script**. If we found an exit in time, actor will be able to escape, but what if he arrives there in the nick of time and while talking his line, the time runs away and he dies? So let’s prevent this from happening by detaching the bomb script and letting him say something more reasonable.
+Et le dernier changement que nous allons faire est dans **exit.script**. Si vous trouvez la sortie à temps, l'acteur doit pouvoir s’échapper, mais s'il y arrive juste à temps et tout en disant sa ligne, le temps passe et qu'il meurt? Alors nous allons éviter cela en détachant le script de la bombe et le laisser parler ça serait quelque chose de plus raisonnable.
-So the contents of the **exit.script** would look like this:
+Donc le contenu de **exit.script** devrait ressembler à ça:
 <code script>
@@ Line 338: / Line 343: @@
 	if (door.Active)
 	{
-		actor.Talk("I don't want to return to my flat before I am sure I can't enter the warehouse!");
+		actor.Talk("Je ne veux pas retourner à mon appart avant d’être sûr que je ne peux pas entrer dans l'entrepôt!");
 	}
 	else
 	{
 		Scene.DetachScript("scenes\warehouse\scr\bomb.script");
-		actor.Talk("Phew. That was close");
+		actor.Talk("Ouf. C'était juste");
 		Game.ChangeScene("scenes\room\room.scene");
 	}
@@ Line 350: / Line 355: @@
 </code>
-Save everything and test our little scheme to see some more of the effects.
+Sauvegardez tout et testez notre petit système pour voir un peu plus sur les effets.
+Pour clore ce chapitre je vais ajouter un petit changement à notre système. Ce changement n'est pas nécessaire dans notre exemple, mais il le serais dans d'autres cas. Pour le moment nous avons testé, si l'entité région door est active pour prendre une décision. Mais que faire si nous avons besoin d'appliquer cette même logique sur plus d'une scène? Si nous nous tenons dans une scène différentes, logiquement nous ne pouvons pas utiliser une entité de cette façon parce qu'elle ne fait plus partie de la scène courante.
-On closing of this chapter I’ll introduce a little change to our scheme. This change is not necessary in our example, but it will be necessary in different case. For now we’re testing, if the entity region Door is Active for another decision. But what if we need to apply the similar logic to more than one scene? If we stand in different scene, we logically can’t use entity this way because it’s not anymore part of the current scene.
+Donc ce que nous pouvons faire c'est d'utiliser une variable globale. Faisons un changement dans nos scripts alors!
-So what we can do is using a global variable. Let’s make a change to our scripts then!
+Ainsi la derniere liste de code de ce triplet de script sera :
-Last code listing for this script triplet is then (changes in bold):
 **bomb.script**
@@ Line 361: / Line 367: @@
 #include "scripts\base.inc"
-for (var timer=6;timer>-1;timer = timer -1)  // let's set up a loop which would go down from 6 to 0.
+for (var timer=6;timer>-1;timer = timer -1)  // Mettons en place une boucle qui passerait de 6 à 0.
 {
-	Game.Msg("Countdown: " + timer); //Let's display how much time do we have left.
+	Game.Msg("compte à rebours: " + timer); //Affichons combien de temps il nous reste
-	Sleep(1000); // Sleep one second (and also hand the game over to other threads)
+	Sleep(1000); // Pause une seconde (et laisse aussi la main au jeu pour d'autres tâches)
 }
-Game.Interactive = false; //Death cutsene
+Game.Interactive = false; //Scène de la mort
-actor.Talk("I've just died. Let's try again");
+actor.Talk("J'suis mort. Essayez encore.");
 var door = Scene.GetNode("Door");
-door.Active = true; // If we die, we need to return the door to its active state or we'll never discover the bomb again.
+door.Active = true; // Si nous mourons, nous avons besoin de remettre la porte à son état actif ou nous ne pourrons pas découvrir la bombe de nouveau.
 global doorClicked = false;
 Game.ChangeScene("scenes\warehouse\warehouse.scene");
@@ Line 382: / Line 388: @@
 on "LeftClick"
 {
-	Game.Interactive = false;    // We want our player to make more things at once and we don't want to be interrupted.
+	Game.Interactive = false;    // Nous voulons que notre joueur fasse plusieurs choses à la fois et nous ne voulons pas être interrompu.
 	global doorClicked = true;
 	actor.GoToObject(this);
-	this.Active = false;  // We disable the door so the hotspot is not visible or active anymore.
+	this.Active = false;  // Nous désactivons la porte afin que le hot-spot ne soit plus visible ou active du tout.
-	actor.Talk("Oh no. There's a timed bomb attached to the door! I have to find an exit before it explodes.");
+	actor.Talk("Oh non. Il y a une bombe à retardement attachée à la porte! Je doit m’échapper avant qu'elle n'explose.");
 	Scene.AttachScript("scenes\warehouse\scr\bomb.script");
-	Game.Interactive = true; // Allow player to play some more.
+	Game.Interactive = true; // Permet au joueur de jouer de nouveau.
 }
 </code>
@@ Line 403: / Line 409: @@
 	if (!doorClicked)
 	{
-		actor.Talk("I don't want to return to my flat before I am sure I can't enter the warehouse!");
+		actor.Talk("Je ne veux pas retourner à mon appart avant d’être sûr que je ne peux pas entrer dans l'entrepôt!");
 	}
 	else
 	{
 		Scene.DetachScript("scenes\warehouse\scr\bomb.script");
-		actor.Talk("Phew. That was close");
+		actor.Talk("Ouf. C'était juste");
 		Game.ChangeScene("scenes\room\room.scene");
 	}
@@ Line 415: / Line 421: @@
 </code>
-We’ve seen in this chapter some neat tricks with the way how we can handle the game logic. We’ve also learned some of the important concepts for the tying scene to the code and we are able to use a couple of very basic commands and object methods. But for now we all the time used a lot of prebuilt demo code. Next chapter is all about starting the project from scratch. We’ll build upon this blank project until we create a little feature packed game. So stay tuned, we’re getting into it.
+Nous avons vu dans ce chapitre quelques astuces intéressantes avec la façon dont on peut gérer la logique du jeu. Nous avons aussi appris quelques notions importantes pour lier les scène au code et nous sommes capable d'utiliser un certain nombre de commandes et de méthodes objet très basiques. Mais pour le moment nous avons tout le temps utilisé un grand nombre de codes d'une démo pré-compilés. Le prochain chapitre est au sujet du démarrage d'un projet à partir de zéro. Nous allons partir d'un projet vierge jusqu'à créer un jeu tout simple compilé. Alors restez à l'écoute, on y va.