4. Commencer un projet [WME Resource Center]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== 4. Commencer un projet ======

Juste avant nous avons fait des essais sur une démo pré-compilées, Mais maintenant il est tant de revenir à la racine et de créer un nouveau projet complet comme on a envie. Démarrez le gestionnaire de projet et presser Ctrl+N (sinon cliquez sur l’icône nouveau projet (new project)ou choisissez Nouveau projet (New Project) dans le menu Fichiers (File) ). Nommez votre projet comme vous le souhaitez et laissez WME le créer. 

Vous pouvez voir que WME a créé un nouveau projet en y mettant quelques éléments prédéfinis ainsi le démarrage de notre nouveau jeu sera plus simple car nous pouvons dès maintenant lancer ce projet minimaliste et ça marche. Ce que nous allons quand même faire, c'est de porter notre attention sur le point avec lequel le jeu commence réellement. Ce point c'est un simple fichier appelé **game.script** //(Qui se trouve dans data->scripts)//.

Vous pouvez facilement vérifier dans votre gestionnaire de projet, que le jeu a un script attaché à lui et ça ne sera pas une surprise pour vous, que ce script c'est ... game.script. Tout simplement dit, la toute première chose que fait WME après avoir initialisées toutes les fenêtres du système c'est d’exécuter ce fichier. Je parle de ça assez largement, parce que je veut que vous compreniez bien la souplesse de WME. A ce niveau rien n'est décidé, à quoi va ressembler le jeu, comment le jeu se joue, etc...

Essayons de découvrir ce que le script du jeu fait par petit blocs:

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

D'abord nous intégrons le fichier base.inc, qui contient 3 variables globales - actor, Scene et Keyboard. Comme ça on a pas besoin, dans chaque script, à déclarer global Scene; avant d'appeler par exemple Scene.GetNode();.
Base.inc à son tour, introduit un autre fichier appelé const.inc qui contient les constantes les directions de l'acteur et les alignement de texte. Au cours de la création de notre jeu nous ajouterons des variables globales et des constantes dans ces fichiers pour garder notre jeu bien rangé. Nous pouvons également séparer nos Includes dans plus de fichiers si on est obligé. Le deuxième fichier contient la définition des codes claviers, nous n'avons donc pas à deviner des chiffres mais tapez simplement leur représentation textuelle comme VK_ESCAPE au lieu de 27 si on veut tester la touche Esc.

<code script>
Keyboard = Game.Keyboard;
Scene = Game.Scene;
</code>

Comme vous devriez déjà le savoir maintenant, tous les objets de base sont membres de l'objet Game. Mais il y a deux raisons pour lesquelles nous avons besoin de variables pour stocker ces objets imbriqués. Premièrement WME ne permet pas les imbrications donc vous ne pouvez pas utiliser par exemple:

<code script>
var e = Game.Scene.GetNode("Door");
</code>

et deuxièmement ça semble, de toute façon, plus clair si vous écrivez //Scene.GetNode("Door");//.

Donc, retour à ces lignes - Nous avons créé une variable globale Keyboard qui fait référence à l'objet //Game.Keyboard// et qui sera utilisé pour interrogé les saisies clavier et une variable globale qui fait référence à l'objet Scene. 

Comme petite annotation dans la marge - Cet objet est toujours le même, même si vous décidez de changer des scènes ainsi vous n'avez pas à la réassigner à chaque fois que vous avez changé la scène.

<code script>
global WinMenu = Game.LoadWindow("interface\menu\menu.window");
WinMenu.Visible = false;
</code>

Par défaut vous avez un comportement prédéfini, que si vous faites un clic droit sur un hotspot, un petit menu apparait dans lequel vous pouvez choisir entre trois actions. **Maintenant, faite moi plaisir et dégommer moi ces 2 lignes.** Nous allons essayer de le dépouiller.



You may ask, what is a window? Window is a collection of graphical items (buttons, images, edit fields for textual input) which is very practical for forming GUI (graphical user interface). The big advantage is that it’s Scene independent so you can have it on screen for every scene without explicitly forming the elements every time. We’ll look on the windows building later, so let’s focus for now what those two lines mean. First line loads a window file (which contains a definition of the graphical window) and second sets it invisible. The window is attached to the Game object so scene changing can’t affect it. Note that windows are an exception. Entities use //Active//, Windows use //Visible//.

<code script>
var win = Game.LoadWindow("interface\system\caption.window");
global WinCaption = win.GetWidget("caption");
</code>

And another load of window! This one is meant for captions whenever you hover your mouse over the hotspot. Also we introduce a brand new method for getting a reference to specific part of the window. This one is the actual field which holds the text. Now do me a favor – GetWidget is ancient way how to get the control. Now we use much more intuitive GetControl so rewrite the second line to:

<code script>
global WinCaption = win.GetControl("caption"); //You can also remember the parallel Scene.GetNode(name); Window.GetControl(name);
</code>

next comes:

<code script>
global MenuObject = null;
</code>
We store a **null** to MenuObject which will be used later to see what we clicked. Null is a special value, which indicates that there really is nothing. And you can delete this line as well.

<code script>
actor = Game.LoadActor("actors\molly\molly.actor");
Game.MainObject = actor;
</code>

Now those are important lines. Variable “actor” is a global variable defined in base.inc which will now be filled with the definition of our .actor file. Again later on we’ll look how the actor files are constructed. For now let’s live with the fact that we have molly and she can do whatever we want.

Also as a side note, we can use second function **Scene.LoadActor(actor);** which loads the actor but attaches it to the current scene and cthe actor is destroyed when you leave the scene.

Last we set up the attribute **MainObject** to our freshly loaded actor, which does the only thing – when actor moves and the scene is supposed to scroll, the scrolling is oriented to this actor. In case there were more switchable actors (like for example in Day of the Tentacle) this attribute will provide correct scrolling for selected character. You can set also null to this attribute.

<code script>
Game.AttachScript("scripts\game_loop.script"); //formerly known as a game_daemon.script
</code>

We’ll attach the core processes, which take care of caption displaying and inventory appearing when you scroll your mouse up. This will be our second file we’ll examine in a minute. Again you can see, that this file is globally attached for the whole game.

And now for something formerly extremely important - now settable from the project manager:

<code script>
Game.ChangeScene("scenes\Room\Room.scene");
</code>

This is the point where you define in what scene starts your game. Usually it will be some sort of Menu screen unless you start with some FMV intros or such. Now comes the main cleansing part. As we’re stripping our game down, we’ll now remove all inventory interactions only to add them later when we’ll be more skilled.

So simply modify on “LeftClick” event to read:

<code script>
on "LeftClick"
{
  var ActObj = Game.ActiveObject;
  if(ActObj!=null)
  {
     ActObj.ApplyEvent("LeftClick");
  }
  else
  {
    Scene.ApplyEvent("LeftClick");
  }
}
</code>

When we left click in the scene, we first look if the click was in the hotspot. WME knows if there is a hotspot under our mouse cursor and fills attribute **ActiveObject** accordingly. 
Now we simplified our logic to two states. If we clicked on an object, we’ll call his “LeftClick” event. This brings us back to our experiments in the last chapter where we assigned the “LeftClick” event to door. This is the reason why that event got called in the first place. **ApplyEvent** is a method which is used for running events manually.

If we clicked elsewhere (no hotspot under cursor), scene “LeftClick” event is fired. I almost hear you scream now: “Wait a minute. What is a scene “LeftClick” event?!".

This is another trick by WME which comes out of Scene template. If you create a new scene, or open your room scene in scene edit and switch to the //Properties tab// and click on the **"Scripts..."** button, you’ll see that there are two scripts attached. Your favorite scene_init.script and scripts/scene.script. And since this is the template every single scene uses, let’s uncover what dark mysteries this file holds?

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

on "LeftClick"
{
  actor.GoTo(Scene.MouseX, Scene.MouseY);
}
</code>

HA! That’s it. if this event is fired, our actor goes to the current mouse position in the scene. So it boils down to the simple thing: If we click on a hotspot it’s left click is fired else our actor walks to the current mouse position. And that’s about the LeftClicks for now.

Let’s move on to the next event “RightClick” and erase the whole block. We don’t need it now and it would only make our head spin.

Last two events (“Keypress” and “QuitGame”) deals with menu displaying and handling the alt+f4 combo. We don’t have to bother ourselves with it for now, but rest assured, that we’ll look into them soon too.

Let’s recap new methods and attributes we learned so far in this chapter:

**var window = Game.LoadWindow(window filename);**  - Loads a window definition, attaches it to the Game object and optionally returns a reference to it (in this case to window variable)
**window.Visible = true / false;** - Makes the loaded window visible/invisible on the screen
**window.GetContro(controlname);** - Returns a reference to a control stored in the window
**Game.LoadActor(actor filename);** - Loads an actor from file and attaches it to a game object.
**Scene.LoadActor(actor filename);** - Loads an actor from file and attaches it to a scene object destroying it after the scene is left.
**Game.MainObject = actor;** Sets the actor to whom the scene scrolling is synchronized.
**Game.ActiveObject;** - stores the reference to an object your mouse cursor is currently over.
**Game.ApplyEvent(eventName);** - is a method which fires the event associated to the Game object
**Scene.ApplyEvent(eventName);** - is a method which fires the event associated to the Scene object
**Node.ApplyEvent(eventName);** - is a method which fires the event associated to the node stored in the object in question.

For better understanding the last command, we could easily run in our last chapter the “LeftClick” event of the door elsewhere like this:

<code script>
var door = Scene.GetNode("Door");
door.ApplyEvent("LeftClick");
</code>

I hope you got my point now... Let’s also look if you have the same *game.script* file as I do before we proceed:

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

// store some of the game's attributes in global variables for convenience
Keyboard = Game.Keyboard;
Scene = Game.Scene;

// load the "caption" window
var win = Game.LoadWindow("interface\system\caption.window");
global WinCaption = win.GetControl("caption");

// load our main actor
actor = Game.LoadActor("actors\molly\molly.actor");
Game.MainObject = actor;

// run the "daemon" script
Game.AttachScript("scripts\game_daemon.script");

// which scene to load?
Game.ChangeScene("scenes\Room\Room.scene");



on "LeftClick"
{
  var ActObj = Game.ActiveObject;
  if(ActObj!=null)
  {
     ActObj.ApplyEvent("LeftClick");
  }
  else
  {
    Scene.ApplyEvent("LeftClick");
  }
}

on "Keypress"
{
  // on Esc or F1 key
  if(Keyboard.KeyCode==VK_ESCAPE || Keyboard.KeyCode==VK_F1)
  {
    // load and display the main menu window
    WinCaption.Visible = false;
    var WinMainMenu = Game.LoadWindow("interface\system\mainmenu.window");
    WinMainMenu.Center();
    WinMainMenu.GoSystemExclusive();
    Game.UnloadObject(WinMainMenu);
  }
}

on "QuitGame"
{
  // on Alt+F4 (window close)
  // load and display the quit confirmation window
  WinCaption.Visible = false;
  var WinQuit = Game.LoadWindow("interface\system\quit.window");
  WinQuit.Center();
  WinQuit.GoSystemExclusive();
  // and if the user selected Yes
  if(WinQuit.xResult)
  {
    // quit the game
    Game.QuitGame();
  }
  // otherwise just unload the quit window from memory
  else Game.UnloadObject(WinQuit);
}
</code>

Now test the game and you’ll see that it’s still running although we made quite some changes to it. And as we want to continue boiling our example game down to the necessary minimum, we need to look at the **game_loop.script** (formerly named game_daemon.script) as well.

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

global WinCaption;
global WinMenu; 
</code>

We can easily delete the line **global WinMenu;** because we’ve already dropped the idea of right click menu.

<code script>
while(true){  
</code>

This will be always true. This way we are looking at the infinite loop. To end this loop, one would have to call //Game.DetachScript("scripts\game_loop.script");//

<code script>
var ActObj = Game.ActiveObject;
</code>
We’ve seen exactly the same line before in the game script.

<code script>
 if(Game.Interactive && ActObj!=null)
 {
</code>

So first we test if the game is interactive and our mouse cursor is over some active object. But we’ll make this condition a bit simpler so we’ll put away all inventory items logic and it’ll look like this:

<code script>
if(Game.Interactive && ActObj!=null)
{
      WinCaption.X = Game.MouseX;
      WinCaption.Y = Game.MouseY + 20;
      WinCaption.TextAlign = TAL_LEFT;
      WinCaption.Text = ActObj.Caption;

      WinCaption.SizeToFit();
      if(WinCaption.X + WinCaption.Width > Game.ScreenWidth) WinCaption.X = Game.ScreenWidth - WinCaption.Width;
      if(WinCaption.Y + WinCaption.Height > Game.ScreenHeight) WinCaption.Y = Game.ScreenHeight - WinCaption.Height;

     WinCaption.Visible = true;
     WinCaption.Focus();
}
else WinCaption.Visible = false;
</code>

So what happens if we have our mouse over the object?

<code script>
WinCaption.X = Game.MouseX;
WinCaption.Y = Game.MouseY + 20;
</code>

WinCaption contains the reference to the text field inside of the caption window loaded in the game script. We set its position to the same coordinates as our mouse X-position and Mouse Y-position + 20 so it’ll be 20 pixels below.

<code script>
WinCaption.TextAlign = TAL_LEFT;
WinCaption.Text = ActObj.Caption;
</code>

Then we set text aligning to left and set the text of the caption to the node caption as defined in the scene editor.

<code script>
WinCaption.SizeToFit();
</code>

We resize the caption so its size is the same as the size of the displayed text.

<code script>
if(WinCaption.X + WinCaption.Width > Game.ScreenWidth) WinCaption.X = Game.ScreenWidth - WinCaption.Width;
</code>

If the caption width however extends out of the screen, we set our caption X-position to end exactly with the screen border (based on the resolution).

<code script>
if(WinCaption.Y + WinCaption.Height > Game.ScreenHeight) WinCaption.Y = Game.ScreenHeight - WinCaption.Height;
</code>

We do the same with the height and the bottom border.

<code script>
WinCaption.Visible = true;
WinCaption.Focus();
</code>

We display our caption by making it visible and give it focus, which is in this case not necessary, because we don’t interact with it. So we can simply delete this line too.

<code script>
}
else WinCaption.Visible = false;
</code>

The rest means that either the game went into non interactive mode or we moved our mouse out of any active hotspots. In both cases we simply hide the caption.

<code script>
 if(Game.Interactive && Game.MouseY < 45 && !Game.ResponsesVisible && !WinMenu.Visible) Game.InventoryVisible = true;
  else if(Game.MouseY > 100 || Game.ResponsesVisible || !Game.Interactive) Game.InventoryVisible = false;
</code>

Those two lines deal with inventory showing / disappearing and so we simply delete them.

<code script>
Sleep(20);
</code>

Remember what I’ve told you about infinite loops and hanging computers? Enough said.
So let’s look at our revised **game_daemon.script**

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

global WinCaption;

// infinite loop
while(true){
  var ActObj = Game.ActiveObject;

  if(Game.Interactive && ActObj!=null)
  {
      WinCaption.X = Game.MouseX;
      WinCaption.Y = Game.MouseY + 20;
      WinCaption.TextAlign = TAL_LEFT;
      WinCaption.Text = ActObj.Caption;
      WinCaption.SizeToFit();
      if(WinCaption.X + WinCaption.Width > Game.ScreenWidth) WinCaption.X = Game.ScreenWidth - WinCaption.Width;
      if(WinCaption.Y + WinCaption.Height > Game.ScreenHeight) WinCaption.Y = Game.ScreenHeight - WinCaption.Height;
     WinCaption.Visible = true;
  }
  else WinCaption.Visible = false;
  Sleep(20);
}
</code>

As you can see, those are the barebones of our starting project. No inventory, no menus, simple point and click game. Moreover you understand now, what’s the brain behind the game and as we build upon it, you’ll feel more comfortable knowing that you have the rock solid background. Next step: **the actor!**