Show page | Old revisions | Discuss this article
Recent changes
 
You are here: Welcome » fr » Wintermute : Le livre en ligne » 6. L'inventaire

Differences

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


fr:wmebook:ch6 2011/10/20 09:38 fr:wmebook:ch6 2011/10/20 15:00 current
Line 1: Line 1:
====== 6. L'inventaire ====== ====== 6. L'inventaire ======
-Dans ce cahpitre nous allons nous focaliser sur le fonctionnement de l'inventaire. Comme il va y avoir beaucoup de problème à couvrir, nous devrions aller directement à eux. +Dans ce chapitre nous allons nous focaliser sur le fonctionnement de l'inventaire. Comme il va y avoir beaucoup de problème à couvrir, nous devrions aller directement à eux.
- +
-D'abord clarifions ce qu'est l'inventaire. Un des aspect typique du jeu d'aventure est la possibilités de collecter diverses ordures qui trainent dans le monde du jeu et de les utiliser avec une autre afin que le joueur atteigne son ultime but, comme sauvez le monde, etc... Aussi parfois vous pourriez vouloir vous venger et utiliser de ces détritus (en parlant des articles de l'inventaire) sur quelque chose dans le monde virtuel. +
 +D'abord clarifions ce qu'est un inventaire. Un des aspect typique du jeu d'aventure est la possibilités de collecter divers saloperies qui trainent dans le monde virtuel et de les utiliser avec une autre afin que le joueur atteigne son but ultime, Sauvez le monde, etc... Aussi parfois vous pourriez vouloir vous venger et utiliser un de ces détritus (en parlant des articles de l'inventaire) sur quelque chose dans ce monde virtuel.
WME a un excellent support pour l'inventaire incluant les articles combinés et l'article stocké. WME supporte aussi plusieurs inventaires, au cas où vous auriez plus d'un acteur principal ou que vous vouliez intégrer du commerce dans votre jeu. WME a un excellent support pour l'inventaire incluant les articles combinés et l'article stocké. WME supporte aussi plusieurs inventaires, au cas où vous auriez plus d'un acteur principal ou que vous vouliez intégrer du commerce dans votre jeu.
Line 10: Line 9:
L'inventaire a deux principaux fichiers de définition: L'inventaire a deux principaux fichiers de définition:
 +  - La définition de la boite d'inventaire - définit l'endroit où votre inventaire sera stocké. Il se compose de zones rectangulaires et de barres de défilement pour naviguer dans votre inventaire.
 +  - La définition des articles de l'inventaire – définit les articles individuels et les scripts attachés pour que vous puissiez mettre en place des interactions nécessaires.
-  - Inventory box definition - defines the place where your inventory will be stored. It consists of rectangular areas and scrollbars used to navigate in your inventory. +Ces deux fichiers sont attribué dans le gestionnaire de projet et nous en avons parlé précédemment. Mais pour vous rappeler, c'est le fichier **inventory.def** et le fichier **items.items**. Bien sûr vous pouvez les nommer comme vous voulez, mais restons pour le moment avec les éléments qu'on a sous la main.
-  - Inventory items definition – defines individual items and attached scripts so you can set up necessary interactions. +
-Both files are assigned in the Project Manager and we’ve discussed them earlier but to recap, they’re **inventory.def** file and **items.items** file. Of course you can name it however you like, but let’s stick for now with the items at hand.+Avant de commencer avec ça, copiez quelque part le contenu de la ressource pour le chapitre 5. Il se compose du projet vierge que nous avons vu précédemment et on va, éventuellement, construire un jeu simple sur la base de ces fichiers.
-Before we start with that, copy somewhere contents of the resource for chapter 5. It consists of the blank project we discussed earlier and we’re going to eventually build a simple game on top of those files.+Commençons avec la définition de la boite d'inventaire. Nous allons baser notre interface sur l'image **inventory.bmp** qui se trouve dans le dossier data/interface. L'image ressemble à ça:
-Let’s start with a inventory box definition. We’re going to base our interface upon the image **inventory.bmp** located in data/interface folder. The image looks like that 
{{wmebook:inventory.jpg|}} {{wmebook:inventory.jpg|}}
-It’s very simple, yet we can easily explain the inventory mechanics on it. Before we dive into the definition file itself, we should look at the image. We see two red rectangles, which we won’t see in our game as they will serve only as a place holders for the buttons used for scrolling inventory left or right. Then we see 10 square parts which will be placeholders for our items. +C'est très simple, néanmoins nous pouvons expliquer vaguement y expliquer la mécanique de l'inventaire. Avant de nous plongez dans le fichier de définition lui-même, nous devrions regarder l'image. Nous voyons deux rectangles rouge, que nous ne verrons pas dans notre jeu, car ils servent uniquement à réserver la place pour les touches utilisées dans l'inventaire, défiler vers la gauche ou vers la droite. Puis on vois 10 carré qui seront les emplacements pour nos articles.
-So with this in mind, let’s look at the inventory.def file located in interface folder.+Bon avec ça en tête, regardons le fichier inventory.def se trouvant dans le dossier de l'interface.
<code script> <code script>
Line 32: Line 31:
</code> </code>
-Those are dimensions of individual items and they correspond to dimensions of the individual squares in the inventory box. +Ce sont les dimensions de chaque articles et elles correspondent au dimensions de chaque carré de la boite d'inventaire.
<code script> <code script>
Line 38: Line 37:
</code> </code>
-This defines how far apart are individual squares (items). This value is in pixels.+Ceci défini à quelle distance sont chaque carré (articles). Cette valeur est en pixels.
<code script> <code script>
Line 44: Line 43:
</code> </code>
-When player clicks on previous or next button, the items rotate left or right respectively. This value specifies how many items will be rotated.+Quand le joueur sur le bouton précédent ou suivant, les articles se deplace respectivement vers la gauche ou vers la droite. Cette valeur spécifie combien d'article seront déplacé (1 par 1, 2 par 2...)
<code script> <code script>
Line 50: Line 49:
</code> </code>
-If player selects an inventory item, it disappears from the inventory box (to prevent using item on itself for example).+Si le joueur sélectionne un article de l'inventaire, il disparait de la boite d'inventaire (pour empêcher d'utiliser l'article sur lui même par exemple).
<code script> <code script>
Line 56: Line 55:
</code> </code>
-Area defines the inventory item area. It’s **relative** to the inventory window, not to the screen. So even if you wanted to display inventory at the bottom, those values will still remain the same. Now these values are X,Y coordinates of  the upper-left corner and X,Y coordinates of the lower-right corner of the inventory window. In other words, coordinates (30,12) refer to the upper-left corner of first inventory item and (770,77) refers to lower-right corner of 10th inventory item. +AREA définit la zone des articles de l'inventaire. C'est **relatif** à la fenêtre d'inventaire, pas à l'écran. Donc même si vous souhaitez afficher l'inventaire en bas, ces valeurs restent les mêmes. Ces valeurs sont les coordonnées X,Y du coin supérieur gauche et les coordonnées X,Y du coin inférieur droit de la fenêtre d'inventaire. En d'autres termes, les coordonnées (30,12) correspondent au coin supérieur gauche du premier article et (770,77) correspondent au coin inférieur droit du 10e article de l'inventaire.
<code script> <code script>
Line 62: Line 61:
</code> </code>
-If set to true, player can’t do anything else until he closes the inventory window again.+Si c'est réglé sur TRUE, le joueur ne peut rien faire d'autre tant qu'il n'a pas fermé la fenêtre d'inventaire.
-Now comes the definition of the window itself. Note that our next chapters will deal with windows and controls much more extensively, but we’ll cover here what needs to be explained.+Maintenant arrive la définition de la fenêtre proprement dit. Notez que notre prochain chapitre traitera des fenêtres et des contrôles plus largement, mais nous allons présenter ici ce qui doit être expliqué.
<code script> <code script>
Line 75: Line 74:
</code> </code>
-We start with defining window position and dimensions. Those numbers are absolute, so unlike the Area, they refer to the screen position. Our window will be positioned at the top of the screen and will be 800 pixels wide and 90 pixels tall. If we wanted to position this window to the bottom of the screen, we’d simply change Y to 510 (600 – 90).+Nous commençons par définir la position et les dimensions de la fenêtre. Ces nombres sont absolus, donc contrairement à AREA, elle font référence à l'écran. Notre fenêtre sera positionnée en haut de l'écran et fera 800 pixels de large et 90 pixels de haut. Si nous avions voulu positionner cette fenêtre en bas de l’écran (800x600), nous aurions simplement passer Y à 510 (600-90).
<code script> <code script>
Line 81: Line 80:
</code> </code>
-The background image to be used for the inventory – we’ve seen it above already.+L'image de fond qui sera utilisée pour l'inventaire - Nous l'avons déjà vu plus-haut. 
<code script> <code script>
    BUTTON     BUTTON
Line 106: Line 106:
</code> </code>
-Now comes the definition of two buttons. For inventory to work properly, they have to be named **prev** for scrolling left and **next** for scrolling right in the inventory box. Text is what will be written over the button (in our case < and > ). We define dimensions and position so it will cover the red areas. **Note that position is again relative to the parent window.** Template is a button template. We’ll look in them in the window chapter, for now, let’s use the default. +Arrive maintenant la définition des deux boutons. Pour que l'inventaire fonctionne correctement, ils doivent être nommé **prev** pour le défilement à gauche et **next** pour le défilement à droite dans la boite de l'inventaire. 
 +TEXT est ce que nous allons écrire sur le bouton (dans notre cas < et >). X,Y,WIDTH et HEIGHT définissent les dimensions et la position, ils doivent couvrir les zones rouges. ** Notez que la position est à nouveau relative à la fenêtre parent.** 
 +TEMPLATE c'est le modèle de bouton. Nous verrons ça dans le chapitre des fenêtres, pour l'instant, utilisons celui par défaut.
<code script> <code script>
Line 112: Line 114:
</code> </code>
-We end the window block.+Nous terminons le bloc WINDOW.
<code script> <code script>
Line 118: Line 120:
</code> </code>
-We end the inventory block.+Nous terminons le bloc INVENTORY_BOX 
 + 
 +Ok, voyons à quoi ressemble notre inventaire. Ouvrez le fichier **game.script** et avant
-Okay, let’s see how our inventory looks like. Open the **game.script** file and before  
<code script> <code script>
Game.ChangeScene("scenes\Room\Room.scene"); Game.ChangeScene("scenes\Room\Room.scene");
</code> </code>
-put +mettez
<code script> <code script>
Game.InventoryVisible = true; Game.InventoryVisible = true;
</code> </code>
-Well, this wasn’t too hard, was it? Run the game and look at the inventory box on top.+Bien, c’était pas trop dur, n'est ce pas? Lancer le jeu et regardez l'inventaire en haut.
-Our next step in the inventory discoveries will be an items definition. For item to be successfully used in the game we need to define it’s datablock. Those datablocks appear in the file **items.items** and we have them in data/items folder. So far our file looks like this:+La prochaine étape dans la découverte de l'inventaire sera la définition des articles. Pour que les articles soit bien utilisés dans le jeu nous devons définir leurs bloc de données (datablock). Ces datablock apparaissent dans e fichier **items.items** et nous les avons dans le répertoire data/items. Jusqu'à présent notre fichier ressemble à ceci:
 +<code script>
ITEM ITEM
{ {
-  CURSOR_COMBINED = TRUE - defines if you see not only the item but also the standard cursor when you select the item. +  CURSOR_COMBINED = TRUE // Défini si vous voyez pas seulement l'article mais aussi le pointeur standard quand vous avez sélectionnez l'article. 
-  CAPTION = "WME User's Guide"  - caption of the item on mouse hover.+   
 +  CAPTION = "WME User's Guide"  // Légende de l'article quand la souris passe par dessus.
-  NAME = "book"  - in game name. You’d reference it from your scripts+  NAME = "book"  // Nom dans le jeu. Vous ferez référence a celui-ci dans vos scripts
-  SPRITE = "items\book.bmp"  - Image or sprite of the item in the inventory.+  SPRITE = "items\book.bmp"  // Image ou sprite de l'article dans l'inventaire.
-  CURSOR = "items\book.bmp" – Cursor image (sprite) when you select the item.+  CURSOR = "items\book.bmp" // image pointeur (sprite) quand vous avez sélectionné l'article.
-  CURSOR_HOVER = "items\book_h.bmp"  - Defines an image to be used as a mouse cursor when the item is selected and is over an active hotspot.+  CURSOR_HOVER = "items\book_h.bmp"  // Défini une image à utiliser comme pointeur de souris quand cet article est sélectionné et est sur un hot-spot actif..
-  SCRIPT = "items\book.script" - Attached script to the item which handles the interaction.+  SCRIPT = "items\book.script" // Script attaché à l'article qui contient les interactions.
} }
 +</code>
-We can of course define other item parameters as well:+Nous pouvons évidemment définir d'autre paramètres pour l'article:
-**SPRITE_HOVER** – when mouse goes over the inventory image it can change to another. +**SPRITE_HOVER** – Quand la souris passe au dessus de l'image de l'inventaire elle peut changer pour une autre. 
-**ALPHA** – specifies the transparency of the item image (0 = invisible, 255 = fully visible) +**ALPHA** – Spécifie la transparence de l'image de l'article  (0 = invisible, 255 = Complétement visible) 
-**TALK** - the talking animation for this item. +**TALK** - l'animation de parler pour cet article. 
-**FONT** - which font should be used for talk subtitles and amount display  +**FONT** - quelle police doit être utilisée pour les sous-titres et pour afficher la quantité.  
-**AMOUNT** - current amount of items  +**AMOUNT** - Quantité actuel d'articles  
-**DISPLAY_AMOUNT** – (TRUE / FALSE) should the current amount be displayed?  +**DISPLAY_AMOUNT** – (TRUE / FALSE) si le la quantité actuelle d'article devrait être affichée?  
-**AMOUNT_ALIGN** - the alignment of the amount label ("left", "right" or "center")  +**AMOUNT_ALIGN** - L'alignement de l’étiquette quantité ("left"(gauche), "right"(droite) ou "center"(centré))  
-**AMOUNT_OFFSET_X** - the X offset in pixels of the amount label relative to item's position  +**AMOUNT_OFFSET_X** - Le décalage en X en pixels de l’étiquette quantité relatif à la position de l'article.  
-**AMOUNT_OFFSET_Y** - the Y offset in pixels of the amount label relative to item's position +**AMOUNT_OFFSET_Y** - Le décalage en Y en pixels de l’étiquette quantité relatif à la position de l'article.
-Now we are able to define our inventory and individual items and let’s look at the way, how you can connect items with the actual game.+Nous sommes, maintenant, capable de définir notre inventaire et chaque articles et regardons la façons de lier les articles avec le jeu actuel.
-As I’ve written already, there are two ways, how to approach inventory – **Global** (one inventory for the whole game) and **Actor based** – each actor has his own inventory.+Comme je l'ai déjà écrit, il y a deux façon d'aborder l'inventaire - **Globale** (Un inventaire pour tout le jeu) et **basé sur l'acteur** - Chaque acteur a son propre inventaire.
-Let’s get moving and make our first item interaction happen. Here’s what we’ll do – we place an item (book) in the scene. Upon mouse Left Click our actor goes to that item and picks it up. Item disappears from the scene and appears in the inventory.+Faisons e sorte que notre première interaction avec l'article arrive. Qu'allons nous faire là? - Nous plaçons un article (Livre) dans la scène. dès que qu'il y un clic gauche de notre souris sur cet article et qu'il est ramassé. L'article disparait de la scène et apparait dans l'inventaire.
-  * Open our Room scene in Scene Edit.  +  * ouvrir notre salle dans l'éditeur de scene.  
-  * Add a Sprite Entity and choose a file data\items\book.bmp as a graphic file +  * Ajouter un élément Sprite et choisir le fichier data\items\book.bmp comme fichier graphique 
-  * As a Caption and Name write Book +  * Comme légende et nom écrire Book 
-  * In the Item field write book (lowercase) +  * Dans le champ Item écrire book (en minuscule) 
-  * Attach a script to this entity (you should already be familiar with the way how to do this, or return back to the previous chapters) +  * Attacher un script a cet élément (Vous devriez déjà etre familiarisé avec cette façon de faire, ou retournez au chapitre précédent) 
-  * Fill in the Walk to: and set the direction according to your book position.+  * Remplir dans Walk to: et régler la direction en fonction de la position de votre livre.
-We should get the following result:+Nous devrions avoir le resultat suivant :
{{wmebook:ch6.jpg|}} {{wmebook:ch6.jpg|}}
-Save the scene and open the file called book.script in your data\scenes\Room\scr folder.+Sauvegardez la scène et ouvrir le fichier appelé book.script dans votre répertoire data\scenes\Room\scr.
-Inside write the following:+Écrivez dedans ce qui suit:
<code script> <code script>
Line 189: Line 195:
</code> </code>
-Save and test the game. Cool, Molly went to the book and placed it into the inventory! The book also disappeared. But why?+Sauvegardez et test le jeu. Cool, Molly va vers le livre et le place dans l'inventaire! Le livre a également disparu. Mais pourquoi?
-If we fill in the **Item** value with a name corresponding to the file items.items, it becomes linked so whenever we call TakeItem method, it disappears and whenever we call DropItem it reappears. Let’s modify our little script to demonstrate this behavior:+Si nous remplissons la valeur de **Item** avec le nom correspondant au fichier items.items, il devient liée donc à chaque fois que nous appelons la méthode TakeItem, il disparait et chaque fois que nous appelons DropItem il réapparaît. Modifions notre petit script pour démontrer cela:
<code script> <code script>
Line 203: Line 209:
</code> </code>
-Not very logical game play, eh? But it shows the point. Sometimes it’s good to destroy item altogether for example if we want to combine two items to get one or if we use the item and don’t want player to have the possibility to reacquire it. For this we have in stock the **DeleteItem** method.+Pas très logique cette façon de jouer, hein? Mais ça montre ce que je veux dire. Quelque fois c'est bien de détruire complétement l'article, par exemple si on veut combiner deux articles pour en faire un ou si nous utilisons l'article et que le joueur ne veuille pas avoir la possibilité de le récupérer. Pour cela nous avons en stock la méthode **DeleteItem**.
-Before we look more into items handling, let’s look at the item in the inventory. We know, that in items.items there’s a script assigned to it. This is the file, which takes care of the item when it gets to the inventory. It’s not limited to a single scene as our previous script was and this way we should count with the fact that the player would try to use this item anywhere in the game. It would be really painful to create individual responses for each hotspot so basically we want to have unique responses for logical things and some generic “It doesn’t make any sense to use the book here.” for the rest of the hotspots. +Avant de nous pencher un peu plus dans la manipulation d'objets, regardons l'élément dans l'inventaire. Nous savons, que dans items.items il y a un script lié à lui. C'est le fichier, qui prend en charge l'élément quand il arrive dans l'inventaire. Ce n'est pas limitée à une seule scène comme notre script précédent était et ainsi nous devrions compter sur le fait que le joueur voudrait essayer d'utiliser cet élément n'importe où dans le jeu. Ce serait vraiment pénible de créer des réponses individuelles pour chaque hot-spot donc en gros nous voulons avoir des réponses uniques pour des choses logiques et certaines génériques "ça n'a aucun sens d'utiliser ce livre ici." pour les autres hot-spots
-Revert the book.script to the original version (without dropping the item) and open the data\items\book.script. Here modify the contents to read:+Restaurer book.script à sa version originale (sans le lacher d'article) et ouvrez data\items\book.script. Et modifiez le contenu pour avoir:
<code script> <code script>
Line 216: Line 222:
</code> </code>
-This single line means, that we assign inventory item as the active item and so all mouse clicks will “use” that item in the game environment. If SelectedItem is null, we don’t have anything selected and thus the normal cursor actions apply.+Cette simple ligne signifie, que nous assignons l'article de l'inventaire comme l'article actif et ainsi tout les clics de souris "utiliserons" cet article dans l'environnement du jeu. si SelectedItem est Null, Nous n'avons rien de selectionné et donc les actions du pointeur normal s'applique.
-Test the game and you can see, that if we select the book from the inventory, we can use it elsewhere but we can get rid of it. As we’re now going to build the generic action we’ve decided that if we use right click with selected item, we return that item to the inventory box.+Testez le jeu et vous pouvez voir, que si nous sélectionnons le livre dans l'inventaire, nous pouvons l'utiliser ailleurs, mais nous devons nous débarrasser de lui. Comme nous allons maintenant construire l'action générique, nous allons décidé que si nous faisons un clic droit avec l'article sélectionné, nous remettons cet article dans la boîte de l'inventaire.
-So as it’s generic action fro the whole game, open the scripts/game.script and add a RightClick handler, which will take care of this problem.+Alors comme c'est une action génériques pour l'ensemble du jeu, ouvrez scripts/game.script et ajouter la gestion RightClick, qui va s'occuper de ce problème.
<code script> <code script>
Line 231: Line 237:
</code> </code>
-Basically we only check if we have selected any item and if so, we return it to the inventory.+En fait, nous vérifions seulement si nous avons choisi un objet et si oui, nous le retournons dans l'inventaire.
-So far good and now we’re going to present the big change to our room. We’ll introduce the new character, which we will call Sally. They are twins so they’ll share the same graphics. +Jusqu'ici tout va bien et maintenant nous allons présenter le gros changement à notre salle. Nous allons introduire le nouveau personnage, qui s'appelle Sally. Elles sont jumelles donc elles partage les mêmes graphiques. :P
-Switch to the actors folder and copy the file **molly.actor** to **sally.actor** and **molly.script** to **sally.script**.+Aller dans le répertoire des acteurs et copiez le fichier **molly.actor** en **sally.actor** et **molly.script** en **sally.script**.
-In molly.actor change the beginning to look like:+Dans molly.actor changez le début pour que ça ressemble à :
<code script> <code script>
Line 249: Line 255:
</code> </code>
-In sally.actor change the beginning to look like:+Dans sally.actor changez le début pour que ça ressemble à :
<code script> <code script>
Line 261: Line 267:
</code> </code>
-Open the **data\scripts\base.inc** and add the lines+Ouvrez **data\scripts\base.inc** et ajoutez les lignes
<code script> <code script>
Line 268: Line 274:
</code> </code>
-Then open the **game.script** file and add a new actor just after the loading of the first:+Ensuite ouvrez le fichier **game.script** et ajoutez un nouvel acteur juste après avoir chargé le premier:
<code script> <code script>
Line 278: Line 284:
</code> </code>
-Last open the **data/scenes/Room/scr/scene_init.script** and modify the beginning to look like:+Enfin ouvrez **data/scenes/Room/scr/scene_init.script** et modifiez le début pour que ça ressemble à ça:
<code script> <code script>
Line 292: Line 298:
</code> </code>
-Now what we’ve done is that we’ve created another actor named Sally which uses the same graphics as a Molly, but it’s entirely different person. We have her reference stored in the global variable //actor2// and we’ve placed her in our Room scene. Next thing we’re going to do is that we’re going to implement a neat character switching.+Ce que nous venons de faire est que nous avons créé un autre acteur nommé Sally qui utilise les mêmes graphiques que Molly, mais c'est une personne entièrement différente. Nous avons sa référence stocké dans la variable globale //sally// et nous l'avons placé dans la salle. La chose suivante que nous allons faire est que nous allons mettre en œuvre un super changement personnage.
-If player clicks on Molly or Sally (without an inventory item selected) game gives control to the second actor.+Si le joueur clic sur Molly ou sur Sally (sans avoir d'article de l'inventaire sélectionné) le jeu donne le contrôle au second acteur.
-Now remember that everything in our scripts is set to use the global variable “actor”. So if we want to implement character switching, we simply set this variable to character of our liking. Also we have to change the **Game.MainObject** because it drives the screen scrolling and we want to maintain this functionality as well. So let’s open the file **molly.script** in the actor folder and add here the LeftClick handler:+souvenez vous que tout ce qui est dans vos scripts est configurer pour utilisé la variable globale "actor". donc si nous voulons faire un changement de personnage, nous réglons tout simplement cette variable sur le personnage de notre souhait. Nous devons aussi changer **Game.MainObject** parce il gère les défilement d'écran et on veut qui maintienne bien cette fonctionnalité. Donc ouvrez le fichier **molly.script** dans le dossier acteur et ajouter y la gestion LeftClick:
<code script> <code script>
on "LeftClick" on "LeftClick"
{ {
- if (Game.MainObject == molly) actor.Talk("I am already selected!");+ if (Game.MainObject == molly) actor.Talk("Je suis déjà sélectionnée!");
else else
{ {
Line 310: Line 316:
</code> </code>
-Analogically we’ll modify the sally.script to read:+Par analogie nous allons modifier **sally.script** :
<code script> <code script>
on "LeftClick" on "LeftClick"
{ {
- if (Game.MainObject == sally) actor.Talk("I am already selected!");+ if (Game.MainObject == sally) actor.Talk("e suis déjà sélectionnée!");
else else
{ {
Line 324: Line 330:
</code> </code>
-Although we could use single file for this, later on it pays off to have those separated when we want to perform different tasks with each actor.+Bien que nous aurions pu utiliser pour cela qu'un seul fichier, plus tard ça sera payant de les avoir séparé quand nous voulons effectuer des tâches différentes à chaque acteur.
-Now run the game and note that we can switch between actors by simple Left Click on them. +Maintenant lancer le jeu et remarquez que nous pouvons intervertir entre les acteurs par un simple clic gauche dessus.
-Having this done, we’ll return to our inventory and we try some interactions. First thing what we need to do is open our trusty **game.script** and actually code in the generic logic of inventory item interaction. What we want to achieve is that whenever we left click with a selected item on a hotspot, we try to call the corresponding method named by an item name. So if we click with a book, we’d try to call a method “Book” of the target entity.+Ayant fait cela, nous allons revenir à notre inventaire et nous essayons quelques interactions. La première chose que nous devons faire est d'ouvrir notre fidèle **game.script** et réelement coder dans la logique de base des interactions d'article de l'inventaire. Ce que nous voulons réaliser, c'est que chaque fois que nous avons faisons un clic gauche avec un article sélectionné sur un hot-spot, nous essayons d'appeler la méthode correspondante nommé par un nom d'article. Donc, si on clique avec un livre, on essayait d'appeler une méthode de l'entité cible "Livre".
-This can be easily done by modifying the Left Click event to read:+Ceci peut être facilement fait en modifiant l'événement Clic gauche pour avoir:
<code script> <code script>
Line 353: Line 359:
</code> </code>
-What are we programming here is the fact, that if we have selected inventory item and we’re not clicking with this item on itself (which would be applicable if we didn’t “hide” the inventory item upon selecting), then we test if the target hotspot can handle the event by the name of our item and if so, this event is fired.+Ce que nous avons programmé là est en fait, que si nous avons un article d'inventaire sélectionné et que nous ne cliquons pas avec cet article sur lui-même (Ce qui serait faisable si nous n'avions pas "cacher" l'article de l'inventaire lors de sa sélection), puis on test si le hot-spot cible peut gérer l’événement par le nom de notre article et si oui, l’événement est déclenché.
-Take some time to think about this concept and when you’re sure you understand it, read up.+Prenez du temps pour réfléchir au sujet de ce concept et quand vous êtes sur de le comprendre, continuez.
-Now in our case we have two active objects on the screen (provided that you already picked up the book) - Molly and Sally. So our goal is to make them react to the book usage.   +A présent, dans notre cas nous avons deux objets actifs sur l'écran (à condition que vous ayez déjà pris le livre) - Molly et Sally. Donc, notre objectif est de les faire réagir à l'usage livre.
-  +
-Let’s start with the concept. We want the following: if Molly is active and reads a book, she should be able to read the book. If however you try to read a book with Sally while Molly is active, Sally refuses. The same applies vice versa.+
-Let’s open **molly.script** first and add the following code:+Commençons avec ce concept. Nous voulons ce qui suit: si Molly est active et lit un livre, elle devrait être capable de lire le livre. Si toutefois vous essayez de lire un livre avec Sally tandis que Molly est actif, Sally refuse. La même chose s'applique vice et versa. 
 + 
 +Ouvrons **molly.script** d'abord et ajoutez le code suivant:
<code script> <code script>
on "book" on "book"
{ {
- if (actor == molly) actor.Talk("It's always important to read WME documentation! I'll do it now!");+ if (actor == molly) actor.Talk("C'est toujours important de lire la doc de WME! Je vais le faire maintenant!");
else else
- molly.Talk("Read it yourself Sally!");+ molly.Talk("Lit le toi même Sally!");
} }
</code> </code>
-Then open the sally.script and write there the following:+Puis ouvrez sally.script et ecrivez ce qui suit:
<code script> <code script>
on "book" on "book"
{ {
- if (actor == sally) actor.Talk("It's always important to read WME documentation! I'll do it now!");+ if (actor == sally) actor.Talk("C'est toujours important de lire la doc de WME! Je vais le faire maintenant!");
else else
- sally.Talk("Read it yourself Molly!");+ sally.Talk("Lit le toi même Molly!");
} }
</code> </code>
-Again it’s very simple logic. If actor variable containing the active actor is set to the clicked actor, we read the documentation or we say the other line. The event “book” is called because we modified the **game.script** to do this. Clear as mud?+Là encore c'est une logique très simple. Si la variable actor contenant l'acteur actif est défini sur l'acteur qui est cliqué, nous liront la doc sinon nous diront l'autre ligne. L’événement "book" est appelé parce que nous avons modifié le **game.script** pour faire cela. Clair comme du jus de boudin?
-Now we have one illogical thing. It doesn’t matter who picks up the book, both have the book in the inventory. This is the global inventory approach and it’s ok if we have one actor on the stage. But as we’ve introduced two actors, we should separate their inventories.+Nous avons maintenant un chose pas logique. Ça ne se soucis pas de qui a pris le livre, les deux ont le livre dans leur inventaire. C'est une approche d'inventaire globale et c'est bon si nous avons qu'un acteur en scène. Mais comme nous avons introduit deux acteurs, nous devrions séparer leurs inventaires.
-We’re going to try the following scenario. Whoever picks up the book will get it in his personal inventory. If this person use the book on the other character, she gives the book to the other.+Nous allons essayer le scenario suivant. Quiconque prendra le livre le mettra dans son inventaire personnel. Si cette personne utilise le livre sur l'autre personnage, elle donne le livre à l'autre.
-We’re going to introduce new Game attribute called **InventoryObject**. This attribute accepts the actor variable and we’re going to modify the actor scripts that together with the actor switching also the inventory object gets switched.+Nous allons introduire un nouvel attribut de Game qui s’appelle **InventoryObject**. Cet attribut accepte la variable acteur et nous allons modifier les scripts de l'acteur qui avec la permutation des acteur va aussi permuter les objets de inventaire.
-But it’s not enough. We also no longer use Game.TakeItem (Game.DropItem, Game.DeleteItem etc.) but we’ll use **actor.TakeItem** (**actor.DropItem**, **actor.DeleteItem**). +Mais ce n'est pas assez. Nous n'allons plus utiliser Game.TakeItem (Game.DropItem, Game.DeleteItem, etc...)mais nous allons utiliser **actor.TakeItem** (**actor.DropItem**, **actor.DeleteItem**).
-So our first stop is in game.script in our too familiar place:+Donc notre premier arrêt est dans game.script à notre emplacement trop familier:
<code script> <code script>
Line 402: Line 408:
</code> </code>
-Next stop is in data\scenes\Room\scr\book.script:+ 
 +Prochain arrêt est dans data\scenes\Room\scr\book.script:
<code script> <code script>
Line 412: Line 419:
</code> </code>
-And our last stop for now is molly and sally script adding in the Left Click handler of both this line: +Et notre dernier arrêt pour le moment est le script de Molly et de Sally en ajoutant dans le gestionnaire de clic gauche des deux ces lignes :
<code script> <code script>
Line 419: Line 426:
</code> </code>
-Now when you test the game, you see, that those girls have separate inventories and moreover who grabs the book, has it.+Maintenant quand vous testez le jeu, vous voyez que ces filles ont des inventaires séparés et d’ailleurs qui saisit le livre, l'a.
-Now let’s handle the book giving:+Maintenant occupons nous de donner le livre:
**sally.script** **sally.script**
Line 428: Line 435:
on "book" on "book"
{ {
- if (actor == sally) actor.Talk("It's always important to read WME documentation! I'll do it now!");+ if (actor == sally) actor.Talk("C'est toujours important de lire la doc de WME! Je vais le faire maintenant!");
else else
{ {
Line 434: Line 441:
molly.DropItem("book"); molly.DropItem("book");
sally.TakeItem("book"); sally.TakeItem("book");
- sally.Talk("Thank you");+ sally.Talk("Merci");
} }
} }
</code> </code>
-If we clicked by Molly with a book on Sally, we first put away the item (SelectedItem = null), then Molly drops the book and Sally takes it. This way the item gets transferred. At the end Sally thanks Molly for the book. If we didn’t call the DropItem method, both girls would have the book in their inventories.+Si nous cliquons avec Molly et le livre sur Sally, nous mettons d'abord l'article de coté (SelectedItem = null), puis Molly lâche le livre et Sally le prend. C'est la façon dont les items sont transférés. A la fin Sally remercie Molly pour le livre. Si nous n'avions pas appelé la méthode DropItem, les deux filles aurait eu le livre dans leurs inventaires.
-Molly script is almost the same:+le script de Molly est aussi le même:
<code script> <code script>
on "book" on "book"
{ {
- if (actor == molly) actor.Talk("It's always important to read WME documentation! I'll do it now!");+ if (actor == molly) actor.Talk("C'est toujours important de lire la doc de WME! Je vais le faire maintenant!");
else else
{ {
Line 452: Line 459:
sally.DropItem("book"); sally.DropItem("book");
molly.TakeItem("book"); molly.TakeItem("book");
- molly.Talk("Thank you");+ molly.Talk("Merci");
} }
} }
</code> </code>
-Last couple of methods closing this chapter are dealing with the additional item methods.+Le dernier couple de méthodes, pour clore ce chapitre, sont des méthodes supplémentaires pour les articles.
-**Game.IsItemTaken([item name]);** returns true if anyone has an item in his/her inventory. +**Game.IsItemTaken([item name]);** retourne TRUE si n'importe qui a un article dans son inventaire.
-If we want to check specific inventory for item, we’d query it through **sally.HasItem([item name]);** and again this method returns true or false. +Si nous voulons contrôler si un article est dans un inventaire spécifique, nous l'interrogeons grâce à **sally.HasItem([item name]);** et là encore cette méthode répond TRUE or FALSE 
-//(So in praxis Game.IsItemTaken("book"); or sally.HasItem("book");)//+//(Donc, en pratique Game.IsItemTaken("book"); ou sally.HasItem("book");)//
-That’s enough for the items apart from the important tip. Sometimes you don’t need an actor for a NPC as it can be for example only a shadow or a head mounted on the wall. WME doesn’t limit you by that and so even entities can have their inventories!+C'est assez pour les articles sauf ce conseil important. Quelques fois vous n'avez pas besoin d'un acteur pour un NPC comme ça peut être, par exemple, seulement un ombre ou une tête accroché au mur. WME ne vous limite pas à cela et même des entités peuvent avoir leurs inventaire!
-**Documentation link:** +**Liens vers la Documentation:** 
-//Contents-> Inside a game-> Working with the inventory// - for the general description of the inventory work+//Contents-> Inside a game-> Working with the inventory// - pour la description générale du fonctionnement de l'inventaire
 
fr/wmebook/ch6.1319096289.txt.gz · Last modified: 2011/10/20 09:38 by Anto0085
Show page | Old revisions | Discuss this article
 
Recent changes RSS feed Creative Commons License Driven by DokuWiki