Gestion des mouvements

Modèles graphiques 3D

Dessin de surfaces

Autres changements

• Un installeur plus agréable est maintenant utilisé.
• Une action a été ajoutée pour empaqueter une instance autour de l'écran.
• Une action a été ajoutée pour créer une instance aléatoire en fonction de quatre choix possibles.
• Une nouvelle structure de données en grille a été incorporée.
• Le nombre d'événéments de type alarme a été porté à 12 et le nombre d'événements définis par l'utilisateur a été fixé à 16.
• Ajout des fonctions choose(val1,val2,...) et median(val1,val2,...).
• Les blocs d'actions de l'objet ou de la ligne de temps sont désormais indentés.
• Il y a davantage d'options de placement lors de l'ajout d'images dans les sprites.
• Ajout des événements de gestion de la molette de la souris ('mouse wheel up and mouse wheel down events').
• Il est possible maintenant d'utiliser des nombres hexadécimaux commençant par un $, ex: $0000FF est rouge.
• Les réglages de synchronisation dans les options de jeu devraient mieux fonctionner désormais.
• Les moments des lignes de temps peuvent maintenant être dupliqués.
• Ajout d'une fonction screen_wait_vsync() qui attend un rafraîchissement vertical du moniteur informatique.
• Vous pouvez maintenir la touche <Shift> lors de la sélection de tuiles (tiles) pour en choisir plusieurs ou presser <Ctrl> pour en sélectionner plusieurs de la taille de la grille de la room.
• ...

Bogues corrigés

• Les fonctions de collision fonctionnent désormais correctement.
• Lors de la création de rooms (salles ou pièces) durant le jeu, la vitesse est maintenant par défaut réglée à 30.
• Le buffer est effacé lors du démarrage du jeu ou lorsque le mode graphique est changé.
• Bogue corrigé dans la fonction d3d_vertex_normal_texture_color().
• Bogue corrigé lors de la création d'un sprite ou d'un arrière-plan (background) à l'écran.
• Les variables globales sont maintenant correctement affichées en mode déboguage.
• Bogue corrigé lors de l'ajout de moments dans une ligne de temps vide pendant le jeu.
• Bogue corrigé dans le réglage de l'origine dans la fonction replace_sprite().
• Une vue (view) peut désormais suivre une instance ne possédant pas de sprite.
• Un certain nombre de problèmes concernant les sons ont été corrigés.
• Les valeurs réelles dans les fichiers INI sont désormais correctement lues avec les séparateurs ',' et '.'.
• Correction d'erreurs dans le fichier d'aide.
• L'action et la fonction pour sauter à une position aléatoire (Jump to a random position action and function) ne sautent plus en dehors de la room comme c'était parfois le cas auparavant.
• Les événements sur touches (key events) réagissent maintenant à des touches comme ~ . , [ ,etc.
• Bogue résolu concernant les destructeurs et commutateurs de particules de forme elliptique.
• Bogue corrigé qui parfois survenait quand l'on déplaçait (dragging) des actions dans la liste d'actions.
• Lors de la fusion de jeux (merging games), l'objet que doit suivre la vue, demeure désormais correct.
• Le volume par défaut du son est toujours fixé désormais au maximum.
• Ai changé la façon qu'une vue suit un objet (uniquement la position et non plus la prise en compte du sprite). Cela évite beaucoup de problèmes mais peut demander des réglages de bordure légérement plus grosse.
• Une vitesse de chemin (path speed) peut maintenant être effectivement négative.
• Correction de certaines erreurs de la barre de scrolling dans l'éditeur de rooms (room editor).
• ...

Utilisation de Game Maker

Ainsi vous souhaitez créer vos propres jeux sur ordinateur

Cela signifierait donc qu'il est impossible de créer vos propres jeux sur ordinateur ? Heureusement non. Bien sûr, ne vous attendez pas à créer un jeu comme Quake or Age of Empires en quelques semaines. Mais cela n'est pas souvent nécessaire et souhaitable. Des jeux plus simples, comme Tetris, Pacman, Space Invaders, etc. sont aussi amusants à y jouer et beaucoup plus faciles à créer. Malheureusement, cela nécessite un bon niveau de programmation pour concevoir les graphiques, les sons, l'interaction entre le joueur et bien sûr le jeu, etc.

Mais voici Game Maker qui a été écrit dans le but de rendre beaucoup plus facile la création de tels jeux. Il n'est pas nécessaire de savoir programmer. Une interface intuitive et employant le 'drag-and-drop' (sélectionner et déplacer) vous permet de créer vos propres jeux très rapidement. Vous pouvez importer et créer des images, des sprites (des images animées) ainsi que des sons pour les utiliser ensuite dans vos propres créations. Vous pourrez facilement définir les objets de votre jeu et indiquer leur comportement, vous pourrez aussi définir des rooms (salles) attrayantes avec des décors présentant des scrollings et dans lesquels le jeu prendra vie. Et si vous désirez un contrôle total, vous aurez la possibilité d'utiliser un langage de programmation très facile d'emploi , intégré à Game Maker et qui vous donnera le plein contrôle du déroulement de votre jeu.

Game Maker est spécialisé pour les jeux en deux dimensions. Cela ne signifie pas que l'on ne puisse pas créer de mondes en 3D comme Quake, bien que les fonctions graphiques 3D présentent certaines limitations. Mais que cela ne vous décourage pas. La plupart des grands jeux, comme Age of Empires, la série des Command &Conquer et Diablo utilisent la technologie des sprites en deux dimensions, malgré qu'ils semblent apparaître en dimension 3D. Et le développement de jeux en deux dimensions est beaucoup plus rapide et facile à réaliser.

Game Maker existe à la fois en version gratuite et enregistrée. La version gratuite (tout comme la version enregistrée bien entendu) peut être utilisée libre de droits. Vous pourrez librement distribuer les jeux que vous aurez créés avec et pourrez même les vendre si vous le souhaitez. Pour plus de détails, veuillez lire la licence contractuelle jointe à Game Maker. Je vous encourage fortement à vous enregistrer pour obtenir une copie pleinement fonctionnelle de Game Maker. Cela débloquera un certain nombre de fonctions supplémentaires du logiciel et supprimera le logo lors de l'exécution des jeux. Mais surtout, vous contribuerez ainsi à soutenir les développements futurs de Game Maker.

Ce document vous enseignera tout ce que vous devez savoir sur Game Maker et la façon de réaliser vos propres jeux avec le logiciel. Cependant, veuillez comprendre que même à l'aide d'un programme comme Game Maker, le développement de jeux sur ordinateur vous demandera quelques efforts. Il y a beaucoup trop d'aspects importants : le gameplay, les graphiques, les sons, l'interaction entre le jeu et l'utilisateur, etc. Commencez avec des exemples simples et donc faciles à créer. Vous réaliserez ainsi que la création de jeux peut être un loisir très amusant. Pensez également à visiter le site web.

http://www.gamemaker.nl/

pour obtenir de nombreux exemples, tutoriaux, idées et des liens sur d'autres sites et forums. Et très bientôt, vous deviendrez vous aussi un expert dans la conception de jeux sur ordinateur. Alors, amusez-vous bien avec Game Maker .

Installation

Il vous sera demandé la première fois que vous lancerez Game Maker si vous désirez lancer le programme en mode Simple ou Avancé. Si vous n'avez jamais auparavant utilisé un programme de création de jeux et que vous n'êtes pas un programmeur expérimenté, je vous conseille d'utiliser le mode simple (aussi choisissez No). Dans le mode simple, il y a moins d'options affichées. Vous pourrez ultérieurement basculer dans le mode avancé en utilisant l'article approprié dans le menu File.

Dans le répertoire d'installation (par défaut "C:\Program Files\Game_Maker6\"), il y a un certain nombre d'autres répertoires :

• examples : contient des exemples de jeux que vous pourrez examiner et/ou modifier.
• lib : contient des librairies d'actions. Si vous souhaitez installer des librairies d'actions supplémentaires, vous devrez les mettre dans ce répertoire.
• sprites : ce dossier est utilisé pour contenir les sprites à utiliser. L'installation par défaut installe juste quelques sprites, mais sur le site web de Game Maker (http://www.gamemaker.nl/), vous pourrez charger un certain nombre de ressources qui contiennent des sprites supplémentaires, des sons, des décors (backgrounds), etc.
• backgrounds, sounds : des répertoires similaires qui contiennent des images de fonds d'écran et des sons.

Système nécessaire pour utiliser Game Maker

Game Maker nécessite pour fonctionner un PC moderne de type Pentium tournant sous Windows 98SE, 2000, Me, XP, ou supérieur. Une carte graphique compatible DirectX 8 avec au moins 16 Mo de mémoire est nécessaire pour créer la plupart des jeux. Il faut également une résolution d'écran d'au moins 800x600 et 65000 couleurs (16-bit). Vous devrez également disposer d'une carte son compatible DirectX 8. DirectX version 8.0 ou supérieur doit être installé sur votre ordinateur (vous pouvez télécharger la dernière version de DirectX sur le site web de Microsoft à l'adresse : http://www.microsoft.com/windows/directx/). Lors de la conception et du test de jeux, le besoin en mémoire est assez élevé (au moins 64 Mo. Il est préférable d'en avoir davantage, ceci dépendant principalement du système d'exploitation utilisé). Quand vous lancez des jeux pour y jouer, les besoins en mémoire sont moins importants et dépendent beaucoup du type de jeu.

Enregistrement

• Plus d'affichage du logo Game Maker lors du lancement du jeu.
• Sprites tournants, avec changement de couleurs et transparents.
• Actions supplémentaires comme par exemple jouer de la musique d'un CD, textes en rotation et formes colorées.
• Effets sonores spéciaux et sons de type spatial.
• Un certain nombre de fonctions avancées de dessin, comme les polygones texturés.
• Un système de particules pour créer des feux d'artifice, des flammes, de la pluie et d'autres effets.
• Fonctions graphiques 3D.
• La possibilité de faire des jeux multi-joueurs jouables en réseau.
• Des fonctions pour créer et modifier des ressources (sprites, arrière-plans (backgrounds), etc.) durant le jeu.
• Une collection de fonctions pour créer, gérer et utiliser des structures de données.
• Des fonctions pour la gestion des déplacements.
• La possibilité d'étendre Game Maker en utilisant des librairies DLL.

Le prix d'enregistrement de Game Maker est seulement de 15 Euros ou l'équivalent en autres monnaies (ex: 20 $ US). Il y a plusieurs manières d'enregistrer votre copie du programme. La façon la plus simple est d'utiliser l'enregistrement en ligne qui utilise un système de paiement sécurisé par carte de crédit ou encore un compte PayPal. Vous pouvez aussi transfèrer de l'argent vers notre compte bancaire, nous envoyer de l'argent ou encore utiliser un mandat bancaire. Les détails sont sur le site web d'enregistrement de Game Maker :

http://www.gamemaker.nl/registration.html

Pour enregistrer votre copie de Game Maker utilisez le site web indiqué ci-dessus ou choisissez Registration (Enregistrement) à partir du menu d'aide. A la gauche du formulaire qui s'affiche, cliquez sur le bouton Go to Registration Webpage (Aller sur la page d'enregistrement). Vous serez alors redirigé sur la page de notre site web où les différentes options d'enregistrement sont indiquées, y compris l'enregistrement en ligne.

Une fois que nous aurons reçu votre enregistrement, vous recevrez un message électronique (email) avec le nom et la clé à utiliser ainsi que la façon d'entrer la clé dans le programme. Pour entrer la clé, sélectionnez une nouvelle fois Registration (Enregistrement) du menu d'aide. A la gauche du formulaire, pressez le bouton Enter a Registration Key (Entrer la clé d'enregistrement). Tapez le nom et la clé puis pressez OK. Si vous n'avez pas fait d'erreur, le programme sera alors enregistré.

Si vous avez déjà une version enregistrée de la version 5 de Game Maker installée sur votre machine, vous pouvez échanger votre clé d'enregistrement de la version 5 contre une clé d'enregistrement de la version 6. A la fin, choisissez Registration (Enregistrement) à partir du menu d'aide. A la gauche du formulaire, un bouton Convert a Version 5 Key (convertir une clé de la version 5) devrait apparaître dans ce cas. (Sinon, cela signifie qu'il n'y a pas d'enregistrement valide de la version 5 que vous possédez ou que votre version 6 est déjà enregistrée). Il y a également un texte expliquant comment convertir les clés. Lisez tout ceci avec attention et suivez les instructions puis pressez le bouton.

L'idée générale du programme

Première chose, la plupart des objets nécessitent des images afin de rendre ces derniers visibles à l'écran. On appelle ces images des sprites. La plupart du temps, un sprite n'est pas uniquement une simple image mais un ensemble d'images affichées l'une après l'autre pour ainsi créer une animation. De cette façon, le personnage peut marcher, une balle rouler, un vaisseau exploser, etc. Durant le jeu, le sprite d'un objet donné peut changer (le personnage peut ainsi paraître différent lorsqu'il marche vers la gauche ou vers la droite). Vous avez la possibilité de créer vos propres sprites dans Game Maker ou les charger à partir de fichiers (ex: images GIF animées).

Certaines choses peuvent survenir aux objets. C'est ce que l'on appelle des événements (events). Les objets peuvent exécuter certaines actions lorsque des événements surviennent. Il existe un grand nombre d'événements différents mais également un nombre important d'actions différentes que ces objets peuvent effectuer. Par exemple, Il y a un événement création (creation event) lorsque l'objet est créé (pour être plus précis, lorsqu'une instance de l'objet est créée car il peut y avoir de multiples instances d'un même objet). Par exemple : lorsqu'une balle est créée, vous pouvez lui affecter certaines actions de mouvement (motion action). Ainsi, elle commencera à bouger. Lorsque deux objets entrent en collision, un événement de collision (collision event) sera généré. Dans ce cas, vous pourrez décider de stopper ou d'inverser le sens de direction de la balle. Il vous est aussi possible de jouer des sons avec effets ou non. Dans ce but, Game Maker vous permet de définir des sons. Quand le joueur presse une touche du clavier, un événement clavier (keyboard event) est créé. L'objet peut ainsi effectuer une action appropriée, comme se déplacer dans la direction indiquée. Nous espérons que vous avez compris l'idée générale exprimée ci-dessus. Pour chaque objet créé, vous pouvez donc indiquer des actions correspondant à divers événements. De cette façon, vous définissez le comportement de l'objet.

Une fois vos objets définis, il sera alors temps de créer des rooms (salles) dans lesquelles vos objets vont vivre. On peut utiliser les rooms comme niveaux de jeu ou pour décrire différents décors de jeu. Il existe des actions pour aller d'une room à une autre. Premièrement, les rooms ont un arrière-plan ou décor (background). Cela peut être une couleur unie ou encore une image. Des images du décor (background images) peuvent être créées avec Game Maker ou chargées à partir de fichiers [le décor (background) ne fait pas grand chose en lui-même mais pour l'instant, retenez que le décor est destiné à embellir les rooms]. Enfin, vous pouvez placer des objets dans la room. Vous pouvez avoir de multiples instances du même objet dans une room. Ainsi, par exemple, vous ne définirez qu'un seul objet mur et pourrez l'utiliser à différents endroits. De la même manière, vous aurez de multiples instances d'un même objet monstre, dans la mesure cependant où les monstres présentent le même comportement.

Nous sommes maintenant prêts à lancer le jeu. La première room sera affichée et des objets prendront vie à cause des actions définies dans leurs événements de création. Ils interagiront entre eux en raison des événements de collision et réagiront aux actions de l'utilisateur en employant des événements clavier et/ou souris.

En résumé, les choses suivantes [appelées souvent ressources (resources)] jouent un rôle très important :

• les objets: qui constituent les vraies entités du jeu
• les rooms (salles ou pièces) : ce sont les endroits (niveaux de jeu) où vos objets vont prendre vie
• les sprites : les images (animées) qui représentent les objets
• les sons : on peut les utiliser dans les jeux, soit comme musiques d'arrière-plan soit comme effets
• les backgrounds (décors ou arrière-plans): les images utilisées comme décors dans les rooms

Etudions ensemble un exemple

Comme nous pouvons nous en rendre compte, nous avons besoin de deux objets différents : la balle et le mur. Nous aurons également besoin de deux sprites : un pour l'objet mur et un autre pour l'objet balle. Finalement, nous souhaiterons entendre un son quand nous réussirons à cliquer sur la balle avec la souris. Nous utiliserons juste une room (salle) où le jeu se déroulera (si vous ne souhaitez pas faire le jeu par vous-même, vous pouvez charger le fichier "hit the ball.gm6" à partir du répertoire "Examples").

Première chose à créer : les sprites. Sélectionnez Add Sprite dans le menu Add (vous pouvez aussi utiliser le bouton approprié dans la barre d'outils). Un écran s'affichera. Dans le champs Name, tapez “spr_wall”. Choisissez le bouton Load Sprite puis sélectionnez une image appropriée pour le mur. C'est tout : fermez maintenant la fenêtre. De la même manière, créez le sprite de la balle en donnant “spr_ball” comme nom de sprite.

Maintenant, nous allons créer le son. Dans le menu Add, sélectionnez Add Sound. Une fenêtre différente s'ouvre. Donnez un nom au son (ex: "son_hit_ball") puis choisissez Load Sound. Choisissez un son approprié puis écoutez-le en appuyant sur le bouton de lecture. Si vous êtes satisfait, vous pouvez fermez la fenêtre.

La prochaine étape consiste à créer les deux objets. Commençons par l'objet mur. De nouveau, choisissez Add Object dans le menu Add. Un écran un peu plus complexe que les précédents, s'affichera. A gauche, il y a les informations générales sur l'objet. Donnez un nom à l'objet ( ex: obj_mur) puis sélectionnez un sprite approprié pour le mur dans le menu du bas ("spr_wall"). Un mur étant de type solide, cliquez sur la case Solid. Ce sera tout pour le moment. De même, créez un nouvel objet, appelez-le obj_balle et affectez-lui le sprite de la balle ("spr_ball"). La balle ne doit pas être de type solide. Pour la balle, nous devons définir un comportement. Au milieu, vous pouvez voir une liste vide d'événements. En dessous, il y a un bouton nommé Add Event. Pressez-le et vous verrez tous les événements possibles. Sélectionnez creation event. Il est maintenant ajouté à la liste des événements. Plus loin à droite, vous verrez les actions possibles pour un certain nombre de groupes. A partir du groupe move, sélectionnez l'action avec l'icône représentant 8 flêches rouges puis tirez-la (drag and drop) dans la liste des actions du milieu. Cette action créera l'objet move avec une certaine direction. Ceci fait, une fenêtre de dialogue apparaîtra dans laquelle vous indiquerez la direction du mouvement. Sélectionnez toutes les flêches (8 en tout) pour indiquer une direction aléatoire. Vous pouvez laisser la vitesse réglée à 8. Fermez maintenant la fenêtre de dialogue. La balle se déplacera lorsqu'elle sera créée. En second lieu, nous devons définir ce qu'il doit se passer lors d'un événement de collision avec le mur. Une nouvelle fois, pressez Add Event. Cliquez sur le bouton des événements de collision puis déplacez l'objet mur dans le menu du bas. Nous avons aussi besoin d'une action pour gérer le rebond (bounce action). Vous pouvez voir ce que fait chaque action en plaçant pendant quelques instants le curseur de la souris près du nom de l'action. Enfin, nous avons besoin de définir ce que nous devons faire lorsque l'utilisateur presse le bouton gauche de la souris sur la balle. Ajoutez les événements correspondants puis sélectionnez le bouton gauche de la souris à partir du menu pop-up. Quelques actions sont aussi nécessaires pour cet événement : l'une pour jouer un son (peut être trouvé dans le groupe des actions main1) et l'autre pour changer le score (dans le groupe score)) et deux de plus pour déplacer la balle à une nouvelle position aléatoire et la placer dans une nouvelle direction (de la même façon que dans la création de l'événement). Concernant l'action sur le son, sélectionnez le son approprié ("son_hit_ball"). Pour l'action sur le score, tapez 1 comme valeur et vérifiez que la case Relative est cochée. Cela signifie que 1 est ajouté au score actuel. (Si vous faites une erreur, vous pouvez double-cliquer sur l'action pour changer ces paramètres.)

Nos objets sont maintenant prêts. Il reste à définir la room. Ajoutez une nouvelle room dans le jeu, toujours à partir du menu Add. A droite, vous voyez la room vide. A gauche, vous trouverez quelques onglets, un pour régler le décor (background) et un autre pour paramétrer les propriétés générales comme la largeur et la hauteur de la room, et un autre où vous pourrez ajouter des instances dans la room. En bas, vous pouvez sélectionner un objet dans le menu pop-up. En cliquant dans la room, vous pourrez placer des instances de cet objet à l'endroit souhaité. Vous pouvez enlever des instances en utilisant le bouton droit de la souris. Créez une jolie bordure autour de la room avec l'objet obj_mur. Enfin, placez 1 ou 2 objets obj_balle dans la room. Notre jeu est prêt.

Il est temps maintenant de tester notre jeu. Pressez le bouton Run (le triangle vert sur la barre de boutons en haut de la fenêtre) et regardez le déroulement du jeu. Si vous n'avez pas fait d'erreurs, la balle commence à se déplacer. Essayez de cliquer dessus avec la souris et regardez ce qui se passe. Vous pouvez arrêter le jeu en appuyant sur la touche <Esc>. Vous pourrez faire ultérieurement des modifications.

Félicitations. Vous venez de créer votre premier (petit) jeu. Mais il est temps maintenant d'en apprendre un peu plus sur Game Maker.

L'interface Utilisateur de base

(Ceci est ce que vous pouvez voir quand vous exécutez Game Maker en mode simple. Dans le mode avancé, des options supplémentaires seront affichées). A gauche, il y a les différentes ressources mentionnées plus haut : les sprites, les sons (sounds), les décors (backgrounds), les objets, les salles (rooms) et deux ressources supplémentaires : 'Information sur le jeu' (Game Information) et 'Paramètres généraux de jeu' (Global Game Settings). En haut, nous trouvons le menu habituel ainsi que la barre d'outils. Dans ce chapître, nous allons décrire brièvement les différents articles de menu, les boutons, etc. Dans les chapîtres suivants, nous détaillerons un certain nombre d'entre eux. Veuillez noter qu'il y a plusieurs manières de faire certaines choses : en choisissant une commande à partir du menu, en cliquant sur un bouton ou en cliquant avec le bouton droit de la souris sur une ressource. Dans le menu File (Fichier), vous pourrez trouver les commandes habituelles comme charger et sauver les fichiers, plus celles-ci :

• New. (Nouveau) Choisissez cette commande pour commencer la création d'un nouveau jeu. Si le jeu actuel a été modfié, il vous sera demandé si vous souhaitez le sauvegarder. Il existe également un bouton de la barre d'outils pour réaliser cete action.
• Open. (Ouvrir) Ouvre un fichier jeu. Les fichiers Game Maker portent l'extension ".gm6" (vous pouvez aussi ouvrir d'anciens fichiers ".gmd" réalisés avec une version précédente de Game Maker. Notez que ceux-ci peuvent ne plus fonctionner correctement dans la nouvelle version). De même, il y a un bouton de la barre d'outils qui exécute cette commande. Il est également possible d'ouvrir un jeu en déplaçant à la souris (drag & drop) le fichier dans la fenêtre de Game Maker .
• Recent Files. (Fichiers récents) Utilisez ce sous-menu pour réouvrir les fichiers de jeu récemment ouverts.
• Save. (Sauver) Sauvegarde le jeu sous son nom actuel. Si aucun nom n'est précisé, un nouveau nom vous sera demandé. Notez que vous ne pouvez utiliser cette commande que si le fichier a déjà été modifié. Comme à l'accoutumée, il existe un bouton dans la barre d'outils pour effectuer la même action.
• Save As. (Sauver comme) Sauvegarde le jeu sous un nom différent. Un nouveau nom vous sera demandé.
• Create Executable. (Créer un exécutable) Une fois que votre jeu est prêt, vous souhaiterez probablement le donner à d'autres personnes pour qu'ils puissent y jouer. L'utilisation de cette commande vous permettra de créer une version autonome de votre jeu. C'est simplement un exécutable que vous pourrez donner à d'autres personnes afin qu'ils puissent y jouer (NDT : plus besoin alors de disposer de Game Maker).
• Advanced Mode. (Mode avancé) En cochant cette option, Game Maker basculera entre les modes simple et avancé. Dans le mode avancé, des commandes et des ressources supplémentaires sont disponibles.
• Exit. (Quitter) Probablement l'action la plus explicite. Sélectionnez cette option pour quitter Game Maker. Si le jeu actuel a été modifié, il vous sera demandé si vous souhaitez le sauver.

Menu Edition (Edit menu)

• Insert resource. (Insérer ressource) Insère une nouvelle instance du type de ressource actuellement sélectionné avant la ressource courante. Un écran s'ouvrira dans lequel vous pourrez modifier les propriétés de la ressource. Plus de détails dans les chapîtres suivants.
• Duplicate. (Dupliquer) Réalise une copie de la ressource actuelle et l'ajoute dans les ressources disponibles. Un écran s'affiche dans lequel vous pourrez modifier la ressource.
• Delete. (Effacer) Supprime la ressource actuellement sélectionnée (ou groupe de ressources). Soyez prudent car il est impossible d'annuler cette opération. Cependant, un message de confirmation s'affichera.
• Rename. (Renommer) Donne un nouveau nom à la ressource. Ceci peut être également fait à partir de l'écran de propriétés de la ressource. Vous pouvez aussi choisir la ressource et simplement cliquer sur son nom.
• Properties. (Propriétés) Utilisez cette commande afin d'afficher la fenêtre de modification des propriétés. Veuillez noter que tous les écrans de propriétés sont accessibles dans la même fenêtre. Vous pourrez ainsi editer plusieurs propriétés en même temps. Il est possible également d'éditer les propriétés en double-cliquant sur la ressource.

Menu Ajout (Add menu)

Menu Exécution (Run menu)

• Run normally. (Lancement normal) Lance le jeu en mode normal. Le jeu est exécuté de la façon la plus efficace possible et ressemble en tout point au jeu sous sa forme exécutable.
• Run in Debug mode. (Lancement en mode débogage) Lance le jeu dans le mode débogage. Dans ce mode, vous pourrez vérifier certains aspects du jeu, effectuer une pause et avancer pas à pas dans le jeu. Cela peut être utile lorsque quelque chose ne fonctionne pas comme prévu. Veuillez noter que ce mode est plutôt réservé à des utilisateurs avancés.

Menu Fenêtre (Window menu)

• Cascade. Affiche en cascade toutes les fenêtres de manière à ce que chacune d'entre elles soit visible partiellement.
• Arrange Icons. (Ranger les fenêtres icônifiées) Aligne toutes les fenêtres icônifiées (ceci peut être utile notamment après avoir redimensionné l'écran principal).
• Close All. (Fermer tout) Ferme toutes les fenêtres, vous demandant si nécessaire de sauver ou non les changements effectués.

Menu d'Aide (Help menu)

• Contents. (Sommaire) Utilisez cette commande pour afficher ce menu d'aide.
• Registration. (Enregistrement) Bien que la version de base de Game Maker puisse être utilisée gratuitement, je vous encourage à enregistrer le programme. Cela débloquera les fonctionnalités supplémentaires du logiciel et soutiendra les développements futurs du programme. Vous trouverez ici les informations sur la manière d'enregistrer le logiciel. Si vous venez de vous enregistrer, utilisez cette commande pour entrer la clé d'enregistrement que vous avez reçue.
• Web site. (Site Web) Vous connecte sur le site web de Game Maker où vous pourrez trouver des informations sur la plus récente version de Game Maker mais aussi un grand nombre de jeux et de ressources pour Game Maker. Nous vous recommandons d'aller sur ce site pour vérification au moins une fois par mois.
• About Game Maker. (A propos de Game Maker) Donne quelques informations rapides sur cette version de Game Maker.

L'Explorateur de ressources (The resource explorer)

Vous pouvez changer l'ordre des ressources en cliquant dessus avec la souris et en maintenant le bouton de celle-ci pressé. Maintenant, déplacez (drag) la ressource à l'endroit souhaité (bien sûr, l'emplacement choisi doit être correct --> vous ne pouvez pas déplacer un son dans la liste des sprites).

Définition des Sprites

Lors de la création d'un jeu, vous commencerez normalement à vous procurer une collection de jolis sprites pour les objets de votre jeu. Des collections de sprites intéressants peuvent être trouvées sur le site web de Game Maker. D'autres sprites peuvent être téléchargés sur le web, généralement sous la forme d'images GIF animées.

Pour ajouter un sprite, choisissez l'article Add Sprite du menu Add, ou bien utilisez le bouton correspondant dans la barre d'outils. L'écran suivant s'affichera alors.

En haut, vous pourrez indiquer un nom de sprite différent de celui proposé. Tous les sprites (ainsi que toutes les autres ressources) doivent avoir un nom. Il est préférable de donner à chacun des sprites un nom évocateur. Soyez certain que toutes les ressources aient un nom différent. Bien que non obligatoire, il est fortement conseillé d'utiliser uniquement des lettres, des chiffres et le sigle "underscore" (_) dans le nom de sprite (et des autres ressources également) et de commencer par une lettre. N'utiliser pas notamment le caractère espace. Ceci est très important si vous envisagez d'utiliser la programmation dans votre jeu.

Pour charger un sprite, cliquez sur le bouton Load Sprite. Une boîte de dialogue standard s'ouvrira dans laquelle vous choisirez un fichier sprite. Game Maker peut charger différents fichiers graphiques. Quand vous chargez une animation GIF , les sous-images successives constituent les images du sprite. Un fois le sprite chargé, la première image est affichée à droite. Lorsque le sprite comporte plusieurs images, vous pouvez les afficher une par une en utilisant le bouton de type flêche.

La case à cocher nommée Transparent indique que le fond rectangulaire de l'image du sprite sera considéré comme transparent. La plupart des sprites sont transparents. La couleur du fond du sprite est déterminée par celle du pixel en bas le plus à gauche de l'image. Aussi, vérifiez qu'il n'existe pas de pixel de l'image actuelle qui ait cette couleur. (veuillez noter que les fichiers GIF définissent généralement leur propre couleur transparente. Cette couleur ne sera pas utilisée par Game Maker.)

Avec le bouton Edit Sprite, vous pouvez éditer le sprite pour le modifier et même créer un nouveau sprite.

Sons et Musiques

Pour ajouter à votre jeu une ressource de type son, utilisez l'article Add Sound du menu Add ou utilisez le bouton correspondant de la barre d'outils. L'écran suivant s'affichera.

Pour charger un son, appuyez sur le bouton Load Sound. Un sélecteur de fichiers apparaîtra alors dans lequel vous pourrez sélectionner le fichier sonore. Il y a deux types de fichiers son, les fichiers Wave et les fichiers Midi. Les fichiers Wave sont utilisés pour les courts effets sonores. Ils utilisent beaucoup de mémoire mais sont joués instantanément. Les utiliser pour tous les effets sonores de votre jeu. Les fichiers Midi décrivent la musique d'une façon différente. Ils utilisent beaucoup moins de mémoire mais se limitent au fond sonore à base d'instruments de musique. De plus, un seul son midi peut être joué à la fois.

Une fois votre fichier musical chargé, vous pouvez l'écouter en utilisant le bouton de lecture. Il existe également le bouton Save Sound pour sauver le son actuel dans un fichier. Ce bouton n'est pas réellement indispensable mais vous pourriez en avoir besoin en cas de perte du son original.

Arrière-Plans (Décors)

Pour ajouter à votre jeu une ressource de type arrière-plan (background resource), utilisez l'article Add Background du menu Add ou utilisez le bouton correspondant de la barre d'outils. La fenêtre suivante apparaîtra.

Appuyez sur le bouton Load Background pour charger une image de fonds. Game Maker supporte différents formats d'images. Les images d'arrière-plan ne peuvent être animées ! La case à cocher Transparent indique si OUI ou NON le fonds doit être partiellement transparent. La plupart des décors de jeu ne sont pas transparents, aussi la valeur est fixée par défaut à non transparent. La couleur du pixel situé le plus en bas à gauche du décor sera utilisée comme couleur de transparence.

Il vous est possible de changer l'arrière-plan ou d'en créer un nouveau en utilisant le bouton Edit Background.

Définition des objets

Veuillez bien faire la différence ente les sprites et les objets. Les sprites ne sont que des images (animées) qui n'ont pas de comportement particulier. Habituellement, les objets possédent un sprite les représentant mais les objets possédent surtout des comportements. Sans objet, il n'y aurait donc pas de jeu !

Faites bien aussi la distinction entres les objets et les instances. Un objet décrit une certaine entité, par exemple un monstre. Il peut y avoir de multiples instances de cet objet dans le jeu. Quand nous parlons d'instance, nous désignons une instance bien particulière de cet objet. Lorsque nous parlons d'un objet, nous voulons parler de toutes les instances de ce même objet.

Pour ajouter un objet dans votre jeu, choisissez Add Object du menu Add. La fenêtre suivante apparaîtra :

Cet écran paraît plus complexe car il présente davantage de fonctionnalités. A gauche, nous trouvons les informations générales sur l'objet. Au milieu, il y a une liste d'événements pouvant interagir avec l'objet. A droite, on trouve les différentes actions que l'objet peut effectuer. Les événements et les actions seront abordés dans les prochains chapîtres.

Comme d'habitude, vous pouvez (et même devriez) donner un nom à votre objet. Ensuite, vous pourrez choisir le sprite pour l'objet. Dans ce but, cliquez sur le champs du sprite à l'aide du bouton gauche de la souris ou encore sur le bouton de menu tout près de lui. Un menu s'affichera contenant tous les sprites disponibles. Sélectionnez celui que vous souhaitez utiliser pour votre objet. Si vous ne disposez pas de sprite déjà tout fait, cliquez sur le bouton New pour ajouter une nouvelle ressource sprite et la modifier. Quand vous sélectionnez une ressource, il y a également un bouton Edit que vous utiliserez pour changer le sprite. Il est plus rapide de procéder de la sorte plutôt que de rechercher la ressource dans la liste des ressources puis d'indiquer que vous voulez l'éditer.

En dessous, il existe deux cases à cocher : Visible indique si les instances de cet objet doivent être visibles. En clair, la plupart des objets sont visibles mais parfois, il est utile d'avoir des objets invisibles. Par exemple, vous pouvez les utiliser dans le but d'avoir un monstre en mouvement. Les objets invisibles réagiront aux événements et aux autres instances et pourront rentrer en collision avec eux. La case Solid (Solide) indique si un objet doit être de type solide (comme un mur). Les collisions entre objets solides sont traitées de façon différente de celles avec les objets non solides. Il est fortement conseillé d'utiliser l'option Solid uniquement pour les objets ne se déplaçant pas.

Les Evénements

Au milieu de la fenêtre des propriétés de l'objet, se trouve une liste des événements pour lequels l'objet doit réagir. Au départ, cette liste est vide. Vous pourrez ajouter des événements en appuyant sur le bouton Add Event. Un écran apparaîtra avec tous les différents types d'événements possibles. Vous sélectionnerez ici l'événement que vous souhaitez ajouter. Parfois, un menu s'affichera avec des choix supplémentaires. Par exemple, pour les événements clavier, vous devrez choisir la touche concernée par l'événement. En dessous, vous trouverez une liste compléte des différents événements avec leur description. Un seul événement de la liste peut être sélectionné à la fois. C'est l'événement sur lequel nous sommes en train de travailler. Vous pouvez changer l'événement sélectionné en cliquant dessus. A droite apparaissent toutes les actions symbolisées par de petites icônes. Elles sont regroupées sous forme d'onglets. Au prochain chapître, nous verrons les descriptions de toutes ces actions et ce qu'elles réalisent. Entre les événements et les actions, il y a la liste d'actions. Cette liste contient les actions que l'événement courant peut accomplir. Pour ajouter des actions à la liste, déposez (drag) une action à l'aide de la souris dans la liste des actions apparaissant sur la droite. Elles seront placées chacune l'une en dessous de l'autre, accompagnées d'une courte description. Pour chaque action, il vous sera demandé de fournir quelques paramètres. Ils seront également abordés dans le chapître suivant. Après avoir ajouté quelques actions, l'affichage ressemblera à ceci :

Vous pouvez maintenant ajouter des actions à d'autres événements. Cliquez sur l'événement concerné avec le bouton gauche de la souris pour le sélectionner puis déposer (drag) des actions dans la liste.

Vous pouvez modifier l'ordre des actions de la liste toujours en utilisant la fonction 'drag-and-drop' (sélectionner & déposer). Si vous maintenez la touche <Alt> lors d'un déplacement, vous créerez une copie de l'action. Vous pouvez même utiliser la fonction 'drag-and-drop' à l'intérieur des listes d'actions de différents objets. Lorsque vous cliquez avec le bouton droit de la souris sur une action, un menu apparaît dans lequel vous pourrez effacer l'action sélectionnée (peut être également réalisé en utilisant la touche <Del>) mais aussi copier ou coller des actions (vous pouvez aussi sélectionner plusieurs actions en même temps pour les couper, les copier ou les effacer en maintenant les touches <Shift> ou <Ctrl>. Pressez <Ctrl><A> pour sélectionner toutes les actions). Quand le curseur de la souris reste de manière prolongée sur une action, une plus longue description de l'action s'affiche. Voir le prochain chapître pour plus d'informations sur les actions.

Pour effacer l'événement actuellement sélectionné ainsi que toutes ses actions, appuyez sur le bouton Delete. (les événements sans action seront automatiquement supprimés quand vous fermerez la fenêtre. Aussi, il n'est pas nécessaire de procéder manuellement à leur effacement). Si vous souhaitez assigner des actions à un événement différent (par exemple parce que vous souhaitez utiliser une touche différente pour celles-ci), appuyez sur le bouton Change puis sélectionnez le nouvel événement souhaité (l'événement ne doit pas être déjà défini !). En utilisant le menu apparaissant lors du clic droit de la souris sur la liste d'événements, vous pourrez ainsi dupliquer un événement, ce qui en final, ajoutera un nouvel événement avec les mêmes actions.

Comme indiqué ci-dessus, pour ajouter un événement, pressez le bouton Add Event. La fenêtre suivante s'affichera :

Vous pourrez ici sélectionner l'événement que vous souhaitez ajouter. Certaines fois, un menu s'affichera avec des choix complémentaires. Voici une description des différents événements. (rappelez-vous que vous ne devriez normalement n'en utiliser que très peu).

Create event (Evénement à la création)
Cet événement survient lorsque l'instance de l'objet est créée. Cela est utilisé habituellement pour paramétrer l'instance dans ses mouvements et/ou donner une valeur aux variables de l'instance.

Destroy event (Evénement à la destruction)
Cet événement arrive quand l'instance est détruite. Pour être plus précis, cela survient juste avant qu'elle ne soit détruite, ainsi l'instance existe encore lorque l'événement surgit ! En principe, cet événement n'est pas utilisé mais vous pouvez néanmoins l'employer par exemple pour modifier le score ou encore pour créer un autre objet.

Alarm events (Evénements d'alarme)
Chaque instance a 12 alarmes chronomètres. Vous pouvez paramétrer les alarmes chronomètres en utilisant certaines actions (voir chapître suivant). L'horloge effectue alors un compte à rebours et déclenche l'événement d'alarme quand le chronomètre arrive à 0. Pour mentionner les actions à effectuer pour une alarme donnée, vous devez en premier lieu sélectionner cette dernière dans le menu. Les alarmes chronomètres sont très utiles. Vous pouvez les utiliser afin que certaines choses surviennent de temps en temps. Par exemple, un monstre pourra changer de direction tous les 20 steps (20 unités de temps). Dans ce cas, une des actions de l'événement devra de nouveau refixer la valeur de l'alarme chronomètre.

Step events (Evénements d'étape)
L'événement step (étape) survient à chaque étape du jeu. Vous pouvez ici mettre des actions qui ont besoin de s'exécuter en permanence. Par exemple, dans le cas où un objet doit en suivre un autre, vous pourrez ici adapter la direction du mouvement vers l'endroit où se trouve l'objet à suivre. Soyez néanmoins prudent avec ce type d'événement. Ne placez pas trop d'actions complexes dans l'événement step des objets où il existe plusieurs instances de ces derniers. Cela pourrait ralentir considérablement le jeu. Il existe trois événements step différents. En temps normal, vous ne devriez en avoir besoin que d'un seul. Mais, à l'aide du menu, vous pouvez aussi sélectionner l'événement début de step et l'événement fin de step. L'événement début de step est exécuté au début de chaque step, avant que tout autre événement ne soit pris en compte. L'événement normal step est exécuté juste avant que les instances soient placées à leurs nouvelles positions. Enfin, l'événement fin de step est exécuté à la fin du step, juste avant l'étape d'affichage. Ceci est souvent utilisé pour changer un sprite en fonction de sa direction actuelle.

Collision events (Evénements de collision)
Lorsque deux instances entrent en collision (cela signifie que leurs sprites se chevauchent), un événement de collision est généré. En fait et pour être plus précis, deux événements de collision surviennent alors, un pour chacune des instances. L'instance peut réagir à l'événement de collision. A cet effet, à partir du menu, sélectionnez l'objet pour lequel vous souhaitez définir l'événement de collision. Puis placez vos actions à cet endroit.

Il existe une différence lorsqu'une instance entre en collision avec un objet solide ou non solide. Première chose, quand il n'y a aucune action de définie dans l'événement de collision, rien ne se passera. L'instance courante continue simplement son déplacement; même si l'autre objet est de type solide. Lorsque l'événement de collision contient des actions, il peut survenir les choses suivantes :

Si l'autre objet est de type solide, l'instance est replacée à son ancienne position (c'est à dire à la position avant la collision). Ensuite l'événement est exécuté. Finalement, l'instance est déplacée à sa nouvelle position. Si, par exemple, l'événement inverse la direction du déplacement, l'instance rebondit alors contre le mur sans s'arrêter. S'il y a toujours collision, l'instance est replacée à sa position précédente. Puis elle stoppe effectivement son déplacement.

Si l'autre objet n'est pas de type solide, l'instance n'est pas replacée à sa position précédente. L'événement est simplement exécuté avec l'instance à sa position courante. Ainsi, il n'y a donc pas de seconde vérification de collision. Si vous réfléchissez bien, c'est logiquement ce qui doit se passer. Parce que l'objet n'est pas de type solide, nous pouvons donc simplement le traverser. L'événement nous indique ce qui vient de se passer.

Les événements de collision peuvent être utilisés pour divers usages. Les instances peuvent les utiliser pour rebondir contre des murs. Vous pouvez les employer par exemple pour détruire des objets quand leurs instances sont touchées par une balle ou encore un obus.

Keyboard events (Evénements clavier)
Lorsque le joueur presse une touche, un événement clavier apparaît pour toutes les instances de tous les objets. Il existe un événement différent pour chaque touche. Dans le menu, vous pouvez choisir la touche pour laquelle vous souhaitez définir un événement clavier afin d'y déposer des actions. De manière générale, seuls quelques objets nécessitent des événements pour ne gérer finalement que quelques touches. Vous obtenez un événement à chaque step tant que le joueur appuie sur la touche. Il existe deux événements clavier spéciaux. L'un d'eux s'appelle <No key>. Cet événement survient à chaque step lorsqu'aucune touche n'est pressée. L'autre se nomme <Any key> et arrive quand une touche est pressée. Lorsque le joueur presse sur plusieurs touches, les événements se produisent pour chacune des touches. Veuillez noter que les touches du clavier numérique renvoient des événements que lorsque <NumLock> est en fonction.

Mouse events (Evénements souris)
Un événement souris est visible par une instance lorsque le curseur de la souris survole le sprite représentant cette instance. Selon le bouton souris pressé, vous pouvez obtenir l'événement aucun bouton, bouton gauche, bouton droit ou bouton du milieu. Les événements souris sont créés à chaque step tant que le joueur maintient le bouton de la souris enfoncé. Les événements souris presse-bouton n'apparaissent que lorsqu'un bouton de la souris est pressé. Les événements relache-bouton sont générés seulement quand le bouton est relâché. Veuillez noter que ces événements apparaissent uniquement quand la souris se trouve au dessus d'une instance. Si vous souhaitez par contre effectuer une action lorsque l'on appuie ou relâche un bouton de la souris à un endroit arbitraire (NDT : donc indépendant d'une instance), utilisez les événement généraux de la souris que l'on peut trouver dans un des sous-menu. Il existe égalemnt deux événements spéciaux pour la souris. L'événement souris à l'entrée survient quand la souris pénètre dans l'instance. L'événement souris à la sortie apparaît lorsque la souris quitte l'instance. Ces événements sont habituellement utilisés pour changer d'image ou jouer certains sons. Les événements souris de mouvement de roulette vers le haut ou vers le bas surviennent lorsque l'utilisateur actionne la molette de la souris dans l'une des deux directions. Enfin, il existe un certain nombre d'événements concernant le joystick. Vous pouvez indiquer des actions pour les quatre directions principales du joystick (en diagonale, deux événements se produisent). Vous pouvez aussi définir des actions prenant en compte simultanément jusqu'à 8 boutons du joystick. Vous pouvez ainsi gérer à la fois le premier et un éventuel second joystick.

Other events (Autres événements)
Il y a d'autres événements pouvant être utiles dans certains jeux. Ils sont accessibles à partir de ce menu. Les événements disponibles sont les suivants :

• Outside (En dehors) : Cet événement survient lorsque l'instance se situe complètement hors de la room. C'est généralement à ce moment-là que l'on décide de détruire l'instance.
• Boundary (Au bord) : Cet événement apparaît quand l'instance touche les bords de la room.
• Game start (Au début du jeu) : Cet événement concerne toutes les instances de la première room au lancement du jeu. Cela survient avant que la room lance l'événement (voir ci-dessous) mais après les événements à la création (Creation events) des instances de la room. Cet événement est défini typiquement dans un seul objet "controller" et s'utilise pour démarrer une musique de fond, pour initialiser des variables ou encore charger des données.
• Game end (A la fin du jeu) : Cet événement concernent toutes les instances lorsque se termine le jeu. Comme d'habitude, un seul objet définit cet événement. On l'utilise par exemple pour stocker des données dans un fichier.
• Room start (Au lancement de la room) : Cet événement concerne toutes les instances déjà présents dans la room quand celle-ci démarre. Ceci se produit après les événements à la création.
• Room end (A la fin de la room) : Cet événement concerne toutes les instance existantes lorsque la room s'achève.
• No more lives (Plus de vies) : Game Maker intégre un système de gestion des vies dans le jeu. Il existe une action pour fixer et changer le nombre de vies. Lorsque le nombre de vies devient inférieur ou égal à 0, cet événement apparaît. On l'utilise souvent pour finir ou relancer le jeu.
• No more health (Plus de santé) : Game Maker comprend un système de gestion de santé du joueur. Il y a une action pour régler et changer la santé du joueur. Quand la santé est inférieure ou égale à 0, cet événement survient. Habituellement utilisé pour réduire le nombre de vies ou pour relancer le jeu.
• End of animation (Fin d'animation) : Comme mentionné ci-dessus, une animation est constituée d'un certain nombre d'images affichées l'une après l'autre. Lorsque la dernière image est affichée, on boucle en réaffichant la première. Cet événement apparaît précisément à ce moment. Ceci peut être utilisé par exemple pour changer l'animation ou pour détruire l'instance.
• End of path (Fin de chemin) : Cet événement survient lorsque l'instance suit un chemin et que la fin de chemin est atteinte.
• User defined (Evénement défini par l'utilisateur) : 16 événements utilisateur peuvent être définis. Ils ne surviennent généralement jamais sauf si vous-même les invoquez dans un programme.

Drawing event (Evénement à l'affichage)
Les instances, lorsqu'elles sont visibles, dessinent leur sprite sur l'écran à chaque step. Quand vous spécifiez des actions dans l'événement d'affichage, le sprite n'est pas dessiné mais seules ces actions sont exécutées. Ceci peut être utilisé pour dessiner autre chose qu'un sprite ou encore effectuer des changements dans les paramètres du sprite. Un certain nombre d'actions d'affichage existent, destinées principalement aux événements à l'affichage. Veuillez noter que les événements à l'affichage sont uniquement exécutés lorsque les objet sont visibles. Notez également qu'indépendamment de ce que vous dessinez, les événements de collision ne concernent que le sprite associé à l'instance.

Key press events (Evénements si touche pressée)
Cet événement est similaire à l'événement clavier mais survient une seule fois lorsqu'une touche est pressée, plutôt qu'en continu. Ceci est utile quand vous souhaitez une action ne devant survenir qu'une unique fois.

Key release events (Evénements si touche relâchée)
Cet événement est semblable à l'événement clavier sauf qu'il se produit une unique fois lors du relâchement d'une touche et non de manière continue.

Dans certains cas, il est important de bien comprendre l'ordre dans lequel Game Maker traite les événements. L'ordre d'exécution est le suivant :

• Begin step events (Evénements de début de step)
• Alarm events (Evénements alarme chronomètre)
• Keyboard, Key press, and Key release events (Evénements clavier, si touche pressée et si touche relâchée)
• Mouse events (Evénements de la souris)
• Normal step events (Evénements step normal)
• (now all instances are set to their new positions) (toutes les instances sont placées désormais à leurs nouvelles positions)
• Collision events (Evénements de collision)
• End step events (Evénements de fin de tep)
• Drawing events (Evénements à l'affichage)

La création, la destruction et les autres événements ne sont traités que lorsque des choses les concernant surviennent.

Les Actions

Toutes les actions sont disponibles dans des pages d'onglets situées à droite de la fenêtre de propriétés des objets. Il y a six jeux d'actions possibles. Vous sélectionnez le jeu souhaité en cliquant sur l'onglet approprié. Lorsque vous maintenez la souris appuyée au dessus d'une action, une courte description s'affiche pour vous permettre de comprendrer sa finalité.

Faisons un bref rappel : Pour placer une action dans un événement, il suffit de la déposer (drag) dans la liste d'actions à partir des pages d'onglets. Vous pouvez changer l'ordre dans la liste, en procédant de la même manière (dragging). Pour faire une copie de l'action, maintenez la touche <Alt> tout en la déplaçant (drag). Vous pouvez déposer (drag) et copier des actions à l'intérieur des listes des différents écrans de propriétés d'objets. Utilisez le bouton droit de la souris puis sélectionnez l'article du menu concerné pour supprimer des actions (ou encore utilisez la touche <Del> key), les copier ou les coller.

Lorsque vous lâcher (drop) une action dans la liste des actions, une fenêtre apparaîtra la plupart du temps, dans laquelle vous pourrez indiquer certains paramètres concernant cette action. Les paramètres seront décrits ci-dessous lors de la description des actions. Deux types de paramètres concernent la plupart des actions. Nous allons donc les décrire ici. En haut, vous pouvez mentionner sur quelle instance doit s'appliquer l'action. Par défaut, c'est self qui est l'instance pour laquelle l'action est exécutée. La plupart du temps, c'est ce que vous devrez utiliser. Dans le cas d'un événement de collision, vous pourrez préciser si l'action doit s'appliquer à une autre instance concernée par la collision. De cette manière, vous pourrez détruire une autre instance par exemple. Enfin, vous pourrez choisir d'appliquer l'action à toutes les instances d'un objet particulier. Ainsi, il vous sera possible de changer toutes les balles rouge en balles bleu. Le second type de paramètre est la case nommée Relative. En cochant cette case, les valeurs saisies seront relatives par rapport aux valeurs courantes. De cette façon, vous pourrez ajouter des points au score actuel, plutôt que d'affecter une nouvelle valeur absolue à ce score. Les autres paramètres seront décrits plus bas. Vous pourrez ultérieurement modifier ces paramètres en double-cliquant sur l'action.

Les Actions de Mouvements

Start moving in a direction (Déplacement dans une direction)
Utilisez cette action pour effectuer le déplacement d'une instance dans une certaine direction. Vous pouvez indiquer la direction de l'instance en utilisant les boutons flêchés. Utilisez le bouton du milieu pour stopper le déplacement. Vous devrez mentionner également la vitesse de déplacement. La vitesse est donnée en pixels par step. La valeur par défaut est de 8. Il est préférable de ne pas utiliser de valeurs négatives pour régler la vitesse. Vous pouvez indiquer plusieurs directions. Dans ce cas, un choix aléatoire sera réalisé. De cette manière, un monstre peut aller soit à gauche soit à droite.

Set direction and speed of motion (Régler la direction et la vitesse du déplacement)
Ceci constitue la deuxième manière de réaliser un déplacement. Ici, vous indiquerez une direction précise. C'est un angle compris entre 0 et 360 degrés, 0 signifiant aller vers la droite. La direction suit le mouvement inverse des aiguilles d'une montre. Ainsi, par exemple, 90 indique un déplacement vers le haut. Si vous souhaitez une direction arbitraire, tapez alors random(360). Comme nous le verrons ci-dessous, la fonction random fournit un nombre aléatoire inférieur à la valeur donnée en paramètre. Vous avez sans doute remarqué qu'il existe une case nommée Relative. Si vous la cochez, le prochain déplacement sera ajouté au précédent. Par exemple, si l'instance se déplace vers le haut et que vous ajoutez un déplacement vers la gauche, le nouveau déplacement se fera du haut vers la gauche.

Move towards a point( Déplacement vers un point donné)
Cette action fournit une troisième façon de calculer un déplacement. Vous indiquerez ici une position et une vitesse et l'instance commencera à se déplacer vers le point désigné, à la vitesse indiquée (elle ne s'arrêtera pas à ce point !). Par exemple, si vous voulez qu'un boulet se dirige en direction d'un vaisseau spatial, vous pourrez utiliser comme position spaceship.x, spaceship.y (vous en apprendrez davantage sur l'emploi des variables plus bas dans ce document). Si vous cochez la case Relative, vous mentionnerez la position relative à celle actuelle de l'instance (la vitesse quant à elle, n'est pas prise en compte de manière relative !)

Set the horizontal speed (Régler la vitesse horizontale)
La vitesse d'une instance se décompose horizontalement et verticalement. Avec cette action, vous pouvez changer la vitesse horizontale. Une vitesse horizontale positive signifie un déplacement vers la droite. Une valeur négative indique un déplacement vers la gauche. La vitesse verticale suit le même principe. Utilisez la case relative pour augmenter la vitesse horizontale (une valeur négative la diminuera).

Set the vertical speed (Régler la vitesse verticale)
De la même manière, vous pouvez changer avec cette action la vitesse verticale d'une instance.

Set the gravity (Paramétrer la gravité)
A l'aide de cette action, vous allez créer la gravité d'un objet particulier. Vous indiquez une direction (un angle compris entre 0 et 360 degrés) et une vitesse. A chaque étape, la vitesse indiquée est ajoutée au déplacement actuel de l'instance de l'objet et ce dans la direction spécifiée. Vous devrez utiliser normalement un très petit incrément pour la vitesse (comme 0.01). Généralement, vous souhaiterez utiliser une direction vers le bas (270 degrés). Si vous cochez la case Relative, vous augmenterez la vitesse de la gravité ainsi que la direction. Veuillez noter que, contrairement à la réalité, des objets (différents) peuvent avoir des directions gravitationnelles différentes.

Reverse horizontal direction (Inverser la direction horizontale)
Avec cette action, vous inverserez le déplacement horizontal de l'instance. Ceci peut être utilisé par exemple lorsqu'un objet entre en collision avec un mur vertical.

Reverse vertical direction (Inverser la direction verticale)
Avec cette action, vous inverserez le déplacement vertical de l'instance. Ceci peut être utilisé par exemple quand un objet entre en collision avec un mur horizontal.

Set the friction (Paramétrer la friction)
La friction ralentit le déplacement des instances. Vous indiquerez ici une valeur de friction. A chaque step, la quantité indiquée sera déduite de la vitesse jusqu'à ce que celle-ci arrive à 0. Habituellement, vous mentionnerez un très petit nombre (comme 0.01).

Jump to a given position (Aller à une position donnée)
En utilisant cette action, vous pourrez placer l'instance à une position particuliére. Vous indiquerez simplement les coordonnées x et y et l'instance sera placée à cette position avec son point de référence. Si vous cochez la case Relative, la position sera relative à l'actuelle position de l'instance. Cette action est souvent employée pour déplacer une instance en continu. A chaque step, la position est incrémentée d'une valeur très infime.

Jump to the start position (Aller à la position de départ)
Cette action place l'instance de nouveau à la position qu'elle avait à sa création.

Jump to a random position (Sauter à une position aléatoire)
Cette action déplace l'instance à une position aléatoire de la room. Seules les positions ne présentant pas de point d'intersection avec des instances d'objets solides, seront choisies au hasard. Vous pouvez indiquer l'alignement à utiliser. Si vous spécifiez des valeurs positives, les coordonnées seront déterminées en utilisant des entiers multiples des valeurs saisies. Cela peut être utilisé par exemple pour forcer une instance à s'aligner avec les cellules de votre jeu (s'il en existe). Vous pouvez indiquer séparément un alignement horizontal et vertical.

Snap to grid (Aligner avec la grille)
Avec cette action, vous pouvez positionner précisément l'instance sur la grille. Vous indiquerez à la fois la valeur d'alignement horizontale et verticale (ceci correspond à la taille des cellules de la grille). Très utile pour être sûr que les instances restent sur la grille.

Wrap when moving outside (Permettre le déplacement de bord à bord)
Avec cette action, une instance pourra se déplacer de bord à bord de la room (moving wrap). Cela se produit lorsque l'instance quitte un côté de la room pour réapparaître de l'autre côté. Cette action est habituellement employée dans l'événement Outside. Veuillez remarquer que l'instance doit mentionner une vitesse afin que le déplacement de bord à bord puisse fonctionner, ceci en raison de la direction de déplacement de bord à bord qui est basée sur la direction de mouvement. Vous pouvez indiquer si l'on doit permettre uniquement un déplacement horizontal, vertical ou encore dans les deux directions.

Move to contact position (Aller à une position de contact)
Avec cette action, vous pourrez déplacer une instance dans une direction donnée jusqu'à ce que celle-ci entre en contact avec un objet. Si l'instance est déjà en collision avec un autre objet, elle ne sera pas déplacée. Sinon, l'instance sera positionnée juste avant que la collision ne survienne. Vous pouvez indiquer la direction mais aussi une distance maximale pour le déplacement. Par exemple, lorsque l'instance tombe, vous pouvez la faire se déplacer vers le bas d'une certaine distance jusqu'à ce qu'un objet soit rencontré. Vous pourrez également indiquer si l'on doit prendre en compte uniquement les objets solides ou encore tous les objets.Vous mettrez habituellement cette action dans un événement de collision afin de vous assurer que l'instance s'arrêtera au contact d'une autre instance impliquée dans la collision.

Bounce against objects (Rebonds contre des objets)
Lorsque vous placez cette action dans l'événement de collision d'un objet, l'instance de l'objet rebondit de façon naturelle. Si vous régler le paramètre 'precise' à Faux, seules les murs horizontaux et verticaux seront traités correctement. Si 'precise' est paramétrée à Vrai, les murs inclinés (et même ceux qui sont courbés) seront également pris en compte. Ceci est cependant assez lent. Aussi, vous devrez préciser si le rebond concerne uniquement les objets solides ou encore tous les objets. Veuillez bien noter que la gestion du rebond n'est pas complétement fonctionnelle car cela dépend de nombreuses propriétés. Cependant, dans la plupart des situations, le résultat devrait généralement être assez satisfaisant.

Actions Principales, jeu n°1

Create an instance of an object (Créer une instance d'un objet)
Avec cette action, vous pourrez créer une instance d'un objet. Vous indiquerez quel est l'objet à créer ainsi que la position de la nouvelle instance. Si vous cochez la case Relative, la position sera relative à la position de l'instance courante. La création d'instances durant le jeu est extrémement utile. Un vaisseau spatial peut créer des balles; une bombe peut créer une explosion, etc. Dans la plupart des jeux, vous aurez besoin d'un objet contrôleur qui créera de temps à autre des monstres ou bien encore d'autres objets. Pour les nouvelles instances créées, c'est l'événement à la création qui est exécuté.

Create an instance of an object with a speed and direction (Créer une instance d'un objet avec une vitesse et une direction)
Cette action fonctionne de la même manière que celle décrite ci-dessus mais comprend deux champs supplémentaires. Vous pouvez ici préciser la vitesse et la direction de l'instance nouvellement créée. Veuillez noter que si la case Relative est cochée, seule la position sera relative et non la vitesse, ni la direction. Par exemple, pour faire en sorte qu'une balle aille dans la direction d'un personnage en train de tirer, vous devrez utiliser une petite astuce. Comme position, indiquez 0,0 et cochez la case Relative. Nous devrons également connaître la direction actuelle de l'instance. On peut l'obtenir en utilisant le mot direction (ceci est une variable qui indique toujours la direction actuelle dans laquelle se déplace une instance).

Create instance of random object (Créer une instance d'un objet aléatoire)
Cette action vous permet de créer une instance avec plusieurs objets (un à quatre objets). Vous précisez les quatre objets ainsi que leur position. Une instance de l'un de ces quatre objets sera créée à la position indiquée. Si vous cochez la case Relative, la position sera relative à la position de l'instance courante. Si vous avez besoin de choisir moins de quatre objets, vous pourrez utiliser No Object pour certains d'entre eux. Ceci est utile par exemple pour générer et afficher un ennemi aléatoire.

Change the instance (Modification de l'instance)
Avec cette action, vous pouvez modifier l'instance actuelle en une instance d'un autre objet. Ainsi, par exemple, vous pourrez changer l'instance d'une bombe en celle d'une explosion. Tous les paramétres, comme le mouvement et les valeurs des variables, resteront les mêmes. Vous pourrez mentionner si l'on doit exécuter ou non l'événement à la destruction pour l'objet courant et l'événement à la création pour le nouvel objet.

Destroy the instance (Détruire l'instance)
Avec cette action, vous détruisez l'instance courante. L'événement à la destruction de l'instance est exécuté.

Destroy instances at a position (Détruire des instances à une position donnée)
Cette action vous permet de détruire toutes les instances se trouvant dans un certain périmètre. Ceci est utile par exemple lorsque vous faites exploser une bombe. Si vous cochez la case Relative, la position sera déterminée en fonction de la position de l'actuelle instance.

Change the sprite (Changer le sprite)
Utilisez cette action pour changer le sprite de l'instance. Vous indiquerez avec quel sprite le changement doit avoir lieu. Vous pouvez également indiquer quelle sous-image doit être affichée. Vous utiliserez ordinairement 0 (la première sous-image) à moins que vous ne désireriez voir une sous-image particulière. Utilisez -1 si vous ne souhaitez pas changer la sous-image actuellement affichée. Enfin, vous pourrez changer la vitesse de l'animation des sous-images. Si vous voulez seulement voir une sous-image particulière, réglez la vitesse à 0. Si la vitesse est supérieure à 1, des sous-images seront occultées. Si elle est plus petite que 1 alors les sous-images seront affichées plusieurs fois. Ne pas utiliser de vitesse négative. Le changement des sprites est une possibilité intéressante et importante. Par exemple, vous souhaiterez souvent modifier le sprite d'un personnage en fonction de la direction de sa marche. Ceci peut être réalisé en créant différents sprites pour chacune (quatre) des directions. A l'aide des événements clavier et des touches flêchées, vous serez en mesure de diriger la direction du déplacement mais aussi le sprite.

Transform the sprite (Transformer le sprite)
Utilisez cette action pour modifier la taille et l'orientation du sprite de l'instance. Utilisez un facteur d'échelle pour l'agrandir ou le rétrécir. L'angle indique l'orientation du sprite dans le sens contraire des aiguilles d'une montre. Afin que le sprite soit orienté dans la direction du mouvement, utilisez la variable direction. Par exemple, ceci est très utilisé pour une voiture. Vous pourrez aussi indiquer si le sprite doit avoir un effet miroir horizontal et/ou doit être retourné verticalement. Cette action n'est disponible que dans la version enregistrée.

Set sprite blending (Paramétrer le mélange de couleur du sprite)
D'ordinaire, le sprite est dessiné comme il a été défini. Si vous utilisez cette action, il vous sera possible de changer la couleur du sprite. Cette couleur sera mélangée avec celle du sprite, c'est à dire qu'elle sera combinée avec les autres couleurs du sprite. Si vous souhaitez dessiner un sprite avec des couleurs différentes, il est préférable de définir le sprite en noir et blanc puis d'utiliser la couleur de mélange pour déterminer la nouvelle couleur. Vous pouvez aussi employer une transparence alpha. Une valeur fixée à 1 rendra le sprite opaque. Une valeur à 0 le rendra complétement transparent. Entre ces deux valeurs, vous apercevrez partiellement le décor sous le sprite. C'est vraiment super par exemple pour la création d'explosions. Cette action n'est disponible que dans la version enregistrée.

Play a sound (Jouer un son)
Cette action vous permet de jouer une ressource son que vous aurez incorporée auparavant dans votre jeu. Vous choisirez le son à jouer et déterminerez s'il doit être joué une seule fois (par défaut) ou en boucle. Plusieurs sons Wave peuvent être joués en même temps mais un unique son Midi peut être joué. Ainsi, si vous jouez un autre son Midi, l'actuel son Midi sera interrompu.

Stop a sound (Stopper un son)
Cette action stoppe le son indiqué. Dans le cas où il y a plusieurs instances d'un même son, toutes seront arrêtées.

If a sound is playing (Teste si un son est actuellement joué)
Dans le cas où le son indiqué est en cours de lecture, l'action suivante sera exécutée. Sinon, elle sera sautée. Vous pouvez sélectionner Not pour spécifier que l'action suivante sera prise en compte que si le son concerné n'est pas actuellement en cours de lecture. Par exemple, vous pourrez tester si la musique de fond est toujours en train d'être jouée et dans la négative, vous pourrez lancer la lecture d'une nouvelle musique en arrière-plan. Prenez note que cette action retourne la valeur vrai (true) lorsque le son sort actuellement des haut-parleurs. Après l'appel de cette action pour écouter un son, ce dernier n'a peut être pas encore atteint les haut-parleurs. Aussi, l'action pourra parfois retourner une valeur faux (false) pendant un certain laps de temps. Le même raisonnement s'applique quand le son est stoppé : il vous sera peut-être encore possible d'entendre le son ( en raison de l'écho ) alors que l'action retournera la valeur vrai.

Go to previous room (Aller à la room précédente)
Va à la room précédente. Vous pouvez indiquer le type d'effet de transition entre les rooms. A expérimenter afin de constater par vous-même ce qui vous plaît le mieux. Si vous êtes dans la première room, vous obtiendrez une erreur.

Go to next room (Aller à la room suivante)
Va à la room suivante. Là encore, vous pourrez indiquer l'effet de transition.

Restart the current room (Réafficher la room actuelle)
La room courante est réaffichée.Vous pourrez mentionner un effet de transition.

Go to a different room (Aller à une room différente)
Avec cette action, vous vous déplacerez à une room particulière. Vous indiquerez la room et l'effet de transition.

If previous room exists (Teste si la room précédente existe)
Cette action teste s'il existe une room précédente. Dans l'affirmative, l'action suivante sera exécutée. Vous devriez effectuer ce test avant de vouloir vous déplacer à une room précédente.

If next room exists (Teste si la room suivante existe)
Cette action teste s'il existe une room suivante. Si oui, la prochaine action sera réalisée. Vous devriez effectuer ce test avant de vouloir vous déplacer à la prochaine room.

Actions Principales, jeu n° 2

Set an alarm clock (Paramétrer une alarme chronomètre)
Cette action vous permet de régler l'une des douze alarmes chronomètres disponibles pour une instance. Vous devrez sélectionner le nombre de steps et le n° de l'alarme chronomètre. Après expiration du nombre de steps indiqués, l'instance recevra un signal de l'événement d'alarme correspondant. Vous pouvez aussi augmenter ou diminuer la valeur en cochant la case Relative. Si vous réglez l'alarme chronomètre à une valeur négative, vous suspenderez cette alarme. L'événement ne sera alors jamais généré.

Sleep for a while (Attendre un certain temps)
Cette action vous permet de geler une scène pendant un certain temps. On l'utilise généralement au début ou à la fin d'un niveau ou lorsque l'on affiche un message au joueur. Vous mentionnerez le nombre de millisecondes à attendre. Vous pourrez aussi indiquer si l'écran doit être réaffiché afin de tenir compte des dernières modifications graphiques effectuées.

Display a message (Afficher un message)
Avec cette action, vous pouvez afficher un message dans une boîte de dialogue. Vous devrez simplement taper le message. Si vous utilisez le caractère # dans le corps du message, il sera interprété comme un symbole de retour à la ligne (utilisez alors \# pour afficher le caractère # lui-même). Si le texte du message débute avec une simple ou double quote, il sera interprété en tant qu'expression. Voir plus loin pour obtenir davantage d'informations sur les expressions.

Show the game information (Afficher les informations sur le jeu)
Cette action fait apparaître la fenêtre d'informations concernant le jeu.

Restart the game (Relancer le jeu)
Vous pouvez relancer le jeu depuis le début avec cette action.

End the game (Fin du jeu)
Cette action vous permet de quitter le jeu.

Save the game (Sauver le jeu)
Avec cette action, vous avez la possibilité de sauvegarder les principaux paramètres du jeu en cours. Vous devrez mentionner le nom du fichier de sauvegarde (le fichier sera créé dans le répertoire de travail du jeu). Ultérieurement, le jeu pourra être rechargé en utilisant l'action décrite ci-dessous (seul le statut de base du jeu est sauvé. Les choses qui par exemple ne sont pas sauvegardées, concernent les sons en cours et certains aspects avancés comme le contenu des structures de donnée, les particules, etc).

Load the game (Charger le jeu)
Cette action charge le statut du jeu à partir d'un fichier. Vous devrez indiquer le nom du fichier de sauvegarde. Soyez sûr que le jeu de sauvegarde indiqué corresponde bien au jeu concerné et ait été généré avec la même version de Game Maker. Sinon, une erreur surviendra (pour être plus précis, le jeu est chargé à la fin du step courant. Aussi, certaines actions après celui-ci sont encore exécutées dans le jeu actuel, et non pas dans celui venant d'être chargé !).

Actions de contrôle

La question posée ici teste si la position de l'instance actuelle est libre de collision. Si oui alors l'instance se déplacera dans la direction indiquée. Si ce n'est pas le cas, l'instance sautera à une position indiquée dans le bloc else.

Pour toutes les questions, il existe un champs nommé NOT. Si vous cochez ce champs, le sens de la question est inversé. C'est à dire que si par exemple la réponse à la question était vrai, alors elle deviendra faux et vice-versa.. Cela vous permet d'exécuter certaines actions dans le cas où le résultat de la question n'est pas vrai.

A la plupart des questions, vous pouvez indiquer ce qu'il devrait s'appliquer à toutes les instances d'un objet particulier. Dans ce cas, le résultat sera vrai si et seulement si le résultat est également vrai pour toutes les instances de l'objet. Par exemple, vous pouvez vérifier si la position légérement à droite d'un ensemble de balles est libre de collision.

Les questions et actions suivantes sont disponibles (veuillez noter qu'elles ont toutes une représentation sous forme d'icône et une couleur de fond différentes ce qui permet de les distinguer plus facilement entre elles).

If a position is collision free (Test si une position n'est pas en collision)
Cette question retourne vrai pour l'instance courante, placée à la position indiquée, si celle-ci ne génére pas de collision avec un objet. Vous pouvez indiquer la position sous forme absolue ou relative. Vous pouvez aussi mentionner si seuls les objets solides ou encore tous les objets doivent être pris en compte. Cette action est habituellement employée pour vérifier si l'instance peut se déplacer à un endroit précis.

If there is a collision at a position (Test s'il y a collision à cette position)
C'est l'action inverse de la précédente. Elle retourne vrai si l'instance courante, placée à une position donnée, entre en collision avec une autre instance ou objet (toujours soit avec des objets solides uniquement ou encore avec tous les objets).

If there is an object at a position (Test si présence d'un objet à une position donnée)
Cette question retourne vrai si l'instance placée à une position donnée, rencontre une instance de l'objet indiqué.

If the number of instances is a value (Test si le nombre d'instances est égal à une certaine valeur)
Vous devez préciser un objet et un nombre. Si le nombre actuel d'instances de cet objet est égal au nombre donné alors la question retourne vrai sinon elle retournera faux. Vous pouvez également effectuer le test si le nombre d'instances est plus petit ou encore plus grand que la valeur fournie. On utilise ces tests afin de savoir si toutes les instances d'un type particulier ne sont plus présentes dans le jeu. Auquel cas, ce sera souvent le moment de terminer le niveau ou le jeu.

With a chance perform next action (Avec une certaine probabilité d'effectuer la prochaine action)
Vous indiquez le nombre souhaité de côtés d'un dé qui sera ensuite lancé. Si le résultat du lancement du dé est 1 alors il sera retourné vrai (true) et la prochaine action sera exécutée. Ceci est utile pour ajouter des actions aléatoires dans votre jeu. Par exemple, à chaque step, il vous est possible de générer une bombe ou un changement de direction, le tout avec une certaine probabilité que l'événement se réalise. Plus le nombre de faces du dé est grand, moins il y aura de chance que cela se réalise. Actuellement, vous pouvez utiliser des nombres réels. Par exemple, si vous paramétrez le nombre de côtés à 1.5, la prochaine exécution sera exécutée deux fois sur trois. Utiliser un nombre inférieur à 1 n'a ici pas de sens (NDT : en effet, mathématiquement parlant, cela reviendrait à dire que l'événement aurait plus de chance de se réaliser que l'occurence observée de l'événement ce qui n'est pas possible).

If the user answers yes to a question (Si l'utilisateur répond oui à une question)
Vous posez une question. Une boîte de dialogue s'affiche avec un bouton yes (oui) et un bouton no (non). Le résultat sera vrai (true) si l'utilisateur a répondu yes (oui).

If an expression is true (Si une expression est vérifiée)
C'est la condition la plus générale mais aussi la plus utilisée. Vous indiquerez ici une expression arbitraire. Si l'expression renvoie la valeur vrai (true) (par exemple si un nombre est supérieur ou égal à 0.5), l'action suivante sera réalisée. Voir ci-dessous pour obtenir plus d'informations sur les expressions.

If a mouse button is pressed (Si un bouton de la souris a été pressé)
Retourne vrai (true) si le bouton de souris indiqué est pressé. On utilise fréquemment ce test dans l'événement step. Vous pouvez vérifier si un bouton de la souris a été pressé et dans l'affirmative, déplacer une instance à la position de la souris (utilisez l'action "Aller à une position donnée" (jump to a given position) avec les valeurs mouse_x et mouse_y).

If instance is aligned with grid (Test si une instance est alignée avec la grille)
Retourne vrai (true) si la position de l'instance tient sur une grille. Vous indiquerez l'espacement horizontal et vertical de la grille. Cela peut être très utile lorsque certaines actions, comme faire un demi-tour, ne sont possibles que si l'instance se trouve dans une position de la grille.

Start of block (Début de bloc)
Indique le début d'un bloc d'actions.

End of block (Fin de bloc)
Indique la fin d'un bloc d'actions.

Else (Sinon)
Après cette action, il y a les instructions suivant la clause else, qui seront exécutées quand le résultat à la question retourne faux (false).

Repeat next action (Répéter la prochaine action)
Cette action est employée pour répéter l'action suivante (ou bloc d'actions) un certain nombre de fois. Vous indiquerez simplement ce nombre.

Exit the current event (Quitter l'événement courant)
Quand cette action est utilisée, aucune autre action de cet événement ne sera désormais exécutée. On l'utilise généralement après une question. Par exemple, lorsqu'une position est libre, il n'est pas nécessaire de faire quelque chose de particulier donc on quitte l'événement. Dans l'exemple donné, les actions suivantes ne seraient exécutées qu'en présence d'une collision.

Si vous souhaitez davantage de contrôle sur le fonctionnement de votre jeu, vous pourrez utiliser le langage de programmation intégré (GML), décrit dans la 4 ème partie de cette documentation. Il vous apportera plus de flexibilité que l'emploi d'actions via l'interface graphique du logiciel. Il est d'utilisation facile mais surtout, il vous permettra l'usage de vos propres variables. Les actions suivantes ont trait à ce langage :

Execute a piece of code (Exécuter du code)
Lorsque vous ajoutez cette action, une fenêtre apparaît à l'écran dans laquelle vous pourrez taper des lignes de code qui seront ultérieurement exécutées. Cela peut être de simples appels de fonction ou encore du code plus complexe. L'utilisation des actions sous forme de code n'est envisageable que pour les petits programmes. Pour les plus gros projets, il est fortement recommandé d'utiliser les scripts qui font l'objet d'une description dans la 2 ème partie de ce document.

Comment (Commentaire)
Utilisez cette action pour ajouter une ligne de commentaires à la liste d'actions. La ligne est affichée en italique. L'ajout de commentaires vous aidera à vous souvenir de ce que doivent faire vos événements. Cette action ne fait rien de particulier mais sachez que c'est tout de même une action. Ainsi, si vous placez l'action après une action conditionnelle, ce sera l'action commentaire qui sera exécutée dans le cas où la condition est vraie (true) (bien qu'elle ne fasse rien du tout).

Set the value of a variable (Fixer la valeur d'une variable)
Il existe de nombreuses variables intégrées dans le jeu. Avec cette action, vous pourrez les modifier. Vous pourrez aussi créer vos propres variables et leur assigner des valeurs. Vous indiquerez le nom de la variable et la nouvelle valeur. Si vous cochez la case Relative, la valeur sera ajoutée à la valeur actuelle de la variable. Veuillez noter que ceci n'est possible que si la variable a déjà eu une valeur qui lui ait été affectée ! Voir ci-dessous pour en savoir davantage sur les variables.

If a variable has a value (Test si une variable a une certaine valeur)
Cette action vous permet de tester la valeur d'une variable particulière. Si la valeur de la variable est égale au nombre indiqué, la question retournera vrai (true). Sinon, elle donnera faux (false). Vous pouvez également tester si la valeur d'une variable est inférieure ou supérieure à une valeur mentionnée. Voir plus bas pour obtenir plus d'informations au sujet des variables. Actuellement, vous pouvez également utiliser cette action pour comparer deux expressions.

Draw the value of a variable (Afficher la valeur d'une variable)
Avec cette action, vous pourrez afficher la valeur d'une variable à un endroit précis de l'écran. Veuillez noter que cette action ne peut être utilisée que dans l'événement d'affichage d'un objet.

Actions de Gestion du Score

Set the score (Donner une valeur au score)
Game Maker comprend un mécanisme interne de gestion des scores. Le score est d'ordinaire affiché dans une fenêtre dédiée à cet usage. Vous pouvez utiliser cette action pour changer le score. Il vous suffira simplement de fournir la nouvelle valeur du score. Souvent, vous souhaiterez incrémenter le score. Dans ce cas, n'oubliez pas de cocher la case Relative.

If score has a value (Test si le score est égal à une certaine valeur)
Avec cette action basée sur une question, vous pouvez vérifier si le score a atteint une valeur particulière. Vous indiquerez la valeur à comparer et si le score doit être égal, inférieur ou supérieur à cette valeur.

Draw the value of score (Afficher le score)
Cette action vous permet d'afficher la valeur actuelle du score à un endroit précis de l'écran. Vous fournirez les positions et le motif devant être placés en face du score. Le score sera affiché dans la police de caractères courante. Cette action ne peut être utilisée que dans l'événement d'affichage d'un objet.

Display the highscore table (Afficher la liste des plus hauts-scores)
Pour chaque jeu, les meilleurs scores sont conservés. Cette action affiche la liste des plus hauts-scores. Si le score actuel figure parmi les scores les plus élevés, le nouveau score sera inséré et le joueur pourra taper son nom. Vous pouvez préciser quelle image de fond doit être utilisée, si la fenêtre doit comporter une bordure, dans quelles couleurs s'afficheront la nouvelle entrée ainsi que les autres entrées du score et quelle police de caractères devra être utilisée.

Clear the highscore table (Effacer la liste des plus hauts-scores)
Cette action efface la liste des meilleurs scores.

Set the number of lives (Paramétrer le nombre de vies)
Game Maker comporte également un système intégré de gestion des vies. Cette action vous permet de modifier le nombre de vies disponibles au début du jeu. Habituellement, la valeur est fixée à 3 au lancement du jeu et augmente ou diminue selon la performance du joueur. Cependant, n'oubliez pas de cocher la case Relative si vous souhaitez pouvoir augmenter ou diminuer le nombre de vies. Si le nombre de vies atteint (ou est plus petit que) 0, un événement "no more lives" (plus de vie) sera généré.

If lives is a value (Test si le nombre de vies a atteint une certaine valeur)
Avec cette action sous forme de question, vous pouvez vérifier si le nombre de vies a atteint une certaine valeur. Vous indiquerez la valeur mais également si le nombre de vies doit être égal, inférieur ou supérieur à cette valeur.

Draw the number of lives (Afficher le nombre de vies)
Cette action vous permet d'afficher le nombre de vies à un endroit précis de l'écran. Vous fournirez les positions et le motif à placer en face du nombre de vies. Le nombre de vies sera affiché dans la police de caractères courante. Cette action ne peut être utilisée que dans l'événement d'affichage d'un objet.

Draw the lives as image (Afficher les vies sous forme d'image)
Plutôt que d'afficher le nombre de vies sous la forme d'un nombre, il peut être plus agréable graphiquement d'utiliser quelques petites images à cet effet. Cette action réalise précisément cela. Vous indiquerez la position et l'image souhaitée. Ainsi, le nombre de vies sera affiché avec des images. Cette action ne peut être utilisée que dans l'événement d'affichage d'un objet.

Set the health (Régler la santé du joueur)
Game Maker comprend un mécanisme interne de gestion de la santé du joueur. Vous pourrez utiliser cette action pour modifier la santé. Une valeur de 100 indique une santé maximale alors que 0 signifie plus de santé du tout. Vous fournirez simplement la nouvelle valeur pour la santé. Souvent, vous désirerez diminuer la santé du joueur. Dans ce cas, n'oubliez pas de cocher la case Relative. Lorsque la santé sera inférieure ou égale à 0, un événement plus de santé apparaîtra.

If health is a value (Test si la santé a atteint une certaine valeur)
Avec cette action sous forme de question, vous pourrez vérifier si la santé du joueur a atteint une valeur particulière. Vous mentionnerez la valeur et si la santé doit être égale, inférieure ou supérieure à cette valeur.

Draw the health bar (Afficher la barre de santé)
Il vous sera possible avec cette action d'afficher le niveau de santé sous forme de barre de santé. Lorsque la santé est de 100, une barre de santé pleine sera affichée. Par contre, si la santé est à 0, la barre sera vide. Vous indiquerez la position et la taille de la barre de santé ainsi que les couleurs de la barre et du fond.

Set the window caption information (Paramétrer les informations de la fenêtre de jeu)
D'ordinaire, le nom de la room ainsi que le score sont affichés dans le titre de la fenêtre de jeu. Cette action vous permettra de changer tout ceci. Vous indiquerez si oui ou non l'on doit afficher le score, les vies ou la santé et le motif pour chacun de ces éléments.

Actions d'Affichage

Draw a sprite image (Affichage d'une image sprite)
Vous indiquerez le sprite, sa position (soit en absolu ou relative à la position de l'instance courante) et les sous-images du sprite (les sous-images sont numérotées à partir de 0). Si vous souhaitez dessiner l'actuelle sous-image, utilisez alors le numéro -1.

Draw a background image (Dessiner une image de fond)
Vous indiquerez l'image de fond, sa position (absolu ou relative) et si l'image doit remplir ou non toute la room à l'aide de tuile (tile).

Draw a text (Afficher du texte)
Vous mentionnerez le texte et sa position. Un symbole # dans le texte sera interprété comme un caractère de saut de ligne (utilisez alors \# pour pouvoir utiliser le symbole #). Vous pourrez ainsi créer du texte tenant sur plusieurs lignes. Si le texte débute par une simple ou double quote, il sera interprété comme une expression. Par exemple, vous pouvez utiliser

'X: ' + string(x)

pour afficher la valeur de la coordonnée x de l'instance (la variable x mémorise la coordonnée actuelle de x. La fonction string() transforme ce nombre en une chaîne puis les deux chaînes sont concatènées).

Draw a text transformed (Affiche un texte avec effet de transformation)
Cette action est similaire à la précédente action mais cette fois, vous pourrez indiquer également un facteur d'échelle horizontale et verticale pour changer la taille du texte ainsi que l'angle de rotation de celui-ci. Cette action n'est disponible que dans la version enregistrée.

Draw a rectangle (Dessine un rectangle)
Vous indiquerez les coordonnées des deux coins opposés du rectangle, soit en absolu ou relatif à la position de l'instance courante.

Draw a horizontal gradient (Dessine un rectangle avec couleurs gradient horizontales)
Cette action dessine aussi un rectangle mais cette fois-ci en utilisant une couleur gradient changeante de la gauche vers la droite. Vous spécifierez le rectangle et les deux couleurs à utiliser. Cette action n'est disponible que dans la version enregistrée.

Draw a vertical gradient (Dessine un rectangle avec couleurs gradient verticales)
Cette action dessine également un rectangle mais utilise une couleur gradient changeante du haut vers le bas. Vous indiquerez le rectangle et les deux couleurs à employer. Cette action n'est disponible que dans la version enregistrée.

Draw an ellipse (Dessine une ellipse)
Cette action dessine une ellipse. Vous mentionnerez les ccordonnées des deux coins opposés de la bordure du rectangle, soit en absolu ou relatif à la position de l'instance courante.

Draw a gradient ellipse (Dessine une ellipse gradient)
De nouveau, une ellipse est affichée mais ici, vous indiquerez une couleur pour le centre et une autre pour le bord. Cette action n'est disponible que dans la version enregistrée.

Draw a line (Dessine une ligne)
Vous mentionnerez les coordonnées des deux points opposés de la ligne, soit en absolu ou relatif à la position de l'instance courante.

Draw an arrow (Dessine une flêche)
Dessine une flêche. Vous indiquerez les coordonnées des deux points opposés de la ligne ainsi que la taille de la flêche.

Set the colors (Choisir les couleurs)
Vous permet de fixer la couleur à utiliser pour dessiner des formes, des lignes et du texte (ceci n'influence pas la façon dont les sprites et les arrière-plans sont affichés).

Change fullscreen mode( Changer le mode d'affichage de l'écran)
Avec cette action, vous pourrez permuter l'affichage soit en mode fenêtré ou plein écran et vice-versa. Vous indiquerez si vous voulez basculer directement en mode plein écran ou si vous souhaitez permuter entre le mode fenêtré ou plein écran.

Take a snapshot image of the game (Effectuer une copie d'écran du jeu)
Cette action vous permet de faire une copie d'écran du jeu qui sera sauvegardée dans un fichier BMP. Vous indiquerez le nom de fichier de sauvegarde de la copie d'écran. Cette action n'est disponible que dans la version enregistrée.

Create an effect (Créer un effet)
Cette action vous permettra de créer très simplement toutes sortes d'effets. Vous spécifierez le type d'effet, par exemple une explosion ou de la fumée, sa position, sa taille, sa couleur et si l'effet doit être visible derrière ou devant les objets. Pour le reste, tout est géré automatiquement (pour la pluie et la neige, la position ne peut être indiquée car de toute façon, la neige ou la pluie tombe toujours du haut de l'écran. Pour obtenir un effet de pluie régulier, vous devrez créer cet effet à chaque step). Cette action n'est disponible que dans la version enregistrée.

Utilisation d'expressions et de variables

x la coordonnée x de l'instance
y la coordonnée y de l'instance
hspeed la vitesse horizontale (en pixels par step)
vspeed la vitesse verticale (en pixels par step)
direction l'actuelle direction du déplacement en degrés (0-360)
speed la vitesse actuelle dans la direction courante
visible indique si un objet est visible (1) ou invisible (0)
image_index cette variable indique quelle sous-image du sprite courant est actuellement affichée. Si vous la changez et réglez la vitesse à 0 (see below), vous afficherez une sous-image fixe.
image_speed cette variable indique la vitesse à laquelle les sous-images sont affichées. La valeur par défaut est de 1. Si vous augmentez cette valeur de 1 alors certaines sous-images seront occultées afin de rendre l'animation plus rapide. Si vous la diminuez de 1 alors l'animation sera plus lente en répétant certaines sous-images.
score la valeur actuelle du score
lives le nombre actuel de vies restantes
health l'actuelle santé (0-100)
mouse_x la position en x de la souris
mouse_y la position en y de la souris

Vous pouvez également vous référer aux valeurs des variables appartenant à d'autres objects, en mettant le nom de l'objet puis un point devant les variables. Ainsi par exemple, si vous souhaitez qu'une balle se déplace à l'endroit où se trouve l'objet coin, vous indiquerez (coin.x , coin.y). Dans le cas d'un événement de collision, vous pouvez mentionner la coordonnée x de l'autre objet en utilisant other.x. Dans les expressions conditionnelles, vous pourrez utiliser des opérateurs de comparaison comme < (smaller than), >, etc.

Dans vos expressions, il est également possible d'employer des fonctions. Par exemple, la fonction random(10) retourne un nombre réel aléatoire inférieur à 10. Ainsi, vous pourrez régler la vitesse ou la direction du mouvement à une valeur aléatoire. Beaucoup d'autres fonctions existent. Elles seront décrites dans la 4 ème partie de cette documentation.

Création de rooms

Les possibilités sont très grandes en ce qui concerne la création de rooms. En plus de pouvoir paramétrer un certain nombre de propriétés et d'ajouter des instances pour les objets, vous pouvez aussi ajouter des décors (backgrounds), définir des vues et ajouter des tuiles (tiles). La plupart de ces options seront abordées ultérieurement. Dans ce chapître, nous nous concentrerons sur les réglages de base, l'ajout d'instances pour les objets et le paramétrage des images pour agrémenter de décor.

Pour créer une room (salle), choisissez Add Room à partir du menu Add. L'écran suivant apparaîtra alors :

En haut de l'écran se trouve la barre d'outils. A l'aide de celle-ci, vous pourrez indiquer la taille des cellules utilisées dans la grille pour l'alignement des objets. Vous pourrez aussi mentionner si oui ou non l'on doit afficher les lignes de la grille et les décors (backgrounds), etc. Il est parfois utile de cacher temporairement certains aspects de la room. Cependant, veuillez bien comprendre que les instances d'objets seront toujours affichées lorsque vous les ajouterez sur la room, et ceci indépendamment du paramétrage de la vue (view). Des boutons existent aussi pour effacer les instances de la room et pour décaler les instances d'un certain nombre de pixels. Utilisez des nombres négatifs pour le décalage des instances vers la gauche ou vers le haut. Cela peut être utile quand par exemple, vous décidez d'agrandir la room (vous pouvez également utiliser cette technique pour placer les instances en dehors de la room, ce qui peut parfois s'avérer très utile). Enfin, il y a le bouton Undo pour annuler la dernière opération effectuée sur la room et le bouton OK pour sauver les changements (cliquez sur la croix en haut à droite pour fermer la fenêtre sans sauvegarder les modifications réalisées).

A gauche vous verrez trois onglets (cinq dans le mode avancé). L'onglet objects sert lorsque vous ajoutez des instances d'objets dans la room. Dans l'onglet settings, vous indiquerez un certain nombre de réglages concernant la room. Dans l'onglet backgrounds, vous pourrez indiquer les images de fonds à afficher dans la room.

Ajout d'instances

Pour ajouter des instances dans la room, vous devrez en premier lieu sélectionner l'onglet objects si toutefois, le contenu de ce dernier n'était pas déjà visible. Ensuite, choisissez l'objet que vous souhaitez ajouter en cliquant sur le petit bouton représentant une icône d'un menu (ou en cliquant à gauche sur la zone de l'image représentant l'objet). L'image de l'objet apparaît à gauche (veuillez noter que si vous changez l'origine du sprite, une croix apparaîtra sur l'image. Ceci indique de quelle manière les instances seront alignées sur la grille). Maintenant, cliquez avec le bouton gauche de la souris dans l'aire de la room visible sur la droite. Une instance de l'objet apparaît. Celle-ci sera positionnée dans l'alignement de la grille. Si vous maintenez pressée la touche <Alt> pendant que vous placez l'instance, cette dernière ne sera pas alignée dans la grille. Si vous maintenez appuyé le bouton de la souris tout en plaçant l'instance dans la room, vous déplacerez l'instance à l'endroit précis souhaité. De plus, si vous maintenez pressée la touche <Shift> tout en maintenant appuyé le bouton de la souris et en déplaçant cette dernière, plusieurs instances seront ajoutées. A l'aide du bouton droit de la souris, vous pourrez supprimer des instances. Ainsi, vous allez pouvoir définir précisément le contenu de la room.

Comme vous l'avez sans doute déjà remarqué, si vous placez une instance par dessus une autre, l'instance originale disparaîtra. D'ordinaire, c'est ce que vous souhaiterez faire mais pas toujours. On peut contourner ceci en décochant la case Delete underlying (Effacer l'image en dessous) située en bas à gauche.

Si vous voulez changer la position d'une instance, maintenez pressée la touche <Ctrl> et cliquez avec le bouton gauche de la souris sur l'instance tout en maintenant appuyé ce bouton. Vous pouvez maintenant déplacer l'instance à sa nouvelle position (utilisez <Alt> pour un positionnement précis).

Si vous maintenez appuyée la touche <Ctrl> tout en cliquant sur une instance avec le bouton droit de la souris, un menu apparaîtra alors où vous pourrez effacer l'objet, indiquer une position précise pour cette instance ou encore placer l'instance d'arrière-plan en avant-plan et vice-versa.

Paramétrage de la room

Chaque room posséde un nom. L'idéal sera de donner un nom significatif et parlant pour vous. La room a aussi un titre. Ce titre est affiché dans l'entête de la fenêtre lorsque le jeu est lancé. Vous pouvez régler la largeur et la hauteur de la room (en pixels). Vous pourrez également fixer la vitesse du jeu. Celle-ci correspond au nombre de steps par seconde. Plus la vitesse sera grande et plus les déplacements seront fluides. Mais il vous sera alors nécessaire de disposer d'un ordinateur assez puissant pour lancer le jeu.

Paramétrer le décor (background)

En haut, vous verrez la couleur du décor. Cliquez dessus pour la modifier. La couleur du fonds ne sera à utiliser que si vous n'employez pas d'image pour couvrir la totalité de la room. Sinon, il vaudra mieux décocher la case Draw background color afin de ne pas gaspiller de temps lors de l'exécution du jeu.

En haut, vous pourrez voir une liste de 8 décors possibles. Vous définirez chacun d'entre eux mais la plupart du temps, vous n'en aurez besoin que d'un seul ou deux tout au plus. Pour définir un décor, sélectionnez le tout d'abord dans la liste puis cochez la case Visible when room starts sinon vous ne pourrez pas le voir dans le jeu. Le nom du décor sera affiché en gras quand il aura toutefois été défini. Maintenant, indiquez une image de fonds à partir du menu. Certains paramétres pourront être changés. Premièrement, vous pourrez mentionner si l'image de fonds doit remplir la room dans le sens horizontal et/ou vertical. Vous pourrez aussi indiquer la position du décor dans la room (ceci a une influence sur la disposition des tuiles). Une autre option est d'élargir le décor. Le décor sera alors mis à l'échelle afin de remplir complétement la room. Le ratio d'aspect de l'image ne sera pas respecté. Enfin, vous pouvez indiquer un scrolling pour le décor en précisant une vitesse horizontale ou verticale (pixels par step). Il est préférable de ne pas utiliser le scrolling pour un décor comprenant une image élargie. Le résultat pourrait être quelque peu surprenant.

Il existe aussi une autre case à cocher nommée Foreground image. Lorsque vous cochez cette case, le décor (background) deviendra un avant-plan qui sera dessiné par devant tous les objets plutôt que derrière. Il est évident qu'une telle image devra être partiellement transparente pour être d'une quelconque utilité.

Distribution de votre jeu

La création d'exécutables autonomes est très facile avec Game Maker. Dans le menu File, vous choisirez l'option Create Executable. Il vous sera demandé un nom pour l'exécutable qui contiendra le jeu. Indiquez un nom, pressez OK et vous obtiendrez un jeu autonome que vous pourrez donner ensuite à qui vous voudrez. Vous pourrez aussi changer l'icône de ce jeu en allant dans Global Game Settings.

Une fois votre jeu autonome créé en utilisant la méthode décrite ci-dessus, vous pourrez donner ce fichier à d'autres personnes ou encore le mettre sur votre site web pour y être téléchargé. Vous êtes totalement libre de distribuer les jeux que vous aurez créés avec Game Maker. Vous avez même la possibilité de les vendre. Ceci suppose néanmoins que les sprites, les images et les sons utilisés peuvent être distribués ou vendus sans enfreindre la loi sur les droits d'auteurs. Veuillez consulter l'accord de licence pour plus d'informations à ce sujet.

Il est généralement utile de compacter votre exécutable, accompagné de sa documention et de son fichier 'readme' (lisez-moi). Sous Windows XP, ceci peut directement être réalisé avec le menu apparaissant lors du clic du bouton droit de la souris. De plus, il existe de nombreux utilitaires de compactage (zip utilities) téléchargeables sur le web. En option, vous pouvez également créer un programme d'installation de votre jeu. De même, de nombreux programmes gratuits de création de packages d'installation peuvent être trouvés sur le web.

Mode avancé

Mode avancé

Lorsque vous lancez Game Maker dans le mode avancé, l'écran suivant apparaît :

Ce mode présente, en plus des fonctions du mode simple, de nouvelles ressources, de nouveaux boutons et articles de menu. Comme nous le verrons dans les chapîtres qui suivent, les ressources supplémentaires possédent des options additionnelles. Nous détaillerons ici les nouveaux articles des menus.

Menu Fichier

• Fusionner deux jeux. Avec cette commande, vous pourrez fusionner toutes les ressources (sprites, sons, objets, rooms, etc) d'un jeu dans l'actuel jeu en cours de développement. Ceci peut être très utile dans le cas où vous souhaiteriez réutiliser des parties de code ou de ressources dans votre jeu (ex: systèmes de menu). Veuillez cependant noter que toutes les ressources, les instances et les tuiles (tiles) se verront affecter un nouvel ID, ce qui pourra poser des problèmes lors de l'utilisation de celles-ci dans des scripts. Il est de votre ressort de vérifier que les ressources des deux fichiers possédent des noms différents. Dans le cas contraire, des problèmes surviendront.
• Préférences. Vous pourrez dans cette section paramétrer certaines préférences de Game Maker. Ces dernières seont automatiquement sauvegardées et mémorisées lors du prochain appel du logiciel. Vous trouverez ci-dessous la liste des possibilités.

Préférences

• Afficher les jeux récemment édités dans le menu fichier. Si coché, les 8 jeux les plus récents seront affichés dans le sous-menu 'recent files' du menu fichier.
• Charger le dernier fichier ouvert au démarrage. Si coché, le dernier fichier ouvert sera automatiquement chargé lors du lancement de Game Maker.
• Conserver des copies de sauvegarde des fichiers. Si coché,le programme effectuera une copie de sauvegarde de votre jeu avec l'extension gb0-gb9. Vous pourrez également ouvrir ces jeux dans Game Maker. Il est fortement recommandé d'opter pour au moins une copie de sauvegarde automatique de votre travail !
• Nombre maximal de sauvegardes. Vous indiquerez ici le nombre de copies de sauvegardes différentes (1-9) qui doivent être faites par le logiciel.
• Afficher la barre de progression lors du chargement et de la sauvegarde des fichiers. Si coché, un indicateur de progression sera affiché lors du chargement et de la sauvegarde du jeu.
• Au démarrage, rechercher et supprimer les anciens fichiers temporaires. Game Maker et les jeux développés grâce à lui, créent des fichiers temporaires. Habituellement, ceux-ci sont automatiquement supprimés mais il arrive parfois qu'ils soient conservés comme par exemple lors du crash d'un jeu. Si cette option est cochée, Game Maker vérifiera si des fichiers de ce type existent et dans l'affirmative, les supprimera au démarrage du jeu.
• Lancer les jeux en mode sécurisé. Si coché, tout jeu créé avec Game Maker et s'exécutant sur votre machine, ne sera pas autorisé à exécuter des programmes externes ou à modifier / effacer des fichiers situés à un endroit différent de l'emplacement du jeu (ceci constitue une sécurité contre les chevaux de Troie bien que le résultat ne soit pas garanti). En cochant cette option, les jeux utilisant des fichiers externes ne fonctionneront pas correctement. Ce paramétre ne fonctionne que lorsque Game Maker est lancé. Si vous lancez le jeu indépendamment de Game Maker, par exemple en tant qu'exécutable autonome, le jeu NE SERA PAS exécuté en mode sécurisé.
• Afficher le point d'origine et de bordure des sprites. Si coché, les points d'origine et de bordure du sprite seront visibles dans l'écran de propriétés du sprite.
• Dans les propriétés de l'objet, afficher les informations des actions. Si coché, lorsque la souris survole l'une des actions de l'écran des propriétés de l'objet, une description de l'action sera affichée.
• A la fermeture, supprimer les instances se trouvant en dehors de la room. Si coché, le programme vous indique que des instances ou des tuiles (tiles) se trouvent en dehors de la room et vous demande s'il faut les supprimer.
• Mémoriser le paramétrage de la room lors de la fermeture de la fenêtre. Si coché, un certain nombre de réglages de la room comme par exemple l'affichage de la grille, l'effacement des objets underlying, etc. sont mémorisés pour être réutilisés lorsque vous éditerez ultérieurement cette room.
• Scripts, code et couleurs. Se référer au chapître sur les scripts pour obtenir davantage d'informations sur ces préférences.
• Editeur d'image. Par défaut, Game Maker utilise un éditeur intégré pour travailler sur les images. Si vous préférez utiliser un autre programme de traitement d'images, vous pourrez spécifier ici le nom de ce programme.
• Editeurs externes de sons. Il vous est possible d'indiquer ici avec quels éditeurs externes vous souhaitez travailler pour les différents types de sons (veuillez noter que Game Maker ne comprend pas en base d'éditeur de sons. Aussi, vous ne pourrez pas éditer les sons si vous n'indiquez pas dans cette option le nom de l'éditeur de sons à utiliser).

Menu Edition

• Ajouter un groupe. Les ressources peuvent être regroupées dans un ou plusieurs groupes. Ceci peut très utile lors de la conception de grands projets de jeux. Par exemple, vous pourrez placer dans un groupe tous les sons d'un objet particulier ou encore regrouper tous les objets utilisés dans un niveau de jeu spécifique. Cette commande crée un nouveau groupe dans le type de ressource actuellement sélectionnée. Il vous sera demandé un nom de groupe. Les groupes peuvent à leur tour contenir d'autres groupes, etc. Comme mentionné ci-dessous, vous pouvez déplacer à la souris (drag) des ressources dans les groupes.
• Chercher une ressource. Cette commande vous permet de taper le nom d'une ressource puis d'obtenir la fenêtre de propriétés correspondante à cette ressource.
• Affichage de l'arborescence des ressources. Développe dans son intégralité l'arborescence des ressources, affichant ainsi toutes les ressources de votre jeu.
• Masquage de l'arborescence des ressources. Masque complétement l'arborescence des ressources, cachant ainsi toutes les ressources.
• Afficher les informations sur les objets. Avec cette commande, vous pourrez obtenir un récapitulatif de tous les objets du jeu.

Ajouter un menu

Menu Scripts

• Importer des scripts. Est utilisé pour importer des fichiers scripts que vous jugez utiles d'utiliser dans votre jeu.
• Exporter des scripts. Est utilisé pour sauvegarder vos scripts dans un fichier, qui pourront être employés dans d'autres programmes. Lorsque vous sélectionnez une ressource script, seul ce script sera sauvé. Quand vous sélectionnez un groupe, tous les scripts du groupe seront sauvegardés. Lorsque vous sélectionnez la ressource racine (root resource) ou un type différent de ressource, tous les scripts seront sauvés. Cette option du menu est uniquement disponible que lorsque vous cliquez avec le bouton droit de la souris sur un script ou un groupe de scripts.
• Afficher les variables internes. Affiche une liste triée des variables internes, comprenant les variables locales et globales de votre jeu.
• Afficher les fonctions internes. Affiche une liste triée des fonctions internes.
• Afficher les constantes. Affiche une liste triée des constantes internes et celles définies dans les options de jeu.
• Afficher les noms de ressource. Affiche une listre triée des noms de toutes les ressources. Vous pouvez cliquer sur un nom de ressource afin d'ouvrir cette dernière pour édition.
• Rechercher dans les scripts. Vous pouvez rechercher une chaîne de caractères dans tous les scripts. Vous pourrez ensuite cliquer sur l'un des éléments trouvés pour éditer le script où se trouve la chaîne.
• Vérifier les noms des ressources. Effectue une vérification des noms de toutes les ressources. Les noms incorrects seront indiqués s'il existe des doublons dans les noms de ressources, ou encore si un nom de ressource posséde le même nom qu'une variable, qu'une fonction ou qu'une constante. Vous pouvez cliquer sur un nom afin de pouvoir éditer une ressource particulière.
• Vérifier tous les scripts. Vérifie les erreurs de tous les scripts. Vous pouvez cliquer sur l'un des noms de script affiché afin de pouvoir l'éditer.

Précisions sur les sprites

Edition de sprites

La fenêtre d'édition des sprites se présente ainsi :

A droite, vous apercevrez les différentes images que comporte le sprite. Veuillez noter que dans Game Maker, toutes les sous-images d'un sprite doivent avoir la même taille. A gauche, vous pourrez voir un aperçu de l'animation du sprite (si vous n'apercevez pas l'animation, cochez la case Show Preview). En dessous de cette animation, vous pourrez changer la vitesse de l'animation ainsi que la couleur de fond du sprite. De cette manière, vous pourrez vous rendre compte du rendu final qu'aura l'animation dans votre jeu (veuillez cependant noter que la vitesse d'animation du sprite n'est valable que pour la prévisualisation. La vitesse réelle de l'animation durant le jeu dépendra de la vitesse de la room).

L'éditeur de sprites comportent de nombreuses commandes pour créer et modifier un sprite. Elles sont toutes accessibles grâce aux menus (pour certaines d'entre elles, il existe cependant des boutons dans la barre d'outils). Quelques commandes sont destinées à travailler sur des images individuelles. Elles nécessitent que vous sélectionnez en premier lieu une sous-image à l'aide de la souris.

Menu Fichier (File menu)

Le menu Fichier (File menu) comporte des commandes permettant le chargement et la sauvegarde des sprites.

• Nouveau (New). Crée un nouveau sprite vierge. Vous devrez indiquer la taille du sprite (souvenez-vous que toutes les images d'un sprite doivent avoir la même taille).
• Création d'un sprite à partir d'un fichier (Create from file). Crée le sprite à partir d'un fichier. La plupart des types de fichiers graphiques existants peuvent être utilisés. Tous ces fichiers créeront un sprite comprenant une seule image, à l'exception des fichiers d'animation GIF qui peuvent comporter plusieurs images. Veuillez noter que la couleur de transparence du sprite est déterminée à partir du pixel se trouvant en bas le plus à gauche et non par la couleur de transparence du fichier GIF. Vous avez la possibilité de choisir plusieurs images en même temps qui seront chargées simultanément dans l'éditeur. Rappelez-vous que ces images doivent avoir toutes la même taille.
• Ajout d'images à partir d'un fichier (Add from file). Ajoute une image (ou des images) à partir d'un fichier graphique dans le sprite courant. Si les images ne présentent pas la même taille, vous pourrez choisir où les placer ou encore de les déformer. Vous pourrez aussi sélectionner plusieurs images en une seule opération qui seront ensuite chargées simultanément. Là encore, les images doivent avoir la même taille.
• Sauvegarder comme image GIF (Save as GIF). Sauve le sprite en tant qu'animation GIF.
• Sauvegarder comme séquence d'images (Save as strip). Sauvegarde le sprite dans le format bitmap, comportant toutes les images du sprite à la queue leu-leu.
• Créer un sprite à partir de séquences d'images (Create from strip). Vous permer de créer un sprite à partir d'une séquence d'images (strip). Référez-vous au chapître suivant pour plus d'informations.
• Ajouter des images à partir d'une séquence d'images (Add from strip). A utiliser si vous souhaitez ajouter des images à partir d'une séquence d'images. Voir chapître suivant.
• Fermer la fenêtre de l'éditeur après sauvegarde (Close saving changes). Ferme la fenêtre de l'éditeur de sprites, après avoir effectué une sauvegarde des changements effectués sur le sprite. Si vous ne souhaitez pas effectuer de sauvegarde des modifications, cliquez sur le bouton de fermeture en haut à droite de la fenêtre.

Menu Edition (Edit menu)

Le menu d'édition (Edit menu) comprend un certain nombre de commandes en rapport avec le sprite actuellement sélectionné. Vous avez la possibilité de couper le sprite dans le presse-papiers, de coller une image provenant du presse-papiers, de vider le sprite courant, de l'effacer ou encore de déplacer les sprites de gauche à droite dans l'ordre de la séquence. Enfin, il existe une commande pour éditer une image particulière à l'aide d'un programme de dessin intégré (voir chapître suivant).

Menu de transformations (Transform menu)

Dans ce menu, vous pourrez effectuer quelques transformations sur les images.

• Miroir horizontal (Mirror horizonta)l. Effectue un effet de miroir horizontal sur les images.
• Retournement vertical (Flip vertical). Effectue un retournement vertical des images.
• Décalage (Shift). Vous pourrez ici décaler les images en indiquant des valeurs horizontale et verticale.
• Rotation (Rotate). Vous pouvez faire tourner les images de 90 degrés, de 180 degrés ou encore d'un certain nombre de degrés souhaité. Dans ce dernier cas, vous pourrez également préciser la qualité désirée. A expérimenter par vous-même pour obtenir les meilleurs résultats.
• Redimensionner le canevas (Resize Canvas). Vous pourrez ici modifier la taille du canevas. Vous indiquerez également où devront être placées les anciennes images sur le nouveau canevas.
• Redimensionner les images (Stretch). Vous pourrez ici redimensionner les images. Vous indiquerez le facteur d'agrandissement et la qualité souhaités.
• Echelle (Scale). Cette commande effectue un agrandissement des images (sans en augmenter la taille réelle cependant !). Vous indiquerez le facteur d'agrandissement, la qualité voulue et la position des images courantes dans la nouvelle échelle.

Menu images (Images menu)

Dans le menu images, vous pourrez effectuer quelques opérations sur les images.

• Décalage des images d'un cran vers la gauche (Cycle left). Décale toutes les images d'un cran vers la gauche. Ceci fera débuter l'animation à un autre point de référence.
• Décalage des images d'un cran vers la droite (Cycle right). Décale toutes les images d'un cran vers la droite.
• Noir et blanc (Black and white). Colorise le sprite en noir et blanc (n'affecte pas la couleur de transparence !).
• Colorisation (Colorize). Vous pouvez ici changer la couleur ou la tonalité (hue) des images. Utilisez l'ascenceur pour choisir les différentes couleurs.
• Colorisation partielle (Colorize Partial). Vous permet de changer la couleur ou nuance (hue) d'une partie des images. Vous pourrez sélectionner l'ancienne couleur et une gamme de couleurs autour d'elle puis indiquer la nouvelle couleur avec laquelle vous remplacerez cette gamme de couleurs. Ceci est utilisé par exemple pour changer uniquement la couleur des maillots (shirts) des joueurs.
• Décalage de la tonalité de l'image (Shift Hue). Ceci constitue une autre façon de modifier la couleur des images. Mais cette fois, les couleurs sont modifiées en utilisant une variation de couleurs ce qui peut donner des effets plutôt intéressants.
• Intensité (Intensity). A utiliser pour changer l'intensité en fournissant des valeurs pour la couleur de saturation et la luminosité des images.
• Inversion (Invert). Inverse les couleurs des images.
• Fading. Il vous sera demandé ici une couleur et une valeur allant de 0 à 256. Les couleurs des images seront ensuite interpolées vers cette couleur.
• Transparence (Transparency). Vous indiquerez ici un niveau de transparence (0 à 256). Ceci est réalisé en rendant un certain nombre de pixels transparents.
• Flou (Blur). En rendant plus flou les images, les couleurs sont mélangées légérement, créant ainsi un effet de déformation de l'image. Plus la valeur sera grande et plus l'effet de déformation sera important.
• Contour (Outline). Crée un contour autour de l'image. Il vous sera demandé outre la couleur de contour si les images courantes doivent être supprimées ou non (ne conservant donc que le contour) ou encore si le contour doit être affiché sur l'image.
• Bordure (Boundary). Similaire à la fonction contour (Outline) mais cette fois-ci, l'affichage ne se fera pas en dehors de l'image mais sur les pixels en bordure de l'image.
• Réduction (Crop). Ceci réduit la taille (en octets) des images de la manière la plus compacte possible. Cela peut être très utile car plus les images sont grosses et plus Game Maker consommera de mémoire vidéo. Il vous sera possible de laisser une petite bordure autour des images afin d'éviter les problèmes de transparence.

Vous devrez expérimenter ces commandes par vous-même afin d'obtenir les sprites souhaités.

Menu animation (Animation menu)

A l'aide de ce menu, vous pourrez créer de nouvelles animations en utilisant l'animation courante. Il y a beaucoup d'options et il vous sera nécessaire d'expérimenter par vous-même afin d'être en mesure de créer les effets désirés. N'oubliez pas que vous pourrez toujours sauvegarder une animation et l'ajouter ultérieurement à l'animation courante. Selon le même principe, il vous sera également possible d'ajouter des images vierges et d'effacer celles que vous ne désirez plus utiliser. Nous allons énoncer ici brièvement les différentes possibilités.

• Fixe le nombre d'images (Set Length). Vous permet de changer la longueur de votre animation. L'animation est répétée autant de fois que nécessaire pour créer le nombre d'images que vous aurez indiqué (normalement, vous souhaiterez indiquer un multiple du nombre actuel d'images).
• Stretch. Cette commande modifie également la longueur de l'animation. Cette fois-ci, les images (frames) sont dupliquées ou supprimées afin d'obtenir un certain nombre d'images constituant l'animation. Ainsi, si vous augmentez le nombre d'images, l'animation sera plus lente. A contrario, si vous diminuez ce nombre, l'animation sera plus rapide.
• Inverser l'animation (Reverse). Comme son nom l'indique, cette fonction inverse le sens de l'animation. Ainsi, cette dernière sera jouée à l'envers.
• Ajout d'images inversées (Add Reverse). Une séquence d'inversion d'images est ajoutée, ce qui doublera le nombre total d'images de l'animation. Ceci peut être très utile afin qu'un objet aille de gauche à droite, change de couleur puis revienne à sa position, etc. Vous souhaiterez parfois supprimer la première image ainsi que celle du milieu qui seront en double dans l'animation créée.
• Ordre de translation (Translation sequence). Vous créerez ici une animation dans laquelle l'image sera légérement dupliquée à chaque étape. Vous indiquerez le nombre d'images et la valeur de déplacement horizontal et vertical.
• Ordre de rotation (Rotation sequence). Vous permet de créer une animation dans laquelle les images subiront un effet de rotation. Vous pourrez choisir une rotation suivant le sens des aiguilles d'une montre ou l'ordre inverse. Indiquez le nombre d'images et l'angle total en degrés (360 correspond à un tour complet) (il vous sera peut être utile de redimensionner le canevas auparavant afin d'être certain que l'image entière restera visible pendant la rotation).
• Colorisation (Colorize). Crée une animation qui transforme l'image en utilisant une couleur particulière.
• Fading vers une couleur (Fade to color). Crée une animation qui applique un effet de fading à l'image en utilisant une certaine couleur.
• Disparition (Disappear). Fait disparaître l'image en utilisant la couleur de transparence du fond de l'image.
• Réduction des images (Shrink). Réduit la taille des images jusqu'à l'infini. Vous pourrez indiquer la direction.
• Grossissement des images (Grow). Agrandit la taille des images jusqu'à l'infini.
• Réduction et écrasement (Flatten). Réduit la taille des images de l'animation en appliquant un effet d'écrasement des images, le tout dans une certaine direction.
• Agrandissement et étirement (Raise). Agrandit les images dans une certaine direction avec un effet d'étirement.
• Superposition (Overlay). Superpose à l'animation courante une autre animation ou une autre image provenant d'un fichier.
• Transformation (Morph). Transforme l'animation courante en une autre animation ou image provenant d'un fichier. Veuillez noter que le morphing donne de meilleurs résultats si les deux animations couvrent la même zone de l'image. Sinon, certains pixels disparaîtront à mi-course alors que d'autres apparaîtront soudainement.

Les deux dernières commandes sont particulièrement puissantes. Par exemple, pour faire exploser un objet, ajoutez un certain nombre de copies de cet objet mais également une certaine quantité d'images vierges. Puis superposez-les avec une animation d'une explosion (soyez certain que le nombre d'images corresponde). Vous pourrez aussi utiliser la fonction de morphing pour créer un explosion. Avec de l'entraînement, vous obtiendrez des sprites spectaculaires.

Les séquences animées

Comme indiqué précédemment, les sprites sont stockés habituellement dans des fichiers GIF ou encore dans des fichiers d'animations (strips). Ces derniers sont en quelque sorte une grosse image bitmap contenant toutes les images les unes à la suite des autres. Le problème vient que la taille de ces images n'est pas mémorisée dans le fichier bitmap. Aussi, de nombreux fichiers d'animations disponibles sur le web enregistrent plusieurs sprites dans un seul et unique fichier. Par exemple, le fichier d'animations ci-dessous comprend quatre animations différentes.

Pour extraire un ou plusieurs sprites de ces fichiers d'animations, vous utiliserez l'option Create from Strip ou Add from Strip du menu File. Après avoir indiqué le fichier image souhaité dans la séquence, la fenêtre suivante s'affichera :

A droite, vous pourrez voir les images (une partie seulement) de la séquence choisie. A gauche, vous pourrez entrer un nombre qui indiquera le nombre de sous-images que vous souhaitez récupérer. Veuillez noter qu'un rectangle (ou plus selon le nombre entré) apparaîtra dans l'image pour indiquer les images sélectionnées. Vous pourrez en outre préciser les paramètres suivants :

• Nombre d'images (Number of images). Ceci correspond au nombre d'images que vous souhaitez utiliser dans la séquence animée.
• Images par colonne (Images per row). Combien d'images souhaitez-vous affichée par colonne ? Par exemple, en affectant la valeur 1 à ce paramètre, vous sélectionnerez une séquence verticale d'images.
• Largeur de l'image (Image width). Largeur des images individuelles en pixels.
• Hauteur des images (Image height). Hauteur des images individuelles en pixels.
• Déplacement horizontal dans les cellules (Horizontal cell offset). Si vous ne désirez pas choisir les images situées en haut et à gauche, vous indiquerez ici le nombre d'images à sauter dans le sens horizontal.
• Déplacement vertical dans les cellules (Vertical cell offset). Vous mentionnerez ici le nombre d'images à sauter dans le sens vertical.
• Déplacement horizontal d'un certain nombre de pixels (Horizontal pixel offset). Parfois, il est nécessaire de laisser de l'espace entre les images et le bord supérieur gauche. Il vous suffira pour cela de mentionner la valeur (en pixels) dans cette zone.
• Déplacement vertical d'un certain nombre de pixels (Vertical pixel offset). Valeur de séparation entre le bord vertical et les images.
• Séparation horizontale (Horizontal separation). Dans certaines séquences d'images, il y a parfois des lignes ou des espaces entre les images. Vous pourrez indiquer ici la valeur horizontale d'espacement entre les images (en pixels).
• Séparation verticale (Vertical separation). Valeur de l'espacement vertical entre les images.

Une fois les images qui vous intéressent sélectionnées, appuyez sur OK pour créer votre sprite. Veuillez cependant ne pas oublier que vous ne serez autorisé à utiliser les images créées par d'autres personnes que si celles-ci vous ont donné leur autorisation écrite ou si les images sont libres de droits (freeware).

Edition des sous-images individuelles

Cet écran affiche l'image au milieu et quelques boutons de dessin dans la partie gauche.Vous pourrez ici effectuer un zoom dans les deux sens, dessiner des pixels, des lignes, des rectangles, du texte, etc. Notez que la couleur dépend du bouton de la souris utilisé (droit ou gauche). Pour certains outils de dessin, vous pourrez régler les propriétés (comme la largeur de la ligne ou encore la visibilité de la bordure). Il existe un bouton spécial pour changer tous les pixels d'une certaine couleur en une autre teinte. Ceci est particulièrement utile pour modifier la couleur du décor qui est utilisée pour la transparence. Dans la barre d'outils, vous apercevrez certains boutons spéciaux pour déplacer les pixels de l'image à une position particulière. Vous aurez la possibilité également d'indiquer si l'on doit afficher la grille lors du zoom de l'image (fonctionne uniquement avec un facteur de zoom de 4 au minimum).

Vous pouvez choisir la zone de l'image de la manière habituelle, c'est à dire en pressant le bouton approprié puis en dessinant un rectangle. Ensuite, vous placerez la souris à l'intérieur de la zone choisie pour la positionner autre part. Normalement, l'aire d'origine sera remplie avec la couleur sélectionnée grâce au bouton gauche de la souris. Si vous déplacez la sélection en maintenant appuyée la touche <Shift>, la zone d'origine ne sera pas affectée par cette couleur. Avec la touche <Shift>, vous pourrez aussi effectuer de multiples copies de l'aire sélectionnée. Si vous employez le bouton droit de la souris pour le déplacement (plutôt que le celui de gauche), la sélection sera interprétée comme une couleur transparente.

L'outil de manipulation de textes nécessite des explications supplémentaires. Pour ajouter du texte, pressez le bouton texte puis cliquez sur l'image. Une fenêtre apparaîtra ensuite dans laquelle vous entrerez le texte souhaité. Utilisez le symbole # pour insérer une nouvelle ligne. Une fois que vous avez appuyé sur OK, le texte sera affiché dans l'image, accompagné d'une boîte tout autour. Vous pourrez déplacer le texte en pressant un bouton de la souris dans la boîte puis en tirant le texte (drag). Vous pouvez modifier le texte en cliquant dans la boîte avec le bouton droit de la souris. L'utilisation du menu Text vous permettra de modifier l'alignement et la police de caractères utillisés.

A droite de l'écran, vous pourrez mentionner les couleurs que vous souhaitez utiliser (une couleur à l'aide du bouton gauche et une autre avec le bouton droit de la souris). Il existe quatre façons de modifier la couleur. En premier lieu, vous pourrez cliquer avec l'un des boutons de la souris (gauche ou droit) pour choisir l'une des 16 couleurs de base. Veuillez noter qu'il existe une boîte de couleur spéciale contenant la couleur du pixel le plus en bas à gauche de l'image qui sera utilisée comme couleur de transparence du sprite si toutefois celui-ci doit être transparent. Vous pouvez utiliser cette couleur pour rendre une partie de votre image transparente. En second lieu, vous pourrez cliquer dans l'image sur la couleur à changer. Vous aurez ici plus de couleurs de disponible. En maintenant pressé le bouton de la souris, vous pourrez voir la couleur que vous avez sélectionnée. En troisième lieu, vous pouvez cliquer à l'aide du bouton gauche de la souris dans les boîtes indiquant la couleur de gauche et droite. Une boîte de dialogue apparaîtra ensuite, vous permettant de choisir la couleur. Enfin, vous pourrez choisir l'outil de de copie de couleur situé à gauche puis cliquer sur un endroit de l'image pour copier à cet emplacement précis la couleur actuellement sélectionnée.

Il y a deux fonctions spéciales. Lorsque vous pressez la touche <Ctrl>, vous pouvez sélectionner une couleur pour dessiner à partir de l'image courante. Lorsque vous maintenez la touche <Shift> tout en dessinant des lignes, vous obtiendrez uniquement des lignes horizontales, verticales ou diagonales. De la même façon, en pressant la touche <Shift> tout en dessinant des ellipses ou des rectangles, vous ne produirez comme figures que des cercles et des carrés.

Dans les menus, vous trouverez les mêmes commandes de modification et de transformation des images que celles proposées par l'éditeur de sprite. A la différence près que cette fois-ci, ces commandes ne s'appliqueront uniquement qu'à l'image courante (si le sprite possède plusieurs images, les commandes modifiant la taille, comme stretch (étirement), ne seront pas disponibles). Il vous est également possible de sauvegarder l'image en tant que fichier bitmap. Il existe aussi deux commandes supplémentaires dans le menu Image :

• Effacer (Clear). Efface l'image avec la couleur de gauche (qui deviendra alors automatiquement la couleur de transparence).
• Remplir de façon graduelle (Gradient fill). Cette commande vous permettra de remplir l'image en utilisant une couleur changeante graduelle (pas très utile pour la réalisation de sprites mais le résultat peut être amusant pour d'autres usages. Utilisable également pour les décors qui utilise également le même programme de dessin).

Veuillez noter que cet éditeur ne comprend pas de routines de dessin très élaborées. Pour obtenir d'autres fonctions, il vous sera nécessaire d'utiliser un programme de dessin plus évolué (ou utiliser simplement le logiciel de dessin fourni avec Windows). Une manière très commode sera d'utiliser le bouton Copy (Copie) pour placer l'image dans le presse-papiers. Ensuite, dans votre logiciel de dessin, faites paste (coller) pour pouvoir le modifier. Modifiez le dessin à votre guise puis copiez-le de nouveau dans le presse-papiers. De retour sous Game Maker, vous pourrez alors recoller l'image que vous aurez modifiée avec le programme de dessin.

Paramétrage avancé des sprites

En premier lieu, nous trouvons les options ayant trait à la vérification des collisions. Lorsque deux instances se touchent, un événement de collision se produit. Les collisions sont vérifiées de la façon suivante. Chaque sprite posséde ce que l'on appelle une boîte de rebord (bounding box). Cette boîte contient la partie non transparente de toutes les sous-images. Lorsque les boîtes de rebord se recouvrent, on vérifie également si deux pixels des sous-images actuelles des deux sprites se recouvrent eux-aussi. Cette seconde opération consomme beaucoup de mémoire et de temps processeur. Aussi, si vous n'êtes pas particulièrement intéressé de vérifier précisément la collision d'un certain sprite, il sera préférable de décocher la case Precise collision checking. Dans ce cas, seule la boîte de rebord du sprite est prise en compte dans la collision. Vous avez la possibilité également de modifier la boîte de rebord du sprite. Ceci est très rarement nécessaire mais il peut vous arriver parfois de vouloir une boîte de rebord plus petite, ce qui aura comme conséquence de ne pas prendre en considération certaines parties du sprite.

Les bords des sprites peuvent paraître parfois quelque peu anguleux. Pour éviter ceci, cochez la case Smooth edges (bords atténués). Dans ce cas, les pixels aux bords du sprite (c'est à dire les pixels qui sont voisins des pixels transparents) seront affichés transparents en partie. Ceci peut les rendre plus jolis (à ne pas utiliser quand les sprites doivent s'assembler pour former de plus grandes formes car dans ce cas, une ligne partiellement transparente apparaîtra entre les sprites). L'effet de ce paramétrage n'est visible que dans le jeu, pas dans l'éditeur !

Lors du jeu, les sprites sont transformés en textures. Les textures sont copiées dans la mémoire vidéo (de la carte graphique) avant de pouvoir être utilisées. Si la case Preload texture est cochée, les textures seont affichées immédiatement lors du chargement du jeu. Ainsi, il n'y aura pas de délai d'attente pendant le jeu. Cependant, si vous avez beaucoup de grands sprites qui ne doivent pas être utilisés au début du jeu, il sera préférable de décocher cette option. Game Maker chargera les textures dans la mémoire vidéo et vice-versa lorsque cela sera nécessaire.

Enfin, vous pouvez indiquer l'origine du sprite. C'est le point du sprite qui indique sa position. Lorsque vous placez une instance à une position particulière, l'origine du sprite est définie à cet endroit. L'emplacement par défaut est le coin gauche en haut du sprite mais parfois, il est plus intéressant d'utiliser le centre ou encore une autre point. Vous pourrez même choisir une origine se situant en dehors du sprite. Vous pouvez aussi fixer l'origine en cliquant dans l'image du sprite (lorsque l'origine est affichée dans l'image).

Précisions sur les Sons et la Musique

A côté des boutons de chargement, de sauvegarde et d'écoute des sons, il existe de nombreux paramétres que nous allons décrire maintenant.

Premièrement, vous pourrez indiquer le genre de son souhaité. Quatre types de sons existent. Les sons normaux sont habituellement utilisés pour créer des effets sur les sons dans des fichiers WAVE (bien qu'ils puissent aussi être utilisés pour les fichiers MIDI). Plusieurs sons normaux peuvent être joués simultanément. Il vous est même possible d'écouter plusieurs copies du même son en simultané. La musique de fond (Background music) est comparable aux sons normaux mais une seule peut être jouée à un moment donné. Ainsi, si vous demandez à jouer un nouveau son comme musique de fond, le son actuellement en cours de lecture sera stoppé. Les fichiers MIDI sont utilisés par défaut comme musique de fond. Le son 3D est un son sur lequel vous pourrez appliquer des effets 3D grâce à des fonctions spéciales. Vous ne les utiliserez uniquement que pour créer des effets sophistiqués sur les sons.

Les fichiers sonores sont joués normalement à l'aide de DirectX. Ceci vous donne de nombreuses possibilités mais se limite aux fichiers WAVE et MIDI. Si vous souhaitez utiliser d'autres types de fichiers, comme les fichiers MP3, vous devrez alors sélectionner l'option pour utiliser Media Player. Cela est encore plus limité que précédemment. Aucun réglage de volume ni effets ne pourront être utilisés et seul un morceau de musique pourra être entendu à la fois. Veuillez noter que les fichiers Midi, lorsqu'ils sont joués à l'aide de Media Player, peuvent paraître différents de ceux joués en tant que musique de fond ou sons normaux. Ceci s'explique par le fait que Media Player utilise le synthétiseur hardware (qui peut varier d'une machine à une autre) alors que dans les autres cas, c'est un programme qui est utilisé pour jouer les sons (ainsi, les sons seront identiques sur toutes les machines). Il est conseillé d'éviter d'utiliser les fichiers MP3 dans vos jeux. Pour ce type de fichier, il est nécessaire de les décompresser ce qui consomme du temps de traitement et peut ralentir le jeu. Le fait que la taille de fichier soit plus petite, ne signifie pas que les sons consomment moins de mémoire. De plus, toutes les machines ne les supportent pas. Votre jeu pourra par conséquent ne pas fonctionner sur toutes les machines.

Deuxièmement, vous pourrez indiquer des effets sonores, comme chorus ou encore echo (uniquement dans la version enregistrée de Game Maker !). Vous pouvez sélectionner plusieurs combinaisons. Vous pourrez écouter immédiatement le résultat de vos effets (en programmant avec le langage GML, il vous sera même possible de modifier les paramètres de ces effets).

Vous indiquerez également le volume par défaut du son mais aussi si le son doit sortir du haut-parleur de gauche ou de celui de droite.

Pour tous les types de sons, vous pourrez mentionner si ces derniers doivent être préchargés ou pas. Lorsqu'un son est joué, il est nécessaire auparavant de le charger dans la mémoire audio. Si vous préchargez le son, ceci sera fait au début du jeu, rendant le son disponible immédiatement pour un usage ultérieur. Sinon, le son sera chargé la première fois qu'il sera utilisé. Cela pourra économiser de la mémoire mais occasionnera un petit délai d'attente lors de la première utilisation de ce son.

Game Maker ne comporte pas d'éditeur de sons intégré. Mais il est possible d'indiquer dans les préférences tous les éditeurs externes que vous souhaitez utiliser pour l'édition des sons. Si vous procédez ainsi, il vous suffira de presser sur le bouton Edit Sound pour éditer le son courant (la fenêtre de Game Maker sera alors cachée pendant l'édition du son puis réapparaîtra lorsque vous fermerez l'éditeur de sons).

Précisions sur les Arrière-plans (Backgrounds)

Dans le mode avancé, l'écran de propriétés des arrière-plans propose un certain nombre d'options avancées.

Les bords des arrière-plans, plus particulièrement lorsque ceux-ci sont transparents, peuvent apparaître quelque peu anguleux. Vous pouvez éviter cela en cochant la case Smooth edges. Les pixels aux bords de l'arrière-plan (c'est à dire ceux voisins des pixels transparents) seront affichés en partie de manière transparente. Cela contribuera à les rendre plus jolis (à ne pas utiliser toutefois quand les sprites doivent s'assembler pour former de plus grandes formes car dans ce cas, une ligne partiellement transparente apparaîtra entre les sprites). L'effet de ce paramétrage n'est visible que dans le jeu, pas dans l'éditeur !

Lors du jeu, les sprites sont transformés en textures. Les textures sont copiées dans la mémoire vidéo (de la carte graphique) avant de pouvoir être utilisées. Si la case Preload texture est cochée, les textures seont affichées immédiatement lors du chargement du jeu. Ainsi, il n'y aura pas de délai d'attente pendant le jeu. Cependant, si vous avez beaucoup de grands sprites qui ne doivent pas être utilisés au début du jeu, il sera préférable de décocher cette option. Game Maker chargera les textures dans la mémoire vidéo et vice-versa lorsque cela sera nécessaire.

Parfois, vous souhaiterez utiliser un arrière-plan constitué d'un jeu de tuiles (tiles) qui sont en fait un ensemble de petites images encapsulées dans une plus grande image. Lors de la création de rooms, vous pourrez ajouter ces sous-images à différents endroits de la room. Ceci est très utile pour créer de ravissants niveaux de jeu. Afin de pouvoir utiliser un arrière-plan en tant que jeu de tuiles, cochez la case Use as tile set. L'écran ressemblera alors à ceci :

Il vous sera possible d'indiquer certains paramètres pour le jeu de tuiles. Notamment, vous pourrez mentionner la largeur et la hauteur de chaque tuile (une seule taille peut être donnée, aussi, vérifiez au préalable que toutes les tuiles présentent la même taille. En cas de tailles différentes, créez deux jeux de tuiles ou davantage). Il est possible également de fournir l'offset où débutera la tuile située la plus à gauche en haut. Enfin, une séparation entre les tuiles (normalement 0 ou 1) peut être mentionnée. Pour plus d'informations sur l'utilisation des tuiles, consultez le chapître sur la création des rooms.

Veuillez prendre connaissance de l'avertissement suivant. Lorsque vous placez des bordures de séparation entre les sprites et utilisez une interpolation entre les pixels (consultez les réglages générales du jeu), des fissures peuvent apparaître entre les tuiles. Afin d'éviter cela, vérifiez que les pixels autour des tuiles correspondent aux pixels juste à l'intérieur des tuiles.

Précisions sur les Objets

Profondeur (Depth)

Objets persistants

Parents

Souvent, les objets présentent un comportement presque identique et ont très peu de différences. Par exemple, un monstre doit pouvoir monter et descendre alors qu'un autre doit se déplacer de gauche à droite. Pour tout le reste, les monstres ont le même comportement. Dans ce cas, presque tous les événements devraient avoir les même actions sauf pour un ou deux événements qui présenteront des actions spécifiques. De nouveau, nous pourrons créer un objet parent d'un autre. Mais dans ce cas précis, nous définirons aussi certains événements pour l'objet enfant. Ces événements "écraseront" les événements de l'objet parent. Ainsi, lorsqu'un événement de l'objet enfant contient des actions, celles-ci seront exécutées à la place de celles de l'événement de l'objet parent. Si vous souhaitez cependant exécuter l'événement parent, vous pourrez le faire en appelant l'événement "inherited" (héritage) en utilisant l'action appropriée.

Une bonne habitude est dans ce cas de créer un objet de base. Cet objet contiendra tous les comporements par défaut mais il ne sera jamais utilisé dans le jeu. Tous les objets actuels auront cet objet de base comme parent. Les objets parents peuvent à leur tour avoir des parents et ainsi de suite (cependant, vous ne pourrez pas créer de cycles). De cette manière, vous pourrez créer une hiérarchie d'objets. Cela est extrémement utile pour structurer votre jeu et il vous est fortement recommandé d'apprendre à maîtriser ce mécanisme.

Il existe également une seconde utilité à employer les objets parents. Ils héritent du comportement de collision pour les autres objets. Utilisons un exemple afin de mieux comprendre. Supposons que vous avez quatre objets différents pour le sol. Quand une balle heurte le sol, elle doit changer de direction. Il vous faut donc mentionner cette action dans l'événement de collision de la balle avec le sol. Parce qu'il y a quatre sols différents, vous devrez placer le code dans les quatres événements différents de collision de la balle. Par contre, si vous créer un objet de base pour le sol et rendez cet objet parent des quatres autres objets pour le sol, il ne vous sera ensuite nécessaire que de préciser l'événement de collision avec ce sol de base. Les autres collisions exécuteront le même événement. Encore une fois, cela vous économisera beaucoup de travail.

Comme déjà mentionné, lorsque vous utilisez un objet parent, celui-ci s'aplique aussi aux descendants. Cela survient quand, dans une action, vous indiquez que cette action doit s'appliquer aux instances d'un certain objet. Cela arrive également quand vous employez l'instruction with() dans le code (voir plus loin). Cela est également vrai quand vous invoquez des fonctions comme instance_position, instance_number, etc. Enfin, cela est aussi valable lorsque vous faîtes référence à des variables d'autres objets. Dans l'exemple plus haut, lorsque vous fixez à 10 la variable ball1.speed, cela s'applique également à ball2, ball3 et ball4.

Masques (Masks)

Information

Précisions sur les Actions

Précisions sur les Actions de Déplacements

Définir un chemin pour toutes les instances (Set a path for the instance)
Avec cette action, vous indiquez que l'instance doit suivre un chemin particulier. Vous déclarez le chemin qui doit être suivi et la vitesse en pixels par step. Lorsque la vitesse est positive, l'instance démarre au début du chemin. Si elle est négative, elle débutera à la fin du chemin. Ensuite, vous préciserez le comportement final, c'est à dire ce qui doit se passer quand la fin du chemin est atteinte. Vous pouvez choisir d'arrêter le déplacement, de redémarrer depuis le début, de relancer à partir de la position courante (qui correspond à la position de fin de chemin), ou encore d'inverser le mouvement. Enfin, vous pouvez indiquer si le chemin doit être absolu, c'est à dire que la position sera indiquée dans le chemin (ceci est utile lorsque vous avez désigné le chemin à un endroit particulier dans la room) ou en relatif, dans ce cas, le point de départ du chemin est placé à la position courante de l'instance (au point de fin quand la vitesse est négative). Consultez le chapître sur les chemins pour avoir plus d'informations.

Stopper le chemin pour l'instance (End the path for the instance)
Action à utiliser pour stopper le chemin de l'instance.

Définir la position du chemin (Set the position on the path)
Avec cette action, vous pourrez changer la position courante de l'instance dans le chemin. Cela devra être une valeur comprise entre 0 et 1 (0=début, 1=fin).

Définir la vitesse du chemin (Set the speed for the path)
Cette action vous permet de modifier la vitesse de l'instance dans le chemin. Une vitesse négative déplacera l'instance en sens inverse le long du chemin. Réglez cette valeur à 0 pour stopper temporairement le déplacement dans le chemin.

Exécuter une étape en direction d'un point (Perform a step towards a point)
Cette action a normalement sa place dans l'événement step afin que l'instance effectue un step en direction d'une position particulière. Si l'instance est déjà à cette position, elle ne se déplacera pas. Vous indiquez la position à atteindre, la vitesse avec laquelle l'on doit se déplacer, ce qui représente la taille du step et ensuite si le déplacement doit s'arrêter en cas de collision avec une instance solide ou encore avec une instance quelconque.

Aller en direction d'un point tout en évitant les objets (Step towards a point avoiding objects)
Ceci est une action de déplacement très puissante. Elle doit être placée dans l'événement step. Comme l'action précédente, elle ordonne à l'instance d'aller à un step situé à une position particulière. Mais cette fois-ci, elle essayera d'éviter les obstacles. Si l'instance rencontre une instance solide (ou toute autre instance), elle changera la direction de déplacement pour éviter de heurter l'instance et la contournera. Le résultat n'est cependant pas guarantie mais dans la plupart des situations, cela devrait effectivement déplacer l'instance vers une direction donnée. Pour les cas plus compliqués, il existe des fonctions de gestion des déplacements. Vous entrez la position à atteindre, la vitesse de déplacement, c'est à dire la taille du step et indiquez si le déplacement doit éviter les instances de type solide ou encore toutes les instances.

Précisions sur les Actions Principales

Définir une ligne de temps (Set a time line)
(Uniquement disponible dans le mode avancé). Avec cette action, vous définirez la ligne de temps particulière d'une instance d'un objet. Vous mentionnerez la ligne de temps et la position de départ (0 correspond au début). Vous pourrez également utiliser cette action pour stopper une ligne de temps en indiquant No Time Line (aucune ligne de temps) comme valeur.

Définir la position de la ligne de temps (Set the time line position)
(Uniquement disponible dans le mode avancé). Cette action vous permet de changer la position de la ligne de temps courante (en absolu ou en relatif). Ceci peut être utilisé pour sauter certaines parties de la ligne de temps ou encore répéter d'autres parties. Par exemple, si vous souhaitez créer une ligne de temps qui boucle, à la fin de la ligne de temps, ajoutez cette action pour régler de nouveau la position à 0. Vous pouvez aussi l'utiliser pour attendre que quelque chose de particulier se produise. Il suffit d'ajouter une action de test et, dans le cas où le résultat est faux, affectez en relatif la valeur -1 à la position de la ligne de temps.

Afficher une vidéo (Show a video)
Cette action vous permet de lire un fichier vidéo ou un film. Vous indiquez le nom du fichier et si la vidéo doit être affichée en plein écran ou en mode fenêtré. Vous devrez vérifier auparavant que le fichier vidéo existe. Vous pourrez soit distribuer la vidéo avec le jeu ou soit la mettre dans un fichier de données puis l'exporter.

Remplacer un sprite à partir d'un fichier (Replace a sprite from a file)
On utilise cette action pour remplacer un sprite avec le contenu d'un fichier. Vous indiquerez le sprite à remplacer, le nom du fichier (.bmp, .jpg, or .gif) et le nombre de sous-images du sprite quand il sera chargé à partir du fichier BMP ou JPG. Pour un fichier GIF, le nombre de sous-images est calculé automatiquement en fonction du nombre de sous-images contenues dans le fichier GIF. Les autres paramètres du sprite, comme par exemple son éventuelle transparence, ne seront pas modifiés. Vous pouvez utiliser cette action pour éviter de stocker tous les sprites dans le programme. Par exemple, au début d'un niveau, vous pourrez remplacer les sprites par ceux de l'actuel personnage que vous souhaitez utiliser. NE PAS changer un sprite en cours d'utilisation par une instance de la room. Cela pourrait donner des effets indésirables avec les collisions. Cette action est uniquement disponible dans la version enregistrée.

Remplacer un son à partir d'un fichier (Replace a sound from a file)
Avec cette action, il vous sera possible de remplacer un son par le contenu d'un fichier (.wav, .mid, or .mp3). Vous indiquerez le son et le nom du fichier. Cela vous permettra d'éviter de stocker tous les sons dans le jeu lui-même. Par exemple, vous pourrez utiliser différents morceaux de musique d'arrière-plans et choisir celui que vous désirez jouer. NE PAS changer un son lorsque celui-ci est en train d'être joué. Cette action est uniquement disponible dans la version enregistrée.

Remplacer un décor à partir d'un fichier (Replace a background from a file)
Cette action vous autorisera à remplacer un arrière-plan par celui contenu dans un fichier (.bmp, or .jpg). Vous indiquerez l'arrière-plan ainsi que le nom du fichier. De même, ceci vous évitera de stocker tous les décors dans le jeu lui-même. NE PAS changer un décor si ce dernier est encore visible. Cette action est uniquement disponible dans la version enregistrée.

Précisions sur les Actions de Contrôles

Exécuter un script (Execute a script)
Vous pouvez, grâce à cette action, exécuter un script que vous aurez ajouté dans votre jeu. Vous indiquerez le nom du script ainsi que 5 arguments au maximum à passer en paramétre au script.

Invoquer l'événement parent (Call the inherited event)
Cette action n'est à utiliser que si l'objet posséde un objet parent. Elle invoque (=appelle) l'événement correspondant de l'objet parent.

Précisions sur les Actions d'Affichage

Choisir une police pour l'affichage de texte (Set a font for drawing text)
Vous pouvez choisir une police de caractères qui sera ensuite utilisée pour afficher le texte. Cela doit être l'une des fontes de caractères appartenant aux ressources que vous aurez définies au préalable. Si vous sélectionnez No Font (pas de police), la police Arial 12 points sera utilisée.

Les Actions concernant les Particules

Les systèmes de particule sont utilisés pour créer des effets spéciaux. Les particules sont constituées de petits éléments (représentés par un pixel ou encore une petite forme). Ces particules se déplacent selon des règles prédéfinies et peuvent changer de couleur lors de leurs déplacements. De telles particules sont employées afin de créer des feux d'artifices, des flammes, de la pluie, de la neige, des champs d'étoiles, des débris en vol, etc.

Game Maker contient un système de particules complet auquel on accéde grâce à des fonctions (NDT : via le langage GML). Un système de particules plus limité est néanmoins accessible avec les actions décrites ci-dessous.

Un système de particules peut traiter de particules de différents types. Après avoir créé le système de particules, la première chose à faire est d'indiquer les types de particule souhaités. Grâce aux actions ci-dessous, vous pourrez spécifier jusqu'à 16 types de particules. Chaque type posséde une forme, une taille, une couleur de départ et d'arrivée. La couleur varie lentement à partir de la couleur de départ jusqu'à la couleur d'arrivée. Les particules se caractérisent par la notion de durée de vie limitée. Vous préciserez dans le type la durée de vie minimale et maximale des particules. Les particules ont aussi une vitesse et une direction. Enfin, la gravité et la friction s'appliquent aux particules.

Après avoir indiqué les types de particule, vous devrez les placer dans la room. Vous pourrez soit générer un certain nombre de particules d'un type particulier à un endroit ou encore créer un flux constant de particules. Les particules apparaissent sous la forme d'émetteurs. Le système de particule peut disposer d'un maximum de 8 émetteurs fonctionnant simultanément. Aussi, après avoir créé les types de particule, vous devrez créer les émetteurs et leur indiquer de générer ou de créer des flux de particules.

Vous trouverez ici la liste complète des actions disponibles. Le mieux sera d'expérimenter par vous-même afin d'obtenir les effets désirés.

Créer le système de particule (Create the particle system)
Cette action crée le système de particule. Ceci doit être effectué afin de permettre ensuite l'utilisation des autres actions. Il ne vous sera nécessaire de le faire qu'une seule fois. Vous pourrez indiquer la profondeur à laquelle les particules seront affichées ou dessinées. Si vous utilisez une grande profondeur positive, les particules apparaîtront derrière les instances. Si vous utilisez une profondeur négative, elles apparaîtront devant les instances.

Détruire le système de particule (Destroy the particle system)
Cette action détruit le système de particule, libérant toute la mémoire utilisée. N'oubliez pas d'exécuter cette action (par exemple lorsque vous changez de room) car les systèmes de particule consomment beaucoup de mémoire.

Effacer toutes les particules du système (Clear all particles in the system)
Cette action supprime toutes les particules actuellement visibles. Cela n'arrête pas toutefois les émetteurs, aussi vous pourrez créer de nouvelles particules si vous avez des émetteurs de flux (voir ci-dessous).

Créer un type de particule (Create a type of particle)
Avec cette action, vous créerez un type de particule. Vous pourrez choisir l'un des 16 types disponibles. Pour le type de particule souhaité, vous indiquerez sa forme ou bien le sprite à utiliser. Si vous indiquez un sprite, c'est le sprite qui sera utilisé. Si vous paramétrez le sprite à la valeur no sprite (aucun sprite), la forme sera alors utilisée. Il existe un certain nombre de formes intéressantes déjà intégrées. Vous indiquerez également la taille minimale et maximale (lorsque la particule apparaîtra, une valeur aléatoire comprise entre ces valeurs sera utilisée). Enfin, vous préciserez l'incrément de taille à appliquer à chaque step. Pour diminuer la valeur, indiquez une valeur négative. Veuillez noter que seul un type de particule sera créé et non pas une particule actuelle. Pour cela, vous aurez besoin d'émetteurs (voir ci-dessous).

Choisir une couleur pour un type de particule (Set the color for a particle type)
Une particule peut avoir une couleur (par défaut, la couleur est le blanc). Avec cette action, vous pourrez fixer la couleur à utiliser pour un type particulier. Vous devrez indiquer le type de particule pour lequel la couleur doit être définie. Ensuite, vous mentionnerez comment la couleur doit être appliquée. Soit une couleur aléatoire sera choisie parmi deux couleurs données ou bien la couleur débutera avec la première couleur puis graduellement, et ce durant la durée de vie de la particule, changera vers la seconde couleur. Les deux couleurs doivent être données. Enfin, vous pourrez indiquer la transparence alpha. Vous spécifierez la transparence au moment de la création de la particule et lorsque celle-ci sera détruite. La transparence variera lentement entre ces valeurs. Il est conseillé habituellement de diminuer la valeur alpha à une valeur au delà de la durée de vie de la particule.

Fixer la durée de vie pour un type de particule (Set the life time for a particle type)
Une particule existe durant un nombre limité de steps. Elles disparaît ensuite. Avec cette action, vous réglerez la durée de vie d'un type de particule. Vous donnerez deux valeurs limites et la durée de vie actuelle sera déterminée aléatoirement entre ces deux limites.

Régler le déplacement pour un type de particule (Set the motion for a particle type)
Avec cette action, vous réglerez la vitesse et la direction du mouvement pour un type de particule. De nouveau, vous préciserez les deux valeurs limites. La valeur actuelle sera choisie aléatoirement entre ces deux valeurs. Par exemple, pour qu'une particule se déplace dans une direction aléatoire, indiquez 0 et 360 comme limites pour la direction. Vous avez aussi la possibilité de mentionner une friction. Cette valeur sera soustraite de la vitesse à chaque step jusqu'à ce que cette dernière atteigne 0 (vous pouvez accélérer la vitesse d'une particule en utilisant une friction négative).

Fixer la gravité d'un type de particule (Set the gravity of a particle type)
Avec cette action, vous pourrez indiquer la valeur de la gravité ainsi que sa direction pour un type particulier de particule. 270 correspond vers le bas.

Créer des particules secondaires (Create secondary particles)
Ceci est un peu plus compliqué. Les particules peuvent créer d'autres particules pendant leur durée de vie et lorsqu'elles meurent. Avec cette action, vous pourrez préciser tout cela. Vous pourrez définir le type et le nombre de particules à créer à chaque step durant la durée de vie et pourrez indiquer également le type et le nombre de particules à créer lors de la mort de cette dernière. Soyez cependant très prudent avec cette action. Vous pourriez facilement créer un trop grand nombre de particules de cette manière, ce qui conduirait à ralentir considérablement le système. Pour les nombres, vous pouvez utiliser une valeur négative. Une valeur x négative signifiera qu'à chaque step, une particule sera créée avec une chance de -1/x. Ainsi, par exemple, si vous souhaitez générer une particule secondaire tous les 4 steps, utilisez une valeur de -4. Les particules secondaires sont très utiles pour créer des effets comme des jets ou encore des explosions de particules.

Créer un émetteur de particule (Create a particle emitter)
Cette action crée un émetteur de particule. Les particules sont générées par des émetteurs. Vous pouvez disposer de 8 émetteurs au maximum. Choisissez l'émetteur et indiquez la forme de ce dernier ainsi que sa taille et sa position (dans la boîte de dialogue).

Détruire un émetteur (Destroy an emitter)
Cette action détruit l'émetteur indiqué. Veuillez noter que les particules existantes qui appartiennent à cet émetteur ne seront pas supprimées.

Générer un nombre de particules à partir d'un émetteur (Burst a number of particles from an emitter)
Même si vous avez défini un type de particule et un émetteur, il n'y aura pas encore de particules. Vous devrez aussi indiquer à l'émetteur de générer les particules. Avec cette action, vous préciserez à un émetteur particulier de créer un nombre donné de particules d'un certain type. Toutes ces particules ne seront générées qu'une seule fois. Pour le nombre, vous pouvez également utiliser une valeur négative. Une valeur x négative indiquera que la particule sera créée avec une chance de -1/x. Ainsi, par exemple, si vous souhaitez générer une particule avec un pourcentage de chance de 25, utilisez une valeur de -4.

Créer des jets de particules à partir d'un émetteur (Stream particles from an emitter)
Avec cette action, vous pourrez indiquer à un émetteur particulier de générer un nombre donné de particules d'un certain type. A chaque step, un certain nombre de particules sera généré, créant un jet continu de particules. L'émetteur continuera de créer des filets de particules jusqu'à ce que vous le détruisiez par vous-même ou que vous lui indiquiez de générer 0 particule. Pour le nombre, vous pouvez aussi utiliser une valeur négative. Une valeur x négative signifiera qu'à chaque step, une particule sera créée avec une chance de -1/x. Par exemple, si vous désirez générer une particule tous les 4 steps, utilisez une valeur de -4.

Les Actions Complémentaires

A partir de l'onglet Extra, vous pouvez accéder à des actions concernant la gestion de CD. Ces actions sont uniquement disponibles dans la version enregistrée de Game Maker.

Lire un CD musical (Play a CD)
Cette action vous permet de jouer les pistes d'un CD placé dans le lecteur utilisé par défaut. Vous indiquerez les pistes de début et de fin.

Arrêter la lecture du CD (Stop the CD)
Stoppe la lecture du CD.

Mets en pause le CD (Pause the CD)
Effectue une pause de la lecture du CD.

Reprendre la lecture du CD (Resume the CD)
Reprend la lecture du CD actuellement en pause.

Tester si un CD est présent dans le lecteur (If a CD exists in the drive)
En présence d'un CD dans le lecteur utilisé par défaut, l'action suivant ce test sera exécutée.

Tester si le CD est en cours de lecture (If the CD is playing)
Si un CD est en cours de lecture dans le lecteur par défaut alors l'action qui suit ce test sera exécutée.

Enfin, il existe deux actions supplémentaires pouvant être utiles dans certains jeux.

Remplacer le curseur de la souris (Set the mouse cursor)
Vous utiliserez cette action pour remplacer le curseur de la souris de la fenêtre par un sprite. Vous indiquerez le sprite à utiliser et si le curseur de la souris de la fenêtre doit être affiché ou non. Le sprite peut être animé. Veuillez noter que le sprite ne sera affiché que dans la room et non pas en dehors de celle-ci.

Ouvrir une page web dans un navigateur (Open a webpage in a browser) Vous pouvez indiquer une adresse web avec cette action. Cette page web sera alors ouverte à l'aide du navigateur utilisé par défaut sur la machine (on peut également utiliser cette action pour ouvrir d'autres documents). Cette action ne fonctionne pas dans le mode sécurisé.

Précisions sur les Rooms

Comme vous pouvez le voir, de nouveaux boutons apparaissent dans la barre d'outils. Il y a des boutons pour trier les instances horizontalement ou verticalement. Cela est utile quand les instance se chevauchent partiellement (lorsque vous ajoutez des tuiles, ces boutons et les autres agissent sur les tuiles plutôt que sur les instances). Il existe aussi des boutons pour verrouiller ou déverrouiller toutes les instances. Les instances verrouillées ne peuvent être déplacées ou effacées. Cela vous évitera de supprimer accidentellement des instances. A l'aide du menu accessible avec le bouton droit de la souris (hold <Ctrl> puis clic droit sur une instance), vous pourrez également verrouiller/déverrouiller des instances individuelles.

Enfin, vous pouvez indiquer si vous souhaitez utiliser une grille isométrique. Cela peut être très utile lors de la création de jeux utilisant des formes isométriques. Les lignes de la grille sont maintenant dessinées en diagonale. De plus, la rupture des instances est différente (cela fonctionne mieux quand l'origine de l'instance se situe en haut dans le coin gauche qui est l'option proposée par défaut).

Apparaissent également deux nouvels onglets que nous détaillerons ultérieurement.

Paramétrage avancé

La seconde caractéristique a trait au bouton Creation code (création de code). Vous pourrez ici taper du code en GML (Game Maker Language -> voir plus loin) qui sera exécuté lors de la création de la room. Cela peut s'avérer utile pour affecter des valeurs à certaines variables de la room, pour créer de nouvelles instances, etc. Il est important de bien comprendre précisément ce qui se passe lorsque vous appelez une room dans le jeu.

• En premier lieu, dans la room courante (si toutefois il y en a plusieurs), toutes les instances reçoivent un signal d'événement de fin de room. Ensuite, les instances non-persistantes sont enlevées (aucun événement de destruction n'est généré ici !).
• Ensuite, dans la nouvelle room, les instances persistantes de la précédente room sont ajoutées.
• Toutes les nouvelles instances sont créées et leurs événements de création sont exécutés (si cependant la room est non persistante ou n'a pas été visitée auparavant).
• Si c'est la première room du jeu et pour toutes les instances, l'événement 'game-start' (début de jeu) est généré.
• Puis, le code de création de la room est exécuté.
• Enfin, toutes les instances reçoivent le signal d'événement 'room-start' (début de room).

Ainsi, par exemple, les événements 'room-start' peuvent utiliser des variables initialisées par le code de création de la room et dans ce code, vous pourrez référencer les instances (aussi bien les nouvelles que celles persistantes) de la room.

Il existe aussi une option plus évoluée. Dans le menu pop-up qui apparaît lors d'un clic droit sur une instance tout en pressant la touche <Ctrl> , vous pourrez également indiquer du code de création pour une instance spécifique. Ce code est exécuté lorsque la room est affichée, juste avant que l'événement de création de l'instance ne soit exécuté. Ceci est très utile par exemple pour régler certains paramètres propres à une instance.

Ajout de tuiles

Une façon fréquemment utilisée dans de nombreux jeux, est que les murs et les autres objets statiques sont actuellement dessinés sur le décor (ou arrière-plan). Mais vous vous demandez sans doute comment le jeu peut-il savoir si un objet frappe un mur s'il est lui-même dessiné sur l'arrière-plan ? L'astuce est la suivante : vous créerez uniquement un seul objet mur dans votre jeu. Il devra avoir une dimension correcte mais il ne devra pas forcément être joli. Lors de la création de la room, placez cet objet aux endroits où il doit y avoir un mur. Puis, intervient l'astuce qui consiste à rendre cet objet invisible. Ainsi, le joueur ne verra pas les objets de type mur lors du jeu. Bien au contraire, il apercevra un superbe arrière-plan. Mais les objets représentant les murs seront bien présents et les autres objets du jeu réagiront lors d'une collision avec ces objets.

Cette technique peut être utilisée pour les objets ne changeant pas de forme ou de position (vous ne pourrez pas employer cette astuce si l'objet doit être animé). Pour les jeux de plateformes, vous aurez certainement juste besoin d'un objet pour le sol et d'un autre pour le mur, mais vous devrez sans doute réaliser des arrière-plans plus travaillés graphiquement si vous voulez que votre jeu puisse permettre au joueur de marcher sur l'herbe, grimper à des branches d'arbres, etc.

Pour ajouter des tuiles dans votre room, vous aurez besoin d'ajouter une ressource background dans votre jeu qui contiendra toutes les tuiles (tiles). Si vous souhaitez avoir des tuiles partiellement transparentes, soyez certain que l'image d'arrière-plan est transparente. Quand vous ajoutez la ressource background, indiquez qu'elle doit être utilisée comme jeu de tuiles (set of tiles). Ensuite, précisez la taille de chacune des tuiles et s'il doit y avoir une room entre les tuiles, comme mentionné dans le chapître sur les ressources de type background.

Maintenant, lors de la création de votre room, cliquez sur l'onglet tiles. L'écran suivant apparaîtra (vous pourrez constater que nous avons déjà ajouté quelques tuiles dans la room).

En haut à gauche, nous apercevons le jeu de tuiles actuellement utilisé. Pour sélectionner le jeu complet, cliquez sur le bouton du menu en dessous puis choisissez l'image d'arrière-plan souhaitée.

Vous pouvez désormais ajouter des tuiles en sélectionnant la tuile désirée en haut à gauche, puis en cliquant à l'endroit voulu dans la room située à droite. C'est le même principe utilisé pour ajouter des instances. Les tuiles 'Underlying' sont supprimées sauf si vous avez décoché la case Delete underlying. Vous pouvez utiliser le bouton droit pour effacer des tuiles. Maintenir la touche <Shift> pour ajouter plusieurs tuiles en même temps. De même, pressez la touche <Ctrl> pour placer les tuiles à un nouvel endroit de la room. La touche <Alt> évitera de créer une rupture avec la grille. Egalement, il y a un menu pop-up si vous maintenez pressée la touche <Ctrl> puis si vous cliquez sur une tuile avec le bouton droit de la souris. Les boutons de la barre d'outils effaceront ou décaleront toutes les tuiles, trieront les tuiles ou encore les verrouilleront / déverrouilleront (actuellement, cela ne fonctionne que sur la couche (layer) courante -> voir plus bas).

Dans certaines situations, vous désirerez mettre une partie de l'arrière-plan dans la room qui ne correspondra pas exactement à la taille d'une tuile ou comportera plusieurs tuiles. On peut faire cela de la manière suivante. Dans l'image du haut à gauche, pressez le bouton gauche de la souris tout en maintenant appuyée la touche <Alt>. Maintenant, vous pourrez déplacer avec la souris une aire que vous placerez dans la room de la même façon que pour les tuiles. Pour sélectionner plusieurs tuiles, maintenir la touche <Shift>. Veuillez prendre note que cela ne fonctionnera correctement que s'il n'y a pas de séparation entre les tuiles. Si vous souhaitez choisir une aire qui est un multiple de la taille de la grille de la room, maintenez pressée la touche <Ctrl> plutôt que la touche <Shift> (notez que vous pouvez actuellement changer la touche pressée durant le déplacement à la souris. Cela pourra parfois vous être utile).

Les tuiles peuvent être placées dans des couches (layers) à différentes profondeurs. En bas, vous verrez la profondeur courante. Par défaut, elle est de 1000000 ce qui est normalement derrière toutes les instances. Autrement dit, les instances se déplaceront devant les tuiles. Vous pouvez employer le bouton Add pour ajouter de nouvelles couches de tuiles, avec une profondeur différente pour chacune d'entre elles. Les profondeurs négatives sont utilisées pour mettre des tuiles devant les instances. Si vous donnez également aux objets différentes profondeurs, vous pourrez ainsi les placer entre différentes couches de tuiles. Si vous pressez Delete, vous effacerez une couche de tuiles en plus de toutes ses tuiles (il doit toujours exister au moins une couche). Si vous pressez Change, vous pourrez modifier la profondeur d'une couche de tuiles. Si vous donnez à la couche la même profondeur qu'une autre couche, les couches seront fusionnées.

L'utilisation de tuiles est une fonctionnalité puissante qui devrait être employée le plus souvent possible. C'est beaucoup plus rapide que d'utiliser des objets et de plus, les images ne sont stockées en mémoire qu'une seule et unique fois. De cette manière, vous pourrez utiliser de grandes rooms avec tuiles tout en consommant très peu de mémoire.

Vues

Si vous cliquez sur l'onglet views, les informations suivantes seront affichées :

En haut, vous apercevrez une case nommée Enable the use of Views (Permettre l'usage des vues). Vous devrez cocher cette case afin de pouvoir utiliser les vues. En dessous, vous verrez la liste des huit vues qu'il est possible de définir. En dessous de cette liste se trouvent les informations sur les vues. En premier lieu, vous indiquerez si la vue doit être visible au lancement de la room. Soyez sûr qu'au moins une vue soit visible. Les vues visibles apparaissent en gras.

Une vue est définie par une zone rectangulaire dans la room. C'est l'aire de jeu qui doit être affichée dans la vue. Vous préciserez la position du coin supérieur gauche et la largeur ainsi que la hauteur de cette zone. Puis, vous indiquerez à quel endroit l'aire doit être affichée dans la fenêtre à l'écran. C'est ce que l'on appelle le (view)port. De nouveau, vous mentionnerez la position du coin supérieur gauche ainsi que la taille. Si vous avez une vue simple, la position sera certainement (0,0). Veuillez noter que la taille du port peut très bien être différente de la taille de la vue. Dans ce cas, la vue sera mise à l'échelle pour tenir dans le port (dans un programme GML, il est aussi possible de faire pivoter une vue). Les ports peuvent se chevaucher. Dans ce cas, ils seront affichés dans l'ordre indiqué en haut de chacun d'entre eux.

Comme mentionné plus haut, vous souhaiterez très souvent que la vue suive un objet bien précis. Vous pourrez mentionner cet objet en bas. S'il existe plusieurs instances de l'objet, seul la première sera suivie par la vue (dans un programme en GML, il vous sera possible de demander de suivre une instance particulière). Normalement, le personnage devrait pouvoir marcher un peu sans que la vue ne change. La vue ne changera que lorsque le personnage atteindra les bords de la vue. Vous pourrez indiquer la taille de la bordure devant rester visible autour de l'objet. Enfin, vous pourrez restreindre la vitesse à laquelle la vue doit changer. Cela signifie effectivement que le personnage pourra sortir de l'écran mais cette manière de faire pourra contribuer à améliorer le gameplay du jeu. Utilisez la valeur -1 si vous souhaitez que la vue change instantanément.

Les fontes ou polices de caractères

Pour ajouter une ressource font dans votre jeu, utilisez l'option Add Font du menu Add ou encore utilisez le bouton correspondant dans la barre d'outils. L'écran suivant apparaîtra alors.

Comme d'habitude, vous devrez mentionner un nom pour la ressource de fontes. Ensuite, vous pourrez choisir un nom pour la police de caractères. De plus, vous pourrez indiquer sa taille ainsi que si elle doit être affichée en gras et/ou en italique. Soyez conscient que les grandes polices de caractères consomment beaucoup de mémoire. Aussi, il est recommandé de ne pas utiliser de polices avec un pas supérieur à 32 (il est néanmoins possible d'appliquer une échelle sur les fontes de caractères pendant le fonctionnement du jeu). Un exemple de la fonte indiquée est affiché en bas.

Une fonte comprend généralement 256 caractères, numérotés de 0 à 255. Mais en général, vous utiliserez uniquement une infime partie de ceux-ci. Par défaut, dans une fonte, seuls les caractères allant de 32 à 127 sont sauvegardés dans la fonte. Plus il y aura de caractères et plus vous consommerez de mémoire. Vous pourrez modifier la plage de caractères utilisés. Pour voir l'index de chacun des caractères, vous utiliserez la table des caractères que l'on trouve dans le menu Démarrer de Windows, rubrique Accessoires/outils système. Des plages standards peuvent être indiquées à l'aide des boutons : la plage Normale allant de 32 à 127 tandis que la plage All s'étend de 0 à 255, la plage Digits ne contient que des chiffres, et la plage Letters qui comprend quant à elle les lettres majuscules et minuscules. D'autres plages peuvent être utilisées en tapant les premiers et derniers caractères de l'index. Si un caractère manque dans la plage, il sera remplacé par un espace.

Habituellement, vous devriez disposer d'une grande quantité de fontes différentes déjà installées sur votre ordinateur et de plus, il existe des sites web où vous pourrez télécharger des centaines de polices supplémentaires. Le problème est que si vous utilisez ces polices dans votre jeu et que vous donniez ce dernier à une autre personne, il y aura de forte chance que cette autre personne ne posséde pas les mêmes fontes installées sur son ordinateur. Afin d'éviter cette situation, Game Maker intégre toutes les fontes que vous utilisez dans le fichier contenant le jeu mais cela est vrai seulement que dans la version exécutable autonome du jeu. Aussi, si vous donnez à une personne la version exécutable de votre jeu, il ne sera donc pas nécessaire de fournir également les fichiers contenant les polices de caractères. Par contre, si vous donnez la version source éditable de votre jeu et que vous utilisez des fontes non standard, il sera préférable de donner à cette personne les fichiers des polices de caractères utilisées.

Les Chemins

Définition de chemins (Defining paths)

En haut à gauche de l'écran, vous pourrez donner un nom au chemin comme à l'accoutumée. En dessous, vous trouverez les points qui définissent le chemin. Chaque point posséde à la fois une position et une vitesse (indiquées par sp). Selon l'utilisation du chemin, la position sera soit absolue, c'est à dire que l'instance utilisée plus tard suivra le chemin à cet endroit bien précis, soit relative; l'instance débutera toujours à la première position du chemin puis suivra le chemin jusqu'à la fin de celui-ci. La vitesse est à interpréter de la façon suivante. Une valeur de 100 signifie que le chemin assigné à l'instance aura une vitesse normale. Une valeur plus faible réduira la vitesse, une valeur plus grande l'augmentera (cela indique donc le pourcentage de la vitesse actuelle). La vitesse sera interpolée entre les points. Ainsi, la vitesse changera progressivement.

Pour ajouter un point, pressez le bouton Add. Une copie de l'actuel point sélectionné sera faite alors. Maintenant, vous pouvez changer l'actuelle position et la vitesse en modifiant les valeurs dans la boîte d'édition. Si vous sélectionnez un point dans la liste, vous pourrez également changer ses valeurs. Pressez Insert pour insérer un nouveau point avant le point courant et Delete pour effacer le point actuel.

A droite de l'écran, vous apercevrez le chemin actuel. Le point rouge indique le point de contrôle actuellement sélectionné. Les points bleus concernent les autres points de contrôle. Le carré vert signale la position où débute le chemin. Vous pouvez aussi changer le chemin en utilisant la souris. Cliquez quelque part dans l'image pour ajouter un point. Cliquez sur un point existant et déplacez-le à la souris pour modifier sa position. Quand vous maintenez pressée la touche <Shift> tout en cliquant sur un point, vous insérerez un nnouveau point. Enfin, vous pouvez utiliser le bouton droit de la souris pour supprimer des points (veuillez noter que vous ne pouvez changer la vitesse de cette façon). Habituellement, les points seront alignés avec la grille. Vous pouvez modifier les paramètres de la grille avec la barre d'outils située en haut. A cet endroit également, vous pourrez indiquer si la grille doit être visible ou non. Si vous voulez positionner un point avec précision, maintenez la touche <Alt> lors des opérations d'ajout ou de suppression.

Vous pouvez influencer la forme du chemin de deux manières. Premièrement, vous pouvez utiliser le type de connexion. Vous pourrez soit choisir une ligne droite ou encore un chemin tout en courbe. Deuxièmement, vous pourrez indiquer si le chemin doit être fermé ou pas.

Dans la barre d'outils, il existe de nombreux contrôles importants. De la gauche vers la droite, les contrôles sont les suivants. Le premier bouton indique que vous êtes prêt et que vous voulez fermer l'écran, tout en conservant les modifications effectuées (si vous ne souhaitez pas les conserver, pressez la croix pour fermer la fenêtre et indiquer que vous ne souhaitez pas effectuer la sauvegarde des modifications). Ensuite, il y a un bouton pour défaire la dernière modification effectuée.

Le jeu de boutons suivants de la barre d'outils vous permet d'effacer le chemin, d'inverser l'ordre dans lequel le chemin sera parcouru, de décaler le chemin, de le copier horizontalement avec un effet de miroir, de le retourner verticalement, de le faire pivoter ou encore de modifier son échelle. Puis, vous trouverez les boutons pour décaler la vue (et non le chemin en lui-même; la zone de la vue courante est indiquée dans la barre de statut en bas) et pour centrer cette dernière.

Comme déjà mentionné plus haut, vous pouvez ensuite paramétrer les valeurs de rupture et indiquer si elles doivent être affichées sur la grille. Enfin, il existe un bouton pour signaler que vous souhaitez voir une room particulière en guise d'arrière-plan pour ce chemin ( vous pourrez ainsi mettre facilement le chemin à un endroit précis de la room, par exemple une piste de course, de cette façon les instances suivront la bonne route (cela a un sens que lorsque vous utilisez des chemins absolus; voir plus loin)).

Assigner des chemins à des objets (Assigning paths to objects)

Vous devrez mentionner le chemin à suivre et la vitesse en pixels par step. Si la vitesse est positive, l'instance commencera au début du chemin. Si elle est négative, l'instance débutera à la fin. Souvenez-vous bien de cela quand vous souhaiterez définir pour le chemin la vitesse actuelle qui sera relative à la vitesse indiquée. Il y a aussi une action pour changer la vitesse d'exécution du chemin. Vous pourrez, par exemple, utiliser cette action pour ralentir ou accélérer une instance le long du chemin. Veuillez noter que la vitesse normale de l'instance sera ignorée dans ce cas précis (actuellement réglée à 0) quand le chemin sera exécuté. Egalement, certaines choses comme la gravité et la friction n'auront pas d'influence sur le mouvement le long du chemin.

Ensuite, vous indiquerez le comportement de fin, c'est à dire ce qui doit se passer lorsque la fin de chemin est atteinte. Vous pouvez choisir d'arrêter le mouvement et d'aller en fin de chemin. Vous pourrez aussi redémarrer au début du chemin, ce qui forcera donc l'instance à revenir à la position de départ du chemin pour exécuter de nouveau ce chemin. Une troisième option est de relancer à partir de la position courante, ce qui signifie que l'instance suit de nouveau le chemin mais maintenant, sa nouvelle position de départ sera à cet endroit (ce sera la même chose lorsque le chemin sera fermé). Finalement, vous pouvez choisir d'inverser le mouvement, forçant l'instance à faire marche arrière le long du chemin. Notez qu'un événement survient à la fin du chemin; voir plus loin.

Vous pourrez aussi indiquer si le chemin doit être absolu ou relatf. Un chemin absolu est exécuté à l'endroit où il a été défini. L'instance est placée à la position de début et se déplace à partir de cette position (la position de fin quand la vitesse est négative). C'est utile par exemple quand vous avez une piste de course de voiture pour laquelle vous avez défini le chemin. Si vous choisissez relatif, les instances commenceront d'exécuter le chemin à la position actuelle. Utile quand une instance doit faire un déplacement local. Par exemple, les vaisseaux dans un jeu de type Invader peuvent effectuer un tour à partir de leur position courante.

Quand vous placez l'instance à un point différent le long du chemin, vous pouvez utiliser l'action pour fixer la position du chemin. Une position de chemin posséde toujours une valeur entre 0 et 1, 0 indiquant la position de départ et 1 la position de fin du chemin. Veuillez notez qu'à chaque step, la variable de direction sera automatiquement paramétrée à la direction correcte le long du chemin. Vous pouvez utiliser cette variable afin de choisir la bonne orientation pour les sprites.

Si vous utilisez des scripts ou du code de programmation GML, vous disposerez davantage de contrôle sur l'exécution du chemin. Il existe une fonction pour fixer le début de chemin d'une instance. La variable path_position indique la position actuelle du chemin (entre 0 et 1 comme indiqué ci-dessus). La variable path_speed indique la vitesse à suivre dans le chemin. Une variable path_scale peut être utilisée pour mettre le chemin à l'échelle. Une valeur de 1 correspond à la taille d'origine. Une valeur plus grande signale un chemin plus grand; une valeur plus petite un chemin plus petit. La variable path_orientation indique l'orientation vers laquelle le chemin est exécuté (en degrés et dans le sens contraire des aiguilles d'une montre). Cela vous permet d'exécuter le chemin dans des orientations différentes (ex: déplacement en haut et en bas plutôt que de gauche à droite). Il y a également une variable pour contrôler le comportement de fin. Enfin, il existe de nombreuses fonctions pour renseigner les propriétés des chemins (ex: les coordonnées x et y à certaines positions) et l'on trouve des fonctions pour créer des chemins. Il y a même des fonctions qui créent des chemins de collision afin qu'une instance puisse atteindre un but précis. Se reporter aux sections suivantes sur le GML pour obtenir plus de détails à ce sujet.

Vous vous êtes certainement demandé ce qui se passe quand l'instance entre en collision avec une autre instance alors que celle-ci suivait un chemin. C'est le même processus qui survient lorsque l'instance se déplace à une certaine vitesse. Lorsqu'il y a une instance solide, l'instance est placée à son ancienne position. Lorsque les instances ne sont pas de type solide, elles seront placées à leur nouvelle position respective. Ensuite, le ou les événements de collision sont exécutés et une vérification a lieu pour vérifier que la collision a bien été résolue. Dans la négative et si l'autre instance était solide, l'instance s'arrêtera, comme on pouvait s'y attendre (cela suppose toutefois qu'un évenement de collision ait été défini). De plus, la variable path_position ne sera pas incrémentée. Lorsque l'instance suspendue disparaît, l'instance continuera à suivre le chemin. Pour gérer les collisions par vous-même, la variable path_positionprevious pourra être très utile. Elle contient la précédente position du chemin et vous pouvez lui affecter la valeur de la position du chemin afin d'éviter d'avancer le long du chemin.

L'événement de chemin (The path event)

Les Lignes de Temps

Pour créer une ligne de temps, choisissez Add Time Line à partir du menu Add. L'écran suivant apparaîtra.

Cet écran ressemble quelque peu à celui des propriétés d'objets. A gauche, vous pourrez donner un nom et il existe aussi des boutons pour ajouter et modifier les moments de la ligne de temps. Ensuite, vous trouverez la liste des moments. Cette liste indique les moments de temps en steps avec les actions devant survenir. Puis, il y a la liste familière des actions pour les moments sélectionnés et enfin, vous trouverez le jeu complet d'actions disponibles.

Pour ajouter un moment précis, pressez le bouton Add. Indiquez le temps du moment (c'est le nombre de steps depuis le démarrage de la ligne de temps). Maintenant, vous pouvez déplacer à la souris les actions dans la liste comme pour les événements concernant les objets. Il existe aussi des boutons pour effacer le moment sélectionné, pour changer le temps du moment choisi, pour dupliquer un moment et pour effacer la ligne de temps.

Enfin , il y a deux boutons spéciaux. Avec le bouton Merge, vous pourrez ajouter tous les moments d'un intervalle de temps dans un autre. Avec le bouton Shift, vous pouvez déclarer tous les moments d'un intervalle de temps soit plus en avant ou plus en arrière en indiquant une valeur de temps précise. Soyez certain que vous ne créez pas de moments avec des valeurs négatives car ils ne seraient bien entendu jamais exécutés.

Il existe deux actions concernant les lignes de temps.

Paramétrer une ligne de temps (Set a time line)
Cette action vous permettra de paramétrer une ligne de temps particulière pour une instance d'un objet. Vous indiquerez la ligne de temps et la position de départ de la ligne de temps (0 correspond au début). Vous pourrez aussi utiliser cette action pour terminer une ligne de temps en choisissant la valeur No Time Line.

Fixer la valeur de la position de la ligne de temps (Set the time line position)
Avec cette action, vous pouvez changer la position de la ligne de temps courante (soit en absolu soit en relatif). Ceci peut être utilisé afin de sauter certaines parties de la ligne de temps ou encore répéter certaines parties d'entre elles. Par exemple, si vous souhaitez faire une ligne de temps qui boucle indéfiniement , au dernier moment, ajoutez cette action pour fixer la position de nouveau à 0. Vous pourrez également utiliser cette action pour attendre que quelque chose de particulier se produise. Il suffira juste d'ajouter l'action de test et, si cette dernière renvoie FAUX (FALSE), vous réglerez la position de la ligne de temps à une valeur relative de -1.

Scripts

Comme mentionné auparavant, un script est écrit en code GML (le langage de programmation intégré) et est destiné à effectuer une tâche particulière. Les scripts peuvent avoir des variables en entrée appelées arguments (parfois, on les appelle également paramètres). Pour exécuter un script à partir d'un événement, vous pourrez utiliser soit une action contenant du script ou employer du code. Dans le premier cas, vous indiquerez le nom du script à exécuter, en plus des cinq arguments maximum optionnels. Dans le second cas, ce sera la même chose mais vous appellerez une fonction en GML. Dans ce cas précis, il vous sera possible d'utiliser jusqu'à 16 arguments. Les scripts peuvent retourner une valeur. Cela est souvent utile pour élaborer des méthodes de calculs (mathematical methods). Le mot-clé return est utilisé à cet effet. Le code placé après ce mot-clé ne sera jamais exécuté ! Lorsqu'un script retourne une valeur, vous pourrez aussi utiliser cette valeur comme fonction en fournissant des valeurs pour d'autres actions.

Pour ajouter un script dans votre jeu, choisissez Add Script à partir du menu Add menu. L'écran suivant apparaîtra alors (dans l'exemple, nous avons déjà ajouté un petit script qui initialise deux variables).

(Actuellement, il existe un éditeur de scripts intégré. Dans les préférences, vous pouvez aussi indiquer que vous souhaitez utiliser un éditeur externe). En haut à droite, vous mentionnerez le nom du script. Vous aurez à disposition un petit éditeur dans lequel vous pourrez taper le script. Veuillez noter qu'une liste de toutes les fonctions, des variables internes et des constantes, est affichée tout en bas. Ceci constitue une aide qui vous permettra de trouver l'instruction souhaitée. Vous pouvez double-cliquer sur une instruction pour l'ajouter dans la liste (ou encore utiliser la touche <Ctrl>P). L'affichage de cette liste peut être paramétrée pour s'afficher ou non toujours à partir des préférences. L'éditeur présente de nombreuses propriétés utiles, la plupart étant accessibles à partir de boutons (pressez le bouton droit de la souris pour obtenir des commandes supplémentaires) :

• Plusieurs Undo et Redo en pressant une touche ou par groupes (peut être modifié dans les préférences)
• Indentation automatique intelligente qui aligne avec la ligne précédente (peut être modifié dans les préférences)
• Gestion intelligente des tabulations qui se positionnent au prochain caractère (différent du caractère espace ) des lignes précédentes (peut être modifié dans les préférences)
• Utilisation de la touche <Ctrl>I pour indenter les lignes sélectionnées et des touches <Shift> <Ctrl>I pour les désindenter
• Couper et coller
• Recherche et remplacement
• Utilisation des touches <Ctrl> + up, down, page-up, ou page-down pour scroller sans modifier la position du curseur
• Utilisation de la touche de fonction F4 pour ouvrir le script ou la ressource dont le nom se trouve à la position du curseur (ne fonctionne pas pour les actions comprenant du code; marche uniquement dans les scripts)
• Sauvegarde et chargement de scripts comme fichiers textes

Il existe aussi un bouton avec lequel vous pourrez tester si la syntaxe du script est correcte. Tous les aspects, cependant, ne peuvent être testés à ce stade mais la syntaxe de votre script sera vérifiée, de même que l'existence des fonctions utilisées.

Comme vous l'avez sans doute remarqué, certaines parties du texte du script sont en couleur. L'éditeur sait reconnaître les objets existants, les variables et les fonctions intégrées du langage, etc. La colorisation du code aide beaucoup dans la recherche des erreurs. En particulier, vous pourrez voir immédiatement si vous avez mal orthographié certains noms de commandes ou utilisé un mot-clé en tant que variable. Cependant, la colorisation du code est assez lente. Dans les préférences du menu Fichier (file menu), il est possible d'autoriser / d'interdire la colorisation du code. Vous pourrez également ici modifier la couleur des différents composants des programmes (si quelque chose ne devait pas bien fonctionner avec cette fonctionnalité, appuyez deux fois sur F12, pour permuter entre les deux états de cette fonction). Vous pouvez aussi changer la police de caractères utilisée dans les scripts et le code.

Les scripts sont extrémement utiles afin d'étendre les possibilités de Game Maker. Cela suppose donc que vous conceviez vos scripts avec précaution. Les scripts peuvent être stockés dans des librairies qui seront ajoutées dans votre jeu. Pour importer une librairie, utilisez l'option Import scripts du menu Fichier (file menu). Pour sauver vos scripts sous forme de librairie, utilisez Export scripts. Les librairies de scripts sont de simples fichiers textes (malgré qu'elles portent l'extension .gml). Il est cependant préférable de ne pas les éditer directement avec un éditeur externe car elles ont une structure spéciale. Certaines librairies avec de puissants scripts, sont déjà incluses avec Game Maker (afin d'éviter du travail inutile lors du chargement du jeu, après l'importation d'une librairie, il est très conseillé de supprimer les scripts que vous n'utilisez pas).

Quand vous créez des scripts, vous pouvez très facilement commettre des erreurs. Il faut toujours tester les scripts en utilisant le bouton ad'hoc. Lorsqu'une erreur survient pendant l'exécution d'un script, cela est mentionné, avec une indication du type d'erreur commise et à quel endroit celle-ci se trouve. Il est très rare que vous puissiez voir une fenêtre avec le texte "Unexpected error occurred during the game" ("erreur inattendue rencontrée pendant le jeu" ). Ce message d'erreur indique qu'un problème est apparue dans Windows ou bien dans le matériel. La raison est due à une boucle récursive infinie, un manque de mémoire ou à cause d'un matériel inadapté pour effectuer les opérations demandées, un problème de pilotes (drivers) ou encore de logiciel (firmware). Pour être plus clair, ces erreurs n'ont pas de liens directs avec des problèmes dus à l'environnement de GM. Si vous avez besoin de vérifier ces choses plus en détails, vous devrez lancer le jeu dans le mode de déboguage (debug mode). Un écran apparaîtra alors avec lequel vous pourrez obtenir beaucoup d'informations sur votre jeu.

A partir du menu Run, vous pouvez suspendre le jeu, l'exécuter étape par étape et même relancer son exécution. Dans le menu Watch, vous pourrez surveiller la valeur de certaines expressions. Utilisez Add pour entrer une expression dont la valeur sera affichée à chaque étape du jeu. De cette manière, vous pouvez voir si le jeu réalise les choses correctement. Vous pouvez surveiller plusieurs expressions. Vous pouvez les sauvegarder pour un usage ultérieur (ex: après que vous ayez fait une correction du jeu). Dans le menu Tools, vous trouverez des options pour avoir encore plus d'informations. Vous pourrez ainsi examiner la liste de toutes les instances du jeu, surveiller toutes les variables globales (ce sont sans doute les plus importantes) et les variables locales d'une instance (vous pouvez utiliser soit le nom de l'objet ou l'ID de l'instance). Vous pourrez également voir les messages que votre code transmet en utilisant la fonction show_debug_message(str). Enfin, vous pourrez donner des commandes au jeu et modifier la vitesse de celui-ci. Si vous réalisez des jeux complexes, vous devriez vraiment apprendre à utiliser les options de déboguage (debug options).

La distribution de votre jeu

Informations sur le Jeu

Dans le menu File, vous pourrez également paramétrer un certain nombre d'options. Vous indiquerez ici le titre de la fenêtre d'information du jeu. Vous pourrez aussi indiquer la position (utilisez le nombre -1 pour un affichage centré) et la taille de la fenêtre d'information du jeu ainsi que si cette dernière doit avoir une bordure, redimensionnable ou pas par le joueur. Vous pouvez forcer la fenêtre d'informations à rester en haut de l'écran et indiquer si le jeu doit poursuivre son exécution pendant l'affichage de la fenêtre d'informations.

Une option intéressante est de reproduire la fenêtre principale du jeu. Si vous cochez cette option, la fenêtre d'aide sera affichée exactement à la position et à la taille de la fenêtre de jeu. Cela donnera l'illusion que le texte apparaît dans la fenêtre de jeu. Si la couleur d'arrière-plan est bien choisie, cela produira un joli effet visuel (il serait également intéressant que vous indiquiez au joueur de presser la touche Escape (ou Esc) pour qu'il puisse retourner au jeu).

Il est important que l'information affichée soit brève et concise. Bien entendu, vous ajouterez votre nom parce que c'est vous qui êtes le créateur du jeu. Tous les exemples de jeu fournis possédent un fichier d'informations sur le jeu et comment ce dernier a été créé.

Si vous souhaitez créer une aide encore plus agréable, vous pouvez utiliser un programme de traitement de textes comme Word. Sélectionnez ensuite la partie souhaitée puis faites un copier/coller du logiciel Word dans l'éditeur d'information de jeu. Pour les jeux plus avancés, vous n'utiliserez certainement pas ce mécanisme mais employerez plutôt des rooms spécialement concues pour afficher de l'information sur le jeu.

Paramétrages généraux du Jeu

Les paramètres peuvent être changés en double cliquant sur Global Game Settings dans l'arbre des ressources situé à gauche de l'écran. Ils sont regroupés dans plusieurs onglets (certaines options ne sont disponibles que dans le mode avancé).

Options sur les Graphiques et sur la Fenêtre

Lancer le jeu en mode plein écran (Start in fullscreen mode)
Si cette option est validée, le jeu se lancera en plein écran; sinon il fonctionnera en mode fenêtré.

Mise à l'échelle du jeu (Scaling)
Ici, vous indiquerez ce qui doit se passer lorsque la fenêtre est plus grande que la room ou encore lorsque le jeu fonctionne en mode plein écran. Trois choix sont possibles. Vous pourrez indiquer une échelle arbitraire. La room sera alors affichée dans cette échelle en utilisant la valeur fournie et sera centrée dans la fenêtre ou dans l'écran. 100 indique aucune échelle. Vous utiliserez habituellement une échelle arbitraire quand vos sprites et les rooms sont très petits. La seconde option permet de mettre à l'échelle la room de telle manière que celle-ci remplisse entièrement la fenêtre ou l'écran tout en conservant le même ratio d'aspect (rapport entre la largeur et la hauteur). La troisième option fera que la fenêtre ou l'écran sera totalement rempli. Cela pourra créer des déformations de l'image (en particulier dans le mode fenêtré lorsque le joueur voudra redimensionner la fenêtre).

Interpolation des couleurs entre pixels (Interpolate colors between pixels)
Si cette option est cochée, les couleurs des pixels des sprites, des arrière-plans et des tuiles qui ne sont pas alignés avec les pixels de l'écran, seront interpolées. Ceci se produira en particulier en cas de mise à l'échelle, de rotation ou de placement à des positions non entières (non-integer positions). L'interpolation contribuera à rendre les mouvements plus doux mais en contre-partie créera un effet de flou (ceci est également valable pour les tuiles qui présenteront des fissures entre elles, si ces dernières n'ont pas été prévues et conçues pour cet usage).

Couleur en dehors de l'aire de la room (Color outside the room region)
Si la room ne remplit pas complètement la fenêtre ou l'écran, il apparaîtra des zones inutilisées autour de la room. Vous indiquerez ici la couleur de la zone en question.

Autoriser le joueur à redimensionner la fenêtre (Allow the player to resize the game window)
Si cette option est cochée et si nous nous trouvons dans le mode fenêtré, le joueur pourra modifier la taille de la fenêtre de jeu en déplaçant ses coins à l'aide de la souris.

Afficher la fenêtre de jeu toujours au dessus des autres fenêtres (Let the game window always stay on top)
Si cette option est cochée et si nous nous trouvons dans le mode fenêtré, la fenêtre de jeu apparaîtra toujours par dessus toutes les autres fenêtres.

Ne pas afficher une bordure dans le mode fenêtré (Don't draw a border in windowed mode)
Si cette option est cochée et si nous nous trouvons dans le mode fenêtré, la fenêtre de jeu ne possédera pas de bordure ni de barre de titre.

Ne pas afficher les boutons dans le titre de la fenêtre (Don't show the buttons in the window caption)
Si cette option est cochée et si nous nous trouvons dans le mode fenêtré, le titre de la fenêtre n'affichera pas les boutons de fermeture et de minimisation/maximisation de la fenêtre.

Afficher le curseur (Display the cursor)
Indique si vous souhaitez rendre visible le pointeur de souris. Le rendre invisible devrait normalement accélérer les déplacements de la souris. (vous avez la possibilité avec Game Maker de créer facilement votre propre objet pointeur de souris).

Geler le jeu lorsque l'écran de jeu n'est plus affiché au premier plan (Freeze the game when the form looses focus)
Si cette option est cochée et lorsque le joueur ouvre un autre écran (ex: une autre application), le jeu sera suspendu jusqu'à ce que la fenêtre du jeu réapparaisse au premier plan.

La Résolution d'Ecran

Il y a trois choses que vous pouvez modifier. En premier lieu, la profondeur de couleur. Ceci indique le nombre de bits utilisés pour représenter la couleur d'un pixel. La plupart des machines n'autorisent que 16-bit (High Color) ou 32-bit (Full Color) mais les machines plus anciennes ne permettent que le 8-bit et même parfois uniquement le mode couleur 24-bit. Game Maker ne fonctionne que dans les modes de couleur 16-bit et 32-bit. Le mode couleur 32-bit donne les plus belles images mais consomme plus de mémoire et de temps processeur. Si vous désirez que votre jeu puisse tourner sur les machines les plus anciennes, réglez la profondeur de couleur sur 16-bit. Sinon, utilisez le mode couleur 32-bit ou encore ne modifiez rien du tout.

En second lieu, il y a la notion de résolution d'écran, c'est à dire le nombre de pixels (horizontaux et verticauxl) de l'écran. Changer la résolution est utile quand par exemple vos rooms sont très petites. Dans ce cas, il peut être utile de réduire la résolution d'écran. Ayez cependant bien en tête que cela aura des effets également sur les autres applications actuellement en fonctionnement. Cela peut en particulier créer des problèmes dans les modes basse résolution. En général, il est préférable de toucher à la résolution d'écran que si le jeu tourne en mode plein écran. Game Maker repositionnera automatiquement la résolution à sa valeur d'origine une fois le jeu terminé.

Enfin, vous pourrez modifier la fréquence de rafraîchissement. Ce paramétre indique combien de fois par seconde l'image doit être rafraîchie à l'écran. Si la vitesse de votre room est plus grande que la fréquence de l'écran, tous les steps ne seront pas actuellement visibles. Cela fonctionne mieux si la fréquence est un multiple de la vitesse de la room (si vous indiquez une fréquence trop importante ou non disponible, la fréquence ne sera pas modifiée).

Il existe aussi un réglage nommé Use synchronization to avoid tearing (utiliser la synchronisation afin d'éviter le scintillement). Ceci nécessite des explications. L'affichage est réalisé un certain nombre de fois par seconde, selon la fréquence de rafraîchissement actuellement sélectionnée. Si l'affichage d'une room est affichée par moitié, le haut de l'affichage contiendra encore l'ancienne image alors qu'en bas, la partie de la nouvelle image sera déjà affichée. Ce phénomène est appelé le scintillement (tearing). Afin d'éviter cela, vous pouvez cocher cette option. Dans ce cas, la nouvelle image de la room sera seulement copiée à l'écran lorsque le rafraîchissement n'est pas en dehors de la fenêtre de jeu évitant ainsi le scintillement (tearing) la plupart du temps. L'inconvénient est que normalement, il faudra attendre jusqu'au prochain rafraîchissement. Cela veut dire que le nombre maximal d'images est limité par la fréquence du moniteur et que, lorsque le traitement de ce processus n'est pas assez rapide, le taux d'images tombe immédiatement à la moitié de ce nombre. Il peut aussi y avoir un conflit entre le timing interne du jeu et la synchronisation. Si vous souhaitez obtenir le meilleur réglage, réglez la fréquence du moniteur par exemple à 60 Hz et modifiez si besoin la vitesse de la room à 30 ou encore à 60.

Autres Options Diverses

Paramétrer la touche <Esc> Fin de jeu (End the game)
Si cochée, l'appui sur la touche escape (Esc) terminera le jeu. Pour la plupart des jeux, cependant, cela ne sera pas souhaitable car certains jeux veulent effectuer des traitements (comme la sauvegarde) avant de fermer le jeu. Dans ce cas, décochez cette case et fournissez vos propres actions lors de l'emploi de la touche escape (cliquer sur la croix de la fenêtre génére également un événement touche escape).

Paramétrer la touche <F1> Afficher l'information sur le jeu (show the game information)
Si cochée, cette option affichera des informations sur le jeu lors de la pression de la touche F1.

Paramétrer la touche <F4> Basculer entre les modes d'écran (switch between screen modes)
Si cochée, la touche F4 basculera entre les modes plein écran et fenêtré.

Paramétrer la touche <F5> Sauvegarder le jeu (save the game) et <F6> Charger un jeu (load a game)
Si cochée, le joueur pourra utiliser la touche <F5> pour sauvegarder la situation courante du jeu et la touche <F6> pour charger le dernier jeu sauvegardé (veuillez noter que seules les données de base du jeu seront sauvées. Lorsque vous utiliserez des fonctionnalités avancées comme les particules ou encore les structures de données, ces paramétres ne seront pas sauvés et vous devrez par vous-même créer un mécanisme de sauvegarde.

Vous pourrez aussi changer la priorité du processus du jeu. Cette priorité indique combien de temps le processeur doit consacrer au jeu. En fonctionnement normal, le système d'exploitation essaie de donner à chacun des processus un temps processeur raisonnable et réparti. Plus la priorité sera grande et davantage de temps processeur sera affecté à votre jeu, permettant à ce dernier de fonctionner plus rapidement et de manière plus régulière. Mais les autres processus disposeront par conséquent de moins de temps pour leur exécution (ainsi, les processus Windows comme ceux de la souris ralentiront leur exécution). A utiliser avec précaution.

Options de Chargement

Il est possible de préciser que l'image chargée doit être transparente. Dans ce cas, le pixel du bas à gauche de l'arrière-plan de l'image sera utilisé comme couleur transparente. La valeur alpha de transparence peut aussi être indiquée. Une valeur de 0 signifie une transparence totale. Une valeur de 255 indique une opacité totale (ces deux paramétres ne fonctionnent que sous Windows 2000, XP, ou supérieur).

En second lieu, vous pourrez indiquer l'icône à utiliser pour les programmes de jeu exécutables. Vous pouvez utiliser uniquement des icônes de taille 32x32. Si vous essayez de choisir un autre type d'icône, vous obtiendrez un message d'erreur.

Enfin, vous pourrez modifier l'ID unique du jeu. Cet ID est utilisé pour sauvegarder la liste des plus hauts scores et sauver les fichiers de jeu. Si vous distribuez une nouvelle version de votre jeu et ne souhaitez pas écraser l'ancienne liste des highscores, vous devrez alors changer ce nombre.

Constantes

La valeur d'une constante devrait être une expression constante. C'est à dire soit un nombre constant ou une chaîne de caractères (entourée de quotes) ou encore une expression. L'expression est évaluée avant toute chose dans le jeu. Ainsi, par exemple, la constante ne peut référencer l'actuelle room, d'autres instances ou des scripts. Mais elle peut contenir des références à des constantes intégrées et à des noms de ressources.

Vous pouvez ajouter une constante en utilisant le bouton Add et les effacer avec le bouton Delete. Vous pouvez modifier le nom d'une constante ou sa valeur en cliquant sur la constante. Il existe aussi des boutons pour effacer toutes les constantes ou pour trier leur nom.

Fichiers à inclure dans les Jeux Autonomes

Comme indiqué plus haut, vous pouvez créer des versions autonomes de votre jeu. Parfois, votre jeu utilisera des fichiers supplémentaires. Par exemple, vous pourrez souhaiter inclure des fichiers vidéo ou des fichiers textes qui seront utilisés dans le jeu. Dans certains cas, vous désirerez ajouter des fichiers DLL ou des images, des sons qui seront chargés lors du jeu. Il est bien sûr possible de fournir ces fichiers intégrés dans le fichier exécutable mais il est souvent plus commode de les joindre sous forme de fichiers séparés. De cette façon, seuls les fichiers nécessaires seront distribués.

Vous pouvez mentionner ici les fichiers que vous voulez joindre dans l'exécutable. En haut de l'écran, se trouve une liste de tous les fichiers à inclure. Utilisez Add pour sélectionner les fichiers à ajouter à la liste (vous pouvez choisir plusieurs fichiers). Utilisez Delete ou Clear pour supprimer les fichiers de la liste (pensez cependant que les fichiers ne seront pas inclus dans le fichier .gm6, mais seulement leur nom. Aussi, lorsque vous enverrez à une autre personne le fichier .gm6 source, vous devrez également donner les fichiers à inclure).

Les fichiers de la liste sont compactés dans l'exécutable. Quand le jeu est lancé, ces fichiers sont décompactés et sont ainsi accessibles par le jeu. Il est important de bien comprendre ce qu'il se passe alors. Il y a deux possibilités pour lesquelles vous devrez faire un choix. Dans la situation par défaut, les fichiers sont décompactés dans le répertoire où se trouve le jeu exécutable. C'est ce que l'on appelle le répertoire courant (ou de travail) du jeu. De cette manière, le jeu peut utiliser uniquement les noms de fichiers pour y accéder (aucun chemin n'est donc nécessaire). Cela fonctionne bien si l'exécutable du jeu est sauvé sur un disque dur mais cela ne marche pas si le jeu est stocké sur un périphérique en lecture seule comme par exemple un CD Rom.

La deuxième façon de procéder est d'indiquer que les fichiers doivent être décompactés dans un répertoire temporaire qui sera créé à l'occasion juste pour le fonctionnement du jeu. Si vous choisissez cette option, il vous sera nécessaire de fournir le chemin de ce répertoire temporaire à l'intérieur même de votre jeu. Ce chemin peut être obtenu en utilisant la variable interne temp_directory. N'oubliez pas d'ajouter le caractère backslash ( \ ) dans ce cas. Dans le cas d'un fichier vidéo, vous pourriez taper par exemple le code programme suivant :

{
  show_video(temp_directory+'\movie.avi',true,true);
}

Si un fichier décompacté existe déjà, il ne sera pas normalement enregistré sur le disque. Vous pouvez changer ce comportement en cochant Overwrite existing files. Ainsi, quand le jeu sera terminé, les fichiers ne seront normalement pas effacés (sauf s'ils étaient dans le répertoire temporaire qui lui est complètement supprimé). Vous pourrez modifier cela en cochant Remove at game end.

Juste un dernier mot pour vous prévenir de ne pas commettre une certaine erreur. Si vous testez votre jeu, le répertoire courant du jeu est le répertoire où le fichier .gm6 est sauvegardé. Si vos fichiers sont également présents dans ce répertoire, et que vous ayez choisi de les supprimer à la fin du jeu, vous pourriez ainsi tous les perdre ! Il est donc préférable de ne pas sauvegarder ces fichiers avec le fichier .gm6 !

Options sur les Erreurs

Afficher les messages d'erreurs (Display error messages)
Si cette option est cochée, les messages d'erreurs seront affichés au joueur. Dans la version finale du jeu, vous souhaiterez certainement décocher cette option.

Enregistrer les messages d'erreurs dans le fichier game_errors.log (Write error messages to file game_errors.log)
Si cochée, tous les messages d'erreurs seront écrits dans le fichier game_errors.log situé dans le répertoire du jeu.

Arrêter le jeu en présence d'un message d'erreur (Abort on all error messages)
Normalement, certaines erreurs seront fatales alors que d'autres pourront être ignorées. Si cette option est cochée, toutes les erreurs seront considérées comme fatales et conduiront à suspendre le jeu. Dans la version finale du jeu que vous distribuerez, vous souhaiterez certainement cocher cette option.

Initialiser à 0 les variables non déclarées (Treat uninitialized variables as 0)
Une erreur courante est d'utiliser une variable avant qu'une valeur ne lui soit assignée. Parfois, c'est un problème qui sera difficile à éviter. En cochant cette option, les variables non initialisées ne généreront plus d'erreur mais seront traitées comme des variables initialisées à 0. Soyez cependant très prudent. Cela ne signifiera pas pour autant que vous n'ayez pas commis d'erreur de saisie.

Informations concernant le Jeu

Considérations sur la vitesse de jeu

Premièrement, soyez attentif en ce qui concerne les sprites et les arrière-plans (backgrounds) utilisés. Les sprites animés prennent beaucoup de mémoire et dessiner de nombreux sprites prend beaucoup de temps. Aussi, créez vos sprites aussi petits que possible. Supprimez toutes les zones invisibles autour de ces derniers (la commande crop de l'éditeur de sprites le fait automatiquement). C'est la même chose en ce qui concerne les images d'arrière-plan. Si vous avez un arrière-plan plein, vérifiez que vous avez désactivé l'utilisation de la couleur d'arrière-plan.

Si vous êtes en mode plein écran, soyez sûr que la taille de la room (ou la fenêtre) ne soit jamais plus large que la taille de l'écran. La plupart des cartes graphiques savent efficacement mettre à l'échelle les images mais la mise à l'échelle de ces images ralentira cependant l'affichage ! Autant que possible, désactivez l'affichage du curseur. Lui aussi ralentit l'affichage des graphiques.

Soyez également prudent lors de l'utilisation des vues (views). Pour chaque vue, la room sera redessinée.

En plus des graphiques, il y a aussi d'autres aspects qui peuvent influencer la vitesse du jeu. Veillez pour qu'il y ait le moins possible d'instances. En particulier, détruisez les instances qui ne sont plus nécessaires (ex: lorsque vous quittez la room). Evitez de placer beaucoup d'actions dans l'événement step ou dans l'événement d'affichage (drawing event) des instances. Souvent, il n'est pas indispensable de les placer à chaque step. L'interprétation du code est assez rapide mais c'est tout de même du code interprété. De plus, certaines fonctions et actions prennent beaucoup de temps; en particulier celles qui doivent vérifier toutes les instances (comme par exemple l'action de rebondissement (bounce action)).

Réfléchissez sur la façon de gérer les événements de collision. Vous devriez avoir normalement deux options. Les objets qui n'ont pas d'événement de collision seront exécutés plus rapidement, aussi il est préférable de traiter les collisions avec les objets qui possédent peu d'instances.

Soyez également attentif lors de l'utilisation de gros fichiers sons. Ils consomment beaucoup de mémoire et se compressent assez mal. Vous devriez analyser davantage vos sons afin de voir s'ils ne peuvent pas être mieux échantillonnés.

Enfin, si vous voulez réaliser un jeu avec lequel la plupart des gens puissent jouer, testez-le sur les plus vieilles machines.

Le Langage de Game Maker (GML)

Aperçu du langage GML

Dans ce chapître, nous décrirons la structure de base des programmes en GML. Lorque vous souhaiterez utiliser des programmes en GML, il y aura certaines choses pour lesquelles vous devrez faire attention. En premier lieu, vous devrez nommer toutes vos ressources (sprites, objets, sons, etc.) par un nom commençant par une lettre et ne comprenant que des lettres, nombres ou le symbole underscore '_' . Sinon, vous ne pourrez pas les référencer dans votre programme. Soyez sûr que toutes les ressources disposent chacune d'un nom différent. Ainsi, n'utilisez pas par erreur des noms de ressources comme self, other, global ou tout autre chose ayant une signification particulière pour le langage. Bien entendu, vous ne devrez pas utiliser l'un des mots-clés énumérés ci-dessous.

Un Programme

{
  <instruction>;
  <instruction>;
  ...
}

Il existe différents types d'instructions qui seront détaillées plus loin.

Les variables

Les Affectations (Assignments)

<variable> = <expression>;

Une expression peut être une simple valeur mais peut aussi être beaucoup plus compliquée. Plutôt que d'affecter une valeur à une variable, on peut également ajouter une valeur à la valeur actuelle d'une variable en utilisant +=. De façon similaire, il vous est possible de soustraire une valeur en employant -=, de la multiplier avec *=, de la diviser grâce à /= ou d'utiliser les opérateurs fonctionnant bit à bit comme |=, &\, ou ^=.

Les Expressions

• && || ^^: traite des valeurs Booléennes (&&; = et, || = ou, ^^ = xor)
• < <= == != > >=: comparaisons, résultat VRAI (1) ou FAUX (0) (True ou False)
• | & ^: opérateurs fonctionnant bit à bit (| = ou bit à bit, & = et bit à bit, ^= xor bit à bit)
• << >>: opérateurs bit à bit (<< = décalage à gauche, > > = décalage à droite)
• + -: addition, soutraction
• * / div mod: multiplication, division, division entière et modulo

Veuillez noter que la valeur de x div y est la valeur de x/y arrondie à l'entier inférieur le plus proche. L'opérateur mod retourne le reste obtenu en divisant les opérandes. Autrement dit, x mod y = x - (x div y) * y. Il existe également les opérateurs unaires suivants :

• !: non, transforme VRAI (true) en FAUX (false) et FAUX en VRAI
• -: valeur opposée de la valeur fournie (inversion)
• ~: inverse la valeur bit à bit

Exemple

Voici un exemple présentant quelques affectations.

{
  x = 23;
  color = $FFAA00;
  str = 'hello world';
  y += 5;
  x *= y;
  x = y << 2;
  x = 23*((2+4) / sin(y));
  str = 'hello' + " world";
  b = (x < 5) && !(x==2 || x==4);
}

Les autres Variables (Extra variables)

Pour créer des variables globales, qui seront visibles par toutes les instances d'objets, précédez les variables avec le mot global suivi d'un point. Par exemple, vous pourrez écrire :

{
  if (global.doit)
  {
    // Effectuer quelque chose...
    global.doit = false;
  }
}

Vous souhaiterez disposer parfois de variables uniquement dans le code ou le script courant. De cette façon, vous éviterez de gaspiller de la mémoire et serez sûr de ne pas avoir de conflit avec les noms des autres variables. En outre, c'est plus rapide que l'utilisation de variables globales. Pour finir, vous devrez déclarer les variables au début de votre code en utilisant le mot-clé var. La déclaration pourra ressembler à ceci.

var <nom1 variable>,<nom2 variable>,<nom3 variable>, ...

Par exemple, vous pourrez écrire :

{
  var xx,yy;
  xx = x+10;
  yy = y+10;
  instance_create(xx,yy,ball);
}

Adressage de variables dans les autres instances

x = 3;

Mais dans de nombreux cas, vous voudrez adresser les variables des autres instances. Par exemple, vous souhaiterez arrêter le déplacement de toutes les balles, ou encore déplacer le personnage principal à une position particulière, ou, dans le cas d'une collision, utiliser le sprite de l'autre instance concernée. Ceci peut être réalisé en précédant le nom de la variable avec le nom d'un objet suivi d'un point. Par exemple, vous pourrez écrire

ball.speed = 0;

Cela modifiera la vitesse de toutes les instances de l'objet ball. Il existe certains objets spéciaux :

• self: L'instance actuelle pour laquelle nous exécutons l'action
• other: L'autre instance concernée dans un événement de collision
• all: Toutes les instances
• noone: Aucune instance (cela peut paraître étrange mais cela a son utilité comme nous le verrons plus tard)
• global: Pas une instance mais un container qui stocke les variables globales

other.sprite_index = sprite5;
all.speed = 0;
global.message = 'A good result';
global.x = ball.x;

Vous vous demandez certainement ce que fera la dernière affectation en présence de plusieurs balles. Et bien, la première sera prise en compte et sa valeur x sera affectée à la variable globale.

Mais alors, comment faire pour régler la vitesse d'une balle particulière ? Cela est un peu plus difficile. Chaque instance posséde un ID unique. Lorsque vous placez des instances dans une room à l'aide de l'éditeur de room, l'ID de cette instance est affiché quand vous gardez le pointeur de la souris sur l'instance. Ce sont des nombres supérieurs ou égaux à 100000. Vous pouvez également utiliser ce nombre en le saisissant à gauche du point. Mais soyez prudent ! Le point sera interprété comme le point décimal du nombre. Afin d'éviter ce problème, mettez des parenthèses autour de l'ID. Par exemple, supposons que l'ID de la balle soit 100032, vous pourrez alors écrire :

(100032).speed = 0;

Lorsque vous créez une instance dans un programme, la valeur de retour sera égal à l'ID. Il est donc possible d'écrire ceci dans un programme :

{
  nnn = instance_create(100,100,ball);
  nnn.speed = 8;
}

Ceci aura pour effet de créer une balle et de régler sa vitesse. Veuillez noter que nous avons affecté l'ID de l'instance à une variable puis utilisé cette variable juste avant le point. Cela est parfaitement valide. Soyons plus précis. Un point est un opérateur. Il admet une valeur comme opérande de gauche et une variable (adresse) comme opérande de droite puis retourne l'adresse de cette variable particulière dans l'objet ou l'instance indiqué. Tous les noms d'objet, ainsi que les objets spéciaux mentionnés ci-dessus, représentent simplement des valeurs et peuvent donc être utilisés comme n'importe quelle valeur. Par exemple, le programme ci-dessous est tout à fait valide :

{
  obj[0] = ball;
  obj[1] = flag;
  obj[0].alarm[4] = 12;
  obj[1].id.x = 12;
}

La dernière instruction est à lire de la façon suivante. Nous prenons l'ID du premier élément. Pour toutes les instances concernées par cet ID, nous affectons 12 à la coordonnée x.

Les noms d'objet, les objets spéciaux et les ID d'instances peuvent également être utilisés dans de nombreuses fonctions. Ils seront considérés comme des constantes dans les programmes.

Les tableaux

{
  a[0] = 1;
  i = 1;
  while (i < 10) { a[i] = 2*a[i-1]; i += 1;}
  b[4,6] = 32;
}

L'instruction IF

if (<expression>) <instruction>

ou

if (<expression>) <instruction> else <instruction>

L'instruction peut aussi se présenter sous la forme d'un bloc. L'expression sera évaluée. Si la valeur (arrondie) est <=0 (false (FAUX)) alors les instructions après le else seront exécutées, sinon (le résultat est donc true (VRAI)), les autres instructions seront exécutées. C'est une bonne habitude de toujours placer des accolades pour entourer les instructions. Il est donc préférable d'écrire les instructions comme ci-dessous.

if (<expression>)
{
  <instruction 1>
  <instruction 2>
  <instruction ...>
}
else
{
  <instruction 1>
  <instruction 2>
  <instruction ...>
}

Exemple
Le programme suivant déplace un objet en avant au milieu de l'écran.

{
  if (x<200) {x += 4} else {x -= 4};
}

L'instruction Repeat

repeat (<expression>) <instruction>

L'instruction est répétée un certain nombre de fois indiqué par la valeur (arrondie) de l'expression.

Exemple
Le programme suivant crée cinq balles (ball étant l'instance de l'objet) à des positions aléatoires.

{
  repeat (5) instance_create(random(400),random(400),ball);
}

L'instruction While

while (<expression>) <instruction>

Tant que l'expression est vraie, l'instruction (qui peut être également un bloc) est exécutée. Soyez prudent avec vos boucles While. Il est facile de créer des boucles infinies, dans lesquelles votre jeu se perdra et ne réagira plus à aucune action de l'utilisateur.

Exemple
Le programme suivant essaie de déterminer une position libre (c'est à dire non utilisée par un autre objet) pour l'objet courant. C'est exactement la même chose que l'action qui déplace un objet à une position aléatoire.

{
  while (!place_free(x,y))
  {
    x = random(room_width);
    y = random(room_height);
  }
}

L'instruction Do

do <instruction> until(<expression>)

L'instruction (qui peut être un bloc) est exécutée jusqu'à ce que l'expression soit vraie. L'instruction est exécutée au moins une fois. Soyez prudent avec vos boucles Do. Vous pourrez facilement créer des boucles infinies, pour lesquelles votre jeu se perdra et ne réagira plus aux actions du joueur.

Exemple
Le programme suivant essaie de placer l'objet courant à un emplacement libre (c'est identique à l'action qui consiste à déplacer un objet à une position aléatoire).

{
  do
  {
    x = random(room_width);
    y = random(room_height);
  }
  until (place_free(x,y))
}

L'instruction For

for (<instruction 1> ; <expression> ;<instruction 2>) <instruction 3>

Cela fonctionne de la façon suivante. Premièrement, l'instruction 1 est exécutée. Puis l'expression est évaluée. Si celle-ci est vraie, l'instruction 3 sera exécutée. L'instruction 2 puis l'expression sont réévaluées de nouveau. Ce processus se poursuit jusqu'à ce que l'expression soit fausse.

Cela peut vous paraître compliqué mais vous devez interpréter ceci de la manière suivante. La première instruction initialise la boucle For. L'expression teste ensuite si la boucle doit se terminer. L'instruction 2 est l'instruction de saut qui poursuit à la prochaine évaluation de la boucle.

On utilise principalement la boucle For pour créer un compteur dans une certaine plage.

Exemple
Le programme suivant initialise un tableau de longueur 10 avec des valeurs allant de 1 à 10.

{
  for (i=0; i<=9; i+=1) list[i] = i+1;
}

L'instruction Switch

switch (<expression>)
{
  case <expression1>: <instruction 1>; ... ; break;
  case <expression2>: <instruction 2>; ... ; break;
  ...
  default: <instruction>; ...
}

Voici comment cela fonctionne. En premier lieu, l'expression est exécutée. Ensuite, elle est comparée avec les résultats des différentes expressions situées après les instructions Case. L'exécution se poursuit après la première instruction Case en cas d'inégalité, jusqu'à ce que l'instruction Break soit rencontrée. Si aucune instruction Case ne posséde la bonne valeur, l'exécution continue après l'instruction default (il n'est pas obligatoire d'avoir une instruction default). Veuillez noter que plusieurs instructions Case peuvent être placées dans le même bloc d'instructions. Aussi, l'instruction Break n'est pas nécessaire. S'il n'existe pas d'instruction Break, l'exécution se poursuivra simplement à la prochaine instruction Case.

Exemple
Le programme suivant effectue une action selon la touche pressée au clavier.

switch (keyboard_key)
{
  case vk_left:
  case vk_numpad4:
    x -= 4; break;
  case vk_right:
  case vk_numpad6:
    x += 4; break;
}

L'instruction Break

break

Lorsqu'elle est utilisée à l'intérieur des boucles suivantes For, While et Repeat ainsi que dans les instructions Switch ou With, l'instruction Break suspend la boucle ou l'instruction concernée. Si cette instruction est utilisée en dehors de ces dernières, Break arrête le programme (mais pas le jeu).

L'instruction Continue

continue

Si elle est utilisée à l'intérieur des boucles For, While, Repeat ou encore une instruction With, cette instruction continue l'exécution avec la valeur suivante de la boucle ou de l'instruction With.

L'instruction Exit

exit

Cette instruction termine l'exécution du script ou du code programme actuellement en cours d'exécution (cela n'arrête pas l'exécution du jeu ! A cet effet, il existe la fonction game_end(); voir plus loin).

Les Fonctions

<function>(<arg1>,<arg2>,...)

Il existe deux types de fonctions. En premier lieu, nous trouvons un grand nombre de fonctions intégrées, destinées à contrôler tous les aspects de votre jeu. En deuxième lieu, tout script que vous aurez défini dans votre jeu, pourra être utilisé comme fonction.

Veuillez noter que pour une fonction sans argument, il est nécessaire d'utiliser des parenthèses. Certaines fonctions retournent des valeurs qui peuvent être employées dans des expressions. Les autres fonctions exécutent tout simplement des commandes.

Il est impossible d'utiliser une fonction à la gauche d'une affectation. Par exemple, vous ne pouvez pas écrire : instance_nearest(x,y,obj).speed = 0. Par contre, vous pourrez écrire ceci : (instance_nearest(x,y,obj)).speed = 0.

Les Scripts

Les scripts peuvent aussi retourner une valeur. De cette manière, ils peuvent être utilisés dans des expressions. A cet effet, vous utiliserez l'instruction return :

return <expression>

L'exécution du script s'arrêtera à l'instruction return !

Exemple
Vous trouverez ci-dessous un petit script qui calcule le carré de l'argument transmis :

{
  return (argument0*argument0);
}

Pour appeler un script dans du code, il suffit de procéder de la même façon que pour l'appel de fonctions. C'est à dire, écrire le nom du script complété des valeurs d'arguments entre parenthèses.

Constructeur With

ball.y = ball.y + 8;

Mais ceci n'est pas correct. La partie droite de l'affectation reçoit la valeur d'ordonnée y de la première balle puis y ajoute 8. Ensuite, cette nouvelle valeur est assignée à l'ordonnée y de toutes les balles. Ce qui entraîne que toutes les balles possédent désormais la même ordonnée y. L'instruction

ball.y += 8;

produira exactement le même résultat car elle ne constitue simplement qu'une abréviation de la première instruction. Comment donc résoudre ce problème ? En utilisant l'instruction with spécialement conçue pour cela. La forme globale de l'instruction est la suivante :

with (<expression>) <instruction>

<expression> indique une ou plusieurs instances. Vous pouvez utiliser l'ID d'une instance, le nom d'un objet (pour mentionner toutes les instances de cet objet) ou l'un des objets spéciaux (all, self, other, noone). <instruction> sera maintenant exécutée pour chacune des instances indiquées comme si cette instance était l'instance courante (self). Ainsi, pour déplacer toutes les balles de 8 pixels vers le bas, vous devrez par exemple taper ceci :

with (ball) y += 8;

Si vous voulez exécuter plusieurs instructions, entourez-les avec des accolades. Par exemple, pour déplacer toutes les balles vers une position aléatoire, vous pouvez écrire :

with (ball)
{
  x = random(room_width);
  y = random(room_height);
}

Veuillez noter que, pendant ces instructions, l'instance mentionnée devient l'instance self. De la même manière, l'instance originale self devient l'instance other (l'autre instance). Par exemple, pour déplacer toutes les balles vers une position de l'instance courante, tapez ceci :

with (ball)
{
  x = other.x;
  y = other.y;
}

L'utilisation de l'instruction With est extrémement puissante. Vous trouverez ci-dessous quelques exemples. Pour détruire toutes les balles, vous taperez :

with (ball) instance_destroy();

Si une bombe explose et que vous souhaitez détruire toutes les instances touchées, vous pourrez utiliser :

with (all)
{
  if (distance_to_object(other) < 50) instance_destroy();
}

Commentaires

Fonctions et Variables en GML

La convention suivante sera utilisée ici. Les noms de variables signalés avec le caractère * sont en lecture seule (leur valeur ne peut être modifiée). Les noms de variables suivis de [0..n] sont des tableaux. La plage admise des indices sera donnée.

Calculs et traitements

Les Constantes

true est égal à 1.
false est égal à 0.
pi est égal à 3.1415...

Fonctions sur les réels

random(x) Retourne un nombre réel aléatoire entre 0 et x. Le nombre sera toujours plus petit que x.
choose(val1, val2, val3, ...) Retourne l'un des arguments choisi de manière aléatoire. La fonction accepte jusqu'à 16 arguments.
abs(x) Retourne la valeur absolue de x.
sign(x) Retourne le signe de x (-1, 0 ou 1).
round(x) Retourne x arrondi à l'entier le plus proche.
floor(x) Retourne la valeur plancher de x, qui correspond à x arrondi à l'entier juste inférieur.
ceil(x) Retourne la valeur plafond de x, qui correspond à x arrondi à l'entier juste supérieur.
frac(x) Retourne la partie décimale de x, qui correspond à celle juste après le point décimal.
sqrt(x) Retourne la racine carrée de x. x doit être un nombre positif.
sqr(x) Retourne x*x.
power(x, n) Retourne x à la puissance n.
exp(x) Retourne e à la puissance x.
ln(x) Retourne le logarithme naturel de x.
log2(x) Retourne log base 2 de x.
log10(x) Retourne log base 10 de x.
logn(n, x) Retourne log base n de x.
sin(x) Retourne le sinus de x (x exprimé en radians).
cos(x) Retourne le cosinus de x (x exprimé en radians).
tan(x) Retourne la tangente de x (x exprimé en radians).
arcsin(x) Retourne le sinus inverse de x.
arccos(x) Retourne le cosinus inverse de x.
arctan(x) Retourne la tangente inverse de x.
arctan2(y, x) Calcule arctan(Y/X) et retourne un angle dans un quart de cercle.
degtorad(x) Convertit les degrés en radians.
radtodeg(x) Convertit les radians en degrés.
min(val1, val2, val3, ...) Retourne le minimum des valeurs. La fonction accepte jusqu'à 16 arguments. Ceux-ci doivent tous être des réels ou des chaîne de caractères.
max(val1, val2, val3, ...) Retourne le maximum des valeurs. La fonction accepte jusqu'à 16 arguments. Ceux-ci doivent tous être des réels ou des chaîne de caractères.
mean(val1, val2, val3, ...) Retourne la moyenne des valeurs. La fonction accepte jusqu'à 16 arguments. Ceux-ci doivent tous être des réels.
median(val1, val2, val3, ...) Retourne la valeur médiane des valeurs, qui correspond au milieu de la valeur (lorsque le nombre d'arguments est pair,la valeur la plus petite entre les deux valeurs du milieu est retournée). La fonction accepte jusqu'à 16 arguments. Ceux-ci doivent tous être des réels.
point_distance(x1, y1, x2, y2) Retourne la distance entre le point (x1,y1) et le point (x2,y2).
point_direction(x1, y1, x2, y2) Retourne la direction du point (x1,y1) vers le point (x2,y2) en degrés.
lengthdir_x(len, dir) Retourne le composant x horizontal du vecteur, déterminé par la longueur indiquée et la direction.
lengthdir_y(len, dir) Retourne le composant y vertical du vecteur, déterminé par la longueur indiquée et la direction.
is_real(x) Retourne si x est un nombre réel (en opposition à une chaîne).
is_string(x) Retourne si x est une chaîne (en opposition à un réel).

Fonctions opérant sur des chaînes de caractères

chr(val) Retourne une chaîne contenant le caractère de code asci val.
ord(str) Retourne le code asci du premier caractère de str.
real(str) Transforme str en un nombre réel. str peut contenir un signe moins, un point décimal et même une partie exponentielle.
string(val) Transforme la valeur réelle en une chaîne de caractères en utilisant un format standard (aucune position décimale lorsqu'il s'agit d'un entier et deux positions décimales dans les autres cas).
string_format(val, tot, dec) Transforme val en une chaîne en utilisant votre propre format: tot indique le nombre total de positions et dec le nombre de positions décimales.
string_length(str) Retourne le nombre de caractères de la chaîne.
string_pos(substr, str) Retourne la position de substr dans str (0=pas d'occurrence).
string_copy(str, index, count) Retourne une sous-chaîne de str, débutant à la position index et de longueur count.
string_char_at(str, index) Retourne le caractère de str à la position index.
string_delete(str, index, count) Retourne une copie de str amputée d'une partie commençant à la position index et de longueur count.
string_insert(substr, str, index) Retourne une copie de str avec ajout de substr à la position index.
string_replace(str, substr, newstr) Retourne une copie de str avec la première occurrence de substr remplacée par newstr.
string_replace_all(str, substr, newstr) Retourne une copie de str avec toutes les occurrences de substr remplacées par newstr.
string_count(substr, str) Retourne le nombre d'occurrences de substr dans str.
string_lower(str) Retourne une copie en minuscule de str.
string_upper(str) Retourne une copie en majuscule de str.
string_repeat(str, count) Retourne une chaîne comprenant count copies de str.
string_letters(str) Retourne une chaîne qui ne contient que les lettres de str.
string_digits(str) Retourne une chaîne qui ne contient que les chiffres de str.
string_lettersdigits(str) Retourne une chaîne qui ne contient que les lettres et les chiffres de str.

Les fonctions suivantes traitent du presse-papier pour stocker du texte.

clipboard_has_text() Retourne si présence de texte dans le presse-papier.
clipboard_get_text() Retourne le texte courant du presse-papier.
clipboard_set_text(str) Mets la chaîne str dans le presse-papier.

Fonctions sur les dates et le temps

date_current_datetime() Retourne la valeur date-heure correspondant à l'instant présent.
date_current_date() Retourne la valeur date-heure correspondant à la date courante uniquement (on ignore l'heure).
date_current_time() Retourne la valeur date-heure correspondant à l'heure courante uniquement (on ignore la date).
date_create_datetime(year, month, day, hour, minute, second) Crée une valeur date-heure correspondant à la date et l'heure indiquées.
date_create_date(year, month, day) Crée une valeur date-heure correspondant à la date indiquée.
date_create_time(hour, minute, second) Crée une valeur date-heure correspondant à l'heure indiquée.
date_valid_datetime(year, month, day, hour, minute, second) Retourne si la date et l'heure indiquées sont valides.
date_valid_date(year, month, day) Retourne si la date indiquée est valide.
date_valid_time(hour, minute, second) Retourne si l'heure indiquée est valide.
date_inc_year(date, amount) Retourne une nouvelle date qui est le nombre d'années après la date indiquée. amount doit être un nombre entier.
date_inc_month(date, amount) Retourne une nouvelle date qui est le nombre de mois après la date indiquée. amount doit être un nombre entier.
date_inc_week(date, amount) Retourne une nouvelle date qui est le nombre de semaines après la date indiquée. amount doit être un nombre entier.
date_inc_day(date, amount) Retourne une nouvelle date qui est le nombre de jours après la date indiquée. amount doit être un nombre entier.
date_inc_hour(date, amount) Retourne une nouvelle date qui est le nombre d'heures après la date indiquée. amount doit être un nombre entier.
date_inc_minute(date, amount) Retourne une nouvelle date qui est le nombre de minutes après la date indiquée. amount doit être un nombre entier.
date_inc_second(date, amount) Retourne une nouvelle date qui est le nombre de secondes après la date indiquée. amount doit être un nombre entier.
date_get_year(date) Retourne l'année correspondant à la date.
date_get_month(date) Retourne le mois correspondant à la date.
date_get_week(date) Retourne la semaine de l'année correspondant à la date.
date_get_day(date) Retourne le jour du mois correspondant à la date.
date_get_hour(date) Retourne l'heure correspondant à la date.
date_get_minute(date) Retourne la minute correspondant à la date.
date_get_second(date) Retourne la seconde correspondant à la date.
date_get_weekday(date) Retourne le jour de la semaine correspondant à la date.
date_get_day_of_year(date) Retourne le jour de l'année correspondant à la date.
date_get_hour_of_year(date) Retourne l'heure de l'année correspondant à la date.
date_get_minute_of_year(date) Retourne la minute de l'année correspondant à la date.
date_get_second_of_year(date) Retourne la seconde de l'année correspondant à la date.
date_year_span(date1, date2) Retourne le nombre d'années entre deux dates. Les années incomplétes seront exprimées sous forme de fraction.
date_month_span(date1, date2) Retourne le nombre de mois entre deux dates. Les mois incomplets seront exprimés sous forme de fraction.
date_week_span(date1, date2) Retourne le nombre de semaines entre deux dates. Les semaines incomplétes seront exprimées sous forme de fraction.
date_day_span(date1, date2) Retourne le nombre de jours entre deux dates. Les jours incomplets seront exprimés sous forme de fraction.
date_hour_span(date1, date2) Retourne le nombre d'heures entre deux dates. Les heures incomplétes seront exprimées sous forme de fraction.
date_minute_span(date1, date2) Retourne le nombre de minutes entre deux dates. Les minutes incomplétes seront exprimées sous forme de fraction.
date_second_span(date1, date2) Retourne le nombre de secondes entre deux dates. Les secondes incomplétes seront exprimées sous forme de fraction.
date_compare_datetime(date1, date2) Compare les deux valeurs date-heure. Retourne -1, 0, ou 1 selon que la première valeur soit plus petite, égale ou plus grande que la seconde valeur.
date_compare_date(date1, date2) Compare les deux valeurs date-heure en ne prenant en compte que l'aspect date. Retourne -1, 0, ou 1 selon que la première valeur soit plus petite, égale ou plus grande que la seconde valeur.
date_compare_time(date1, date2) Compare les deux valeurs date-heure en ne prenant en compte que l'aspect heure. Retourne -1, 0, ou 1 selon que la première valeur soit plus petite, égale ou plus grande que la seconde valeur.
date_date_of(date) Retourne la partie de la date de la valeur date-heure indiquée, en initialisant à 0 la partie heure.
date_time_of(date) Retourne la partie heure de la valeur date-heure indiquée, en initialisant à 0 la partie date.
date_datetime_string(date) Retourne une chaîne indiquant la date et l'heure fournies dans le format par défaut du système.
date_date_string(date) Retourne une chaîne indiquant la date fournie dans le format par défaut du système.
date_time_string(date) Retourne une chaîne indiquant l'heure fournie dans le format par défaut du système.
date_days_in_month(date) Retourne le nombre de jours du mois indiqué dans la valeur date-heure.
date_days_in_year(date) Retourne le nombre de jours de l'année indiquée dans la valeur date-heure.
date_leap_year(date) Retourne si l'année indiquée dans la valeur date-heure est une année bissextile.
date_is_today(date) Retourne si la valeur date-heure indiquée représente aujourd'hui.

Gameplay

Des informations sur le gameplay peuvent être trouvées dans les pages suivantes :

Les Déplacements
Les chemins
La Planification des Mouvements
La Détection des Collisions
Les Instances
La Désactivation des Instances
Le Timing
Les Rooms
Le Score
La Génération des Evénements
Variables et Fonctions Diverses

Les Déplacements

Si l'objet doit se déplacer avec une vitesse et une direction constantes, il y a une façon plus simple de réaliser tout cela. Chaque instance d'objet posséde une vitesse horizontale (hspeed) et verticale (vspeed). Ces deux paramétres sont exprimés en pixels par step. Une vitesse positive horizontale indique un mouvement vers la droite, une vitesse négative horizontale signifie un déplacement vers la gauche. Une vitesse positive verticale mentionne un mouvement vers le bas tandis qu'une vitesse négative verticale un déplacement vers le haut. Vous ne devrez intialiser ces variables qu'une seule fois (par exemple dans l'événement de création) afin de donner à l'instance d'objet un mouvement constant.

Il y a plusieurs façons d'indiquer un mouvement, en utilisant une direction (en degrés 0-359) et une vitesse (ne doit pas être négative). Vous pouvez fixer et lire ces variables pour spécifier un déplacement arbitraire (en interne, cela concerne les valeurs hspeed et vspeed.) Il existe également la friction, la gravité et la direction de la gravité. Enfin, il y a la fonction motion_add(dir,speed) qui ajoute un déplacement à l'actuel mouvement.

Pour être complet, chaque instance posséde les variables et les fonctions suivantes ayant traits à leur position et leur déplacement :

x sa position en x.
y sa position en y.
xprevious sa position précédente en x.
yprevious sa position précédente en y.
xstart sa position de départ en x dans la room.
ystart sa position de départ en y dans la room.
hspeed composant horizontal de la vitesse.
vspeed composant vertical de la vitesse.
direction sa direction courante (0-360, sens contraire des aiguilles d'une montre, 0 = vers la droite).
speed sa vitesse actuelle (pixels par step).
friction friction actuelle (pixels par step).
gravity valeur actuelle de la gravité (pixels par step).
gravity_direction direction de la gravité (270 indique vers le bas).
motion_set(dir, speed) paramètre le déplacement avec la vitesse indiquée vers la direction dir.
motion_add(dir, speed) additionne le mouvement à l'actuel mouvement (addition de vecteurs).

Il existe une grande quantité de fonctions disponibles qui vous aideront à définir vos mouvements :

place_free(x, y) Retourne si l'instance placée à la position (x,y) est hors collision. On l'utilise habituellement comme vérification avant de déplacer l'instance à sa nouvelle position.
place_empty(x, y) Retourne si l'instance placée à la position (x,y) rencontre quelque chose. Cette fonction prend également en compte les instances non solides.
place_meeting(x, y, obj) Retourne si l'instance placée à la position (x,y) rencontre obj. obj peut être un objet auquel cas la fonction retourne true (VRAI) si une instance de cet objet est rencontrée. Cela peut aussi être un ID d'instance, le mot spécial all indiquant une instance d'un objet quelconque ou le mot spécial other.
place_snapped(hsnap, vsnap) Retourne si l'instance est alignée avec les valeurs de rupture.
move_random(hsnap, vsnap) Déplace l'instance à une position libre, à une position de rupture, comme l'action correspondante.
move_snap(hsnap, vsnap) Snaps the instance, like the corresponding action. (NDT : quelle est la traduction de cette phrase ?)
move_wrap(hor, vert, margin) Place l'instance de l'autre côté lorsque celle-ci a quitté la room. hor indique si l'on doit la placer horizontalement et vert verticalement. margin indique à quelle distance l'origine de l'instance doit être en dehors de la room avant que le placement n'intervienne. C'est donc une marge par rapport aux bords de la room. Vous utiliserez habituellement cette fonction dans l'événement Outside.
move_towards_point(x, y, sp) Déplace les instances avec la vitesse sp vers la position (x,y).
move_bounce_solid(adv) Rebondit contre les instances solides, comme l'action correspondante. adv indique si l'on doit employer le rebond anticipé qui prend également en compte les murs inclinés.
move_bounce_all(adv) Rebondit contre toutes les instances, au lieu de ne prendre en compte que les instances solides.
move_contact_solid(dir, maxdist) Déplace les instances dans la direction donnée jusqu'à ce qu'elles entrent en contact avec un objet solide. Si aucune collision ne se produit à la position courante, l'instance sera placée juste avant qu'une collision ne survienne. Si il y a déjà une collision, l'instance ne sera pas déplacée. Vous pouvez indiquer la distance maximale pour le déplacement (utilisez un nombre négatif pour avoir une distance arbitraire).
move_contact_all(dir, maxdist) Mémes effets que la fonction précédente mais cette fois, l'instance sera stoppée si elle entre en contact avec un objet quelconque et non pas uniquement avec un objet solide.
move_outside_solid(dir, maxdist) Déplace l'instance dans la direction jusqu'à ce qu'elle ne se trouve plus en contact avec un objet solide. S'il n'y pas de collision à la position courante, l'instance ne sera pas déplacée. Vous pouvez indiquer la distance maximale pour le déplacement (utilisez un nombre négatif pour avoir une distance arbitraire).
move_outside_all(dir, maxdist) Mêmes effets que la fonction précédente mais cette fois-ci, vous déplacerez l'instance jusqu'à ce qu'elle ne se trouve plus en contact avec un objet quelconque et non pas uniquement avec un objet solide.
distance_to_point(x, y) Retourne la distance de la boîte de rebond de l'instance courante par rapport à (x,y).
distance_to_object(obj) Retourne la distance de l'instance par rapport à la plus proche instance de l'objet obj.
position_empty(x, y) Retourne s'il n'y a rien à la position (x,y).
position_meeting(x, y, obj) Retourne si à la position (x,y), il y a une instance obj. obj peut être un objet, un ID d'une instance ou les mots-clés self, other ou all.

Les chemins

path_start(path, speed, endaction, absolute) Débute l'exécution du chemin pour l'instance courante. La valeur path correspond au nom du chemin à suivre par l'instance. La valeur speed est la vitesse à laquelle le chemin doit être parcouru. Une vitesse négative signifie que l'instance se déplace en sens inverse le long du chemin. La valeur endaction indique ce qui doit se passer lorsque la fin du chemin est atteinte. Les valeurs suivantes peuvent être utilisées :

0 : stoppe le chemin
1: continue à partir de la position de départ du chemin (si le chemin n'était pas totalement parcouru, il y aura saut à la position de départ)
2: continue à partir de la position courante
3: inverse le chemin, c'est à dire change le signe de la vitesse

L'argument absolute devra être soit true soit false. Lorsqu'il est à true, les coordonnées absolues du chemin sont utilisées. Quand il est à false le chemin est relatif à la position courante de l'instance. Pour être plus précis, si la vitesse est positive, le point de départ du chemin sera placé à la position courante et le chemin sera suivi à partir de cette position. Si la vitesse est négative, le point final du chemin sera placé à la position courante et le chemin sera suivi en sens inverse à partir de cette position.
path_end() Suspend le parcours du chemin pour l'instance courante.
path_index* Index du chemin actuel suivi par l'instance. Il ne vous est pas possible de le modifier directement mais est utilisé par la fonction ci-dessus.
path_position Position du chemin actuel. 0 est le début du chemin tandis que 1 correspond à la fin. La valeur doit être comprise entre 0 et 1.
path_positionprevious Position précédente du chemin actuel. On l'utilise par exemple dans les événements de collision pour paramétrer la position du chemin à sa position précédente.
path_speed Vitesse (en pixels par step) à laquelle le chemin doit être parcouru. Utilisez une vitesse négative pour inverser le sens du déplacement.
path_orientation Orientation (sens contraire des aiguilles d'une montre) vers laquelle le chemin est dirigé. 0 correspond à l'orientation normale du chemin.
path_scale Mise à l'échelle du chemin. Augmentez cette valeur pour créer un chemin plus long. 1 est la valeur par défaut.
path_endaction L'action à exécuter en fin de chemin. Vous pouvez utiliser les valeurs indiquées ci-dessus.

La Planification des Mouvements

Différentes formes de planification de mouvements sont déjà fournies avec Game Maker. La forme la plus simple force une instance à se diriger vers une position cible particulière, en essayant d'aller en ligne droite si possible mais en prenant une direction différente si c'est nécessaire. Ces fonctions doivent être utilisées en général dans l'événement step d'une instance. Elles sont similaires à la planification de mouvements proposée par les actions :

mp_linear_step(x, y, stepsize, checkall) Cette fonction déplace d'un step l'instance directement vers la position (x,y) indiquée. La taille du step est indiquée grâce au paramètre stepsize. Si l'instance est déjà à cette position, elle ne sera pas déplacée. Si checkall est à true, l'instance s'arrêtera lorsqu'elle entrera en contact avec une instance d'un objet quelconque. Si ce paramétre est à false, l'instance s'arrêtera uniquement quand elle heurtera une instance solide. Veuillez noter que cette fonction ne tentera pas de faire des détours si l'instance rencontre un obstacle. Elle échouera simplement dans ce cas. La fonction retourne si oui ou non la position cible a été atteinte.
mp_linear_step_object(x, y, stepsize, obj) Mêmes effets que la fonction ci-dessus mais cette fois, seules les instances de obj seront considérées comme des obstacles. obj peut être un objet ou encore un ID d'une instance.
mp_potential_step(x, y, stepsize, checkall) De la même façon que les fonctions précédentes, cette fonction déplace d'un step l'instance en direction d'une position particulière. Mais dans ce cas précis, elle essayera d'éviter les obstacles. Quand l'instance se dirigera vers une instance solide (ou n'importe laquelle instance si le paramètre checkall vaut true), elle changera la direction du mouvement afin d'éviter l'instance et la contournera. Le fonctionnement n'est pas guarantie mais dans la plupart des cas, cette fonction déplacera l'instance vers la cible. La fonction retourne si la cible a été atteinte ou pas.
mp_potential_step_object(x, y, stepsize, obj) Identique à la fonction ci-dessus mais cette fois, seules les instances obj seront considérées comme des obstacles. obj peut être soit un objet soit un ID d'une instance.
mp_potential_settings(maxrot, rotstep, ahead, onspot) La fonction précédente effectue son travail en utilisant un certain nombre de paramètres pouvant être modifiés en utilisant la fonction. Globalement, cette méthode fonctionne de la manière suivante. Elle tente en premier lieu de déplacer directement l'instance vers la cible. Elle regarde un certain nombre de steps en avant, ce nombre pouvant être réglé avec le paramètre ahead (3 par défaut). Réduire cette valeur signifie que l'instance commencera à changer de direction plus tardivement. L'augmenter indiquera que l'instance débutera son changement de direction plus tôt. Si ce contrôle mène à une collision, elle commencera à regarder dans les directions les plus à gauche et les plus à droite afin de déterminer la meilleure direction. Elle effectue cela en utilisant des steps de taille rotstep (10 par défaut). En réduisant ce paramètre, cela donnera à l'instance plus de mouvements possibles mais cela ralentira le processus. Le paramètre maxrot est un peu plus difficile à expliquer. L'instance posséde une direction courante. maxrot (30 par défaut) indique combien de changements de direction l'instance est autorisée à changer sa direction actuelle dans un step. Aussi, même si elle peut se déplacer vers la cible par exemple en ligne droite, elle le fera uniquement si elle ne transgresse pas le nombre maximal de changements de direction. Si vous donnez à maxrot une valeur plus grande, l'instance pourra changer davantage de directions à chaque step. Cela rendra plus facile la recherche du chemin le plus court mais le chemin obtenu sera plus tortueux. Si vous diminuer cette valeur, le chemin sera plus coulé mais vous obtiendrez davantage de détours (et parfois, la recherche de la cible échouera). Si aucun step ne peut être effectué, le comportement dépendera de la valeur du paramètre onspot. Si la valeur de onspot est true (la valeur par défaut), l'instance effectuera une rotation sur son spot selon la valeur indiquée par maxrot. Si la valeur est false, l'instance ne bougera pas du tout. Paramètrer cette valeur à false sera utile par exemple pour des voitures mais réduira la probabilité de trouver un chemin.

Veuillez noter que l'approche potentielle utilise uniquement des information locales. Aussi, elle ne pourra trouver un chemin que si ces informations locales sont suffisantes pour déterminer la bonne direction de mouvement. Par exemple, la recherche du chemin hors d'un labyrinthe échouera la plupart du temps.

Le deuxième type de fonctions détermine pour l'instance un chemin exempt de collision. Une fois ce chemin déterminé, vous pourrez l'assigner à l'instance afin de la diriger vers la cible. Le calcul du chemin prend un certain temps mais ensuite, l'exécution du chemin sera rapide. Bien entendu, ce chemin sera valide si seulement la situation n'a pas changé entre temps. Par exemple, si des obstacles se sont déplacés, vous devrez certainement recalculer le chemin. Veuillez remarquer que ces fonctions peuvent également échouer. Ces fonctions sont uniquement disponibles dans la version enregistrée de Game Maker.

Les deux premières fonctions utilisent le déplacement linéaire et une approche de champs potentiel utilisés également dans les fonctions step.

mp_linear_path(path, xg, yg, stepsize, checkall) Cette fonction calcule un chemin en ligne droite pour l'instance de sa position courante vers la position (xg,yg) en utilisant la taille step indiquée. Elle utilise les steps comme dans la fonction mp_linear_step(). Le chemin mentionné doit déjà exister et sera écrasé par le nouveau chemin (se reporter au chapître ultérieur pour savoir comment créer et détruire les chemins). La fonction retournera si un chemin a pu être trouvé. La fonction s'arrêtera et signalera une erreur si aucun chemin direct n'existe entre le début et la cible. En cas d'échec, un chemin sera toujours créé qui s'exécutera à partir de la position où l'instance a été bloquée.
mp_linear_path_object(path, xg, yg, stepsize, obj) Identique à la fonction ci-dessus mais cette fois, seules les instances obj seront considérées comme des obstacles. obj peut être soit un objet soit un ID d'une instance.
mp_potential_path(path, xg, yg, stepsize, factor, checkall) Cette fonction calcule un chemin pour l'instance de sa position courante et en orientation vers la position (xg,yg) en utilisant la taille step indiquée, tout en tentant d'éviter les collisions avec les obstacles. Elle utilise des steps de champs potentiel, comme dans la fonction mp_potential_step() mais aussi des paramètres que l'on peut régler avec mp_potential_settings(). Le chemin indiqué doit déjà exister et sera écrasé par le nouveau chemin (se reporter au chapître ultérieur pour savoir comment créer et détruire les chemins). La fonction retournera si un chemin a pu être trouvé. Afin d'éviter que la fonction continue son calcul indéfiniement, vous devrez fournir un facteur de temps supérieur à 1. La fonction s'arrêtera et signalera une erreur si elle n'a pu déterminer un chemin plus court durant ce laps de temps entre le début et la cible. Un facteur de 4 devrait normalement être suffisant mais si vous souhaitez faire de plus longs détours, il sera peut-être souhaitable de choisir une valeur encore plus grande. En cas d'échec, un chemin sera toujours créé en direction de la cible qui cependant ne sera jamais atteinte.
mp_potential_path_object(path, xg, yg, stepsize, factor, obj) Idem que la fonction précédente sauf que seules les instances obj seront considérées comme des obstacles. obj peut être soit un objet soit un ID d'une instance.

Les autres fonctions utilisent un mécanisme beaucoup plus complexe et sophistiqué via une approche basée sur les grilles (appelée parfois algorithme A*). Cette approche est plus efficace en terme de recherche de chemins (bien qu'elle puisse aussi échouer !) et détermine des chemins généralement plus courts mais nécessite davantage de travail de votre part. L'idée générale est la suivante. En premier lieu, nous plaçons une grille à l'endroit le plus approprié de la room. Vous pouvez choisir d'utiliser une grille avec un maillage fin (ce qui sera plus lent) ou une grille brute. Ensuite, pour tous les objets concernés, nous déterminons les cellules de la grille qui recouvrent les objets (en utilisant soit des boîtes de rebonds ou soit un contrôle précis) et marquons ces cellules comme étant interdites. Ainsi, une cellule sera marquée comme totalement interdite, même si elle recouvre partiellement un obstacle. Enfin, nous indiquerons une position de départ et une position cible (qui ne pourra être que parmi les cellules libres) puis la fonction déterminera par elle-même le chemin le plus court (le plus proche théoriquement du plus court) entre ces positions. Le chemin s'exécutera entre les centres des cellules libres. Ainsi, si les cellules sont suffisamment grandes de façon à ce que l'instance placée en son centre soit complétement à l'intérieur, le résultat sera concluant. Vous pourrez ensuite donner ce chemin à une instance pour qu'elle le suive.

L'approche basée sur les grilles est très puissante (elle est d'ailleurs utilisée dans de nombreux jeux professionels) mais demande de votre part une plus grande réflexion. Vous devrez déterminer quelle est la zone et la taille de cellule les mieux adaptées pour résoudre le problème. Vous devrez aussi déterminer quels objets doivent être évités et si une vérification précise est nécessaire pour effectuer ce travail. Tous ces paramètres auront une grande influence sur l'efficacité de cette approche.

En particulier, la taille des cellules est cruciale. Souvenez-vous que les cellules doivent être assez grandes de manière à ce que l'objet en déplacement et placé en son origine au centre d'une cellule, demeure complétement à l'intérieur de la cellule (soyez prudent en ce qui concerne la position de l'origine de l'objet. Pensez à décaler le chemin si l'origine de l'objet n'est pas bien au centre !) D'un autre côté, plus les cellules seront petites et plus il existera de chemins possibles. Si vous créez des cellules trop grandes, les ouvertures entre les obstacles pourront être fernées car toutes les cellules rentreront en intersection avec un obstacle.

Les fonctions actuelles concernant l'approche basée sur les grilles, sont les suivantes :

mp_grid_create(left, top, hcells, vcells, cellwidth, cellheight) Cette fonction crée la grille. Elle retourne un index qui devra être utilisé dans tous les autres appels. Vous pouvez créer et gérer plusieurs structures de grilles en même temps. left (gauche) et top (haut) indiquent la position du coin supérieur gauche de la grille. hcells et vcells indiquent le nombre de cellules horizontales et verticales. Enfin, cellwidth et cellheight indiquent la taille des cellules.
mp_grid_destroy(id) Détruit la structure de la grille indiquée et libére la mémoire occupée. N'oubliez-pas d'appeler cette fonction si vous n'avez plus besoin de la structure.
mp_grid_clear_all(id) Marque toutes les cellules de la grille comme libres.
mp_grid_clear_cell(id, h, v) Efface la cellule indiquée. La cellule 0,0 correspond à la cellule en haut à gauche.
mp_grid_clear_rectangle(id, left, top, right, bottom) Efface toutes les cellules qui sont en intersection avec le rectangle indiqué (dans les coordonnées de la room).
mp_grid_add_cell(id, h, v) Marque les cellules indiquées comme étant interdites. La cellule 0,0 correspond à la cellule en haut à gauche.
mp_grid_add_rectangle(id, left, top, right, bottom) Marque toutes les cellules qui sont en intersection avec le rectangle indiqué comme étant interdites.
mp_grid_add_instances(id, obj, prec) Marque toutes les cellules qui sont en intersection avec une instance d'un objet donné comme êtant interdites. Vous pouvez également utiliser une instance individuelle en donnant à obj l'ID de l'instance. Vous pouvez aussi employer le mot-clé all pour indiquer toutes les instances de tous les objets. prec indique si l'on doit utiliser une vérification précise dans les collisions (ne fonctionnera que si le paramètre contrôle précis a été coché pour le sprite utilisé par l'instance).
mp_grid_path(id, path, xstart, ystart, xgoal, ygoal, allowdiag) Détermine un chemin à l'aide de la grille. path doit mentionner un chemin existant qui sera remplacé par le chemin calculé par l'ordinateur. xstart et ystart indiquent le début du chemin et xgoal et ygoal la cible. allowdiag indique si les mouvements en diagonal sont autorisés au lieu de ne considérer que ceux horizontaux ou verticaux. La fonction retourne si elle a réussi à déterminer un chemin (veuillez noter que le chemin est indépendant de l'instance courante; c'est un chemin calculé dans la grille et non pas un chemin pour une instance particulière).
mp_grid_draw(id) Cette fonction dessine la grille avec les cellules libres de couleur verte et les cellules interdites en rouge. Cette fonction est assez lente et n'est généralement utilisée que dans les outils de déboguage.

La Détection des Collisions

collision_point(x, y, obj, prec, notme) Cette fonction teste si une collision se produit au point (x,y) avec les entités de l'objet obj.
collision_rectangle(x1, y1, x2, y2, obj, prec, notme) Cette fonction teste s'il existe une collision entre le rectangle (plein) de coins opposés indiqués et les entités de l'objet obj. Par exemple, vous pouvez utiliser cette fonction pour tester si une zone est sans obstacles.
collision_circle(xc, yc, radius, obj, prec, notme) Cette fonction teste s'il y a une collision entre le cercle (plein) centré à la position (xc,yc) d'un rayon donné et les entités de l'objet obj. Par exemple, vous pouvez l'utiliser pour tester si un objet est proche d'un emplacement particulier.
collision_ellipse(x1, y1, x2, y2, obj, prec, notme) Cette fonction teste s'il y collision entre l'ellipse (pleine) de coins opposés indiqués et les entités de l'objet obj.
collision_line(x1, y1, x2, y2, obj, prec, notme) Cette fonction teste s'il se produit une collision entre la ligne droite positionnée de (x1,y1) à (x2,y2) et les entités de l'objet obj. Ceci est une fonction très puissante. Vous pouvez ainsi l'utiliser pour tester si une instance peut en apercevoir une autre en vérifiant si la ligne droite entre les deux instances ne rentre pas par exemple en intersection avec un mur.

Les Instances

object_index* L'index de l'objet d'une instance. Cette variable ne peut être modifiée.
id* L'unique identificateur de l'instance (>= 100 000) (veuillez noter que lors de la définition de rooms, l'ID de l'instance est toujours signalé en plaçant la souris au dessus de cette instance.)
mask_index L'index du sprite utilisé comme masque de collisions. Donnez à cet index la valeur -1 pour lui affecter la même valeur que sprite_index.
solid Indique si l'instance est de type solide. Ceci peut être modifié durant le jeu.
persistent Indique si l'instance est persistante et doit réapparaître lorsque vous changez de room. Vous souhaiterez souvent mettre la persistence à off à certains moments (par exemple si vous retournez à la première room.)

Il subsiste un problème avec les instances. Il n'est pas très facile d'identifier les instances de manière individuelle. Elles ne possédent pas de nom. En présence d'une unique instance d'un objet particulier, il vous est possible d'utiliser le nom de l'objet mais dans les autres cas, il est nécessaire d'employer l'ID de l'instance. C'est l'unique identifiant de l'instance. Vous pouvez l'utiliser dans les instructions with en tant qu'identificateur d'objet. Heureusement, il existe un certain nombre de variables et de routines qui vous aideront à localiser les ID des instances.

instance_count* Nombre d'instances qui existent actuellement dans la room.
instance_id[0..n-1]* L'ID d'une instance particulière. n représente ici le numéro de l'instance.

Veuillez prendre note que l'affectation des ID aux instances varie à chaque step. Aussi, vous ne pouvez pas utiliser les valeurs issues des steps précédents. Voici un exemple afin de mieux comprendre. Supposons que chaque unité de votre jeu posséde une puissance particulière et que vous souhaitiez localiser la plus résistante, vous pourriez écrire alors le code suivant :

{
  maxid = -1;
  maxpower = 0;
  for (i=0; i<instance_count; i+=1)
  {
    iii = instance_id[i];
    if (iii.object_index == unit)
    {
      if (iii.power > maxpower)
        {maxid = iii; maxpower = iii.power;}
    }
  }
}

Après exécution de la boucle, la variable maxid contiendra l'ID de l'unité la plus puissante (ne supprimez jamais les instances lors de l'exécution de boucles car elles seraient automatiquement supprimées du tableau et vous obtiendriez comme résultat des instances manquantes).

instance_find(obj, n) Retourne l'ID de l'instance (n+1) de type obj. obj peut être un objet ou le mot-clé all. S'il n'existe pas, l'objet spécial noone sera retourné. Notez que l'affectation des ID aux instances varie à chaque step. Aussi, vous ne pouvez pas utiliser les valeurs issues des steps précédents.
instance_exists(obj) Retourne s'il existe une instance de type obj. obj peut être un objet, un ID d'instance ou le mot-clé all.
instance_number(obj) Retourne le nombre d'instances de type obj. obj peut être un objet ou le mot-clé all.
instance_position(x, y, obj) Retourne l'ID de l'instance de type obj à la position (x,y). Lorsque plusieurs instances sont à la même position, seule la première est retournée. obj peut être un objet ou le mot-clé all. Si celui n'existe pas, l'objet spécial noone sera retourné.
instance_nearest(x, y, obj) Retourne l'ID de l'instance de type obj la plus proche de (x,y). obj peut être un objet ou le mot-clé all.
instance_furthest(x, y, obj) Retourne l'ID de l'instance de type obj la plus éloignée de (x,y). obj peut être un objet ou le mot-clé all.
instance_place(x, y, obj) Retourne l'ID de l'instance de type obj rencontré quand l'instance courante est placée à la position (x,y). obj peut être un objet ou le mot-clé all. S'il n'existe pas, l'objet spécial noone sera retourné.

Les fonctions suivantes peut être utilisées pour la création et la destruction d'instances.

instance_create(x, y, obj) Crée une instance de obj à la position (x,y). La fonction retourne l'ID de la nouvelle instance.
instance_copy(performevent) Crée une copie de l'instance courante. L'argument indique si l'événement de création doit être exécuté pour la copie. La fonction retourne l'ID de la nouvelle copie.
instance_destroy() Détruie l'instance courante.
instance_change(obj, perf) Change l'instance en obj. perf indique si l'on doit effectuer les événements de destruction et de création.
position_destroy(x, y) Détruie toutes les instances pour lesquelles le sprite se situe à la position (x,y).
position_change(x, y, obj, perf) Change toutes les instances à la position (x,y) en obj. perf signifie que l'on doit effectuer les événements de destruction et de création.

La Désactivation des Instances

Lorsque vous désactivez des instances, celles-ci sont en quelque sorte retirées du jeu. Elles ne sont donc plus visibles nulle part et leurs événements ne sont plus exécutés. Ainsi, pour toutes les actions et fonctions, elles n'existent plus. Cela économise beaucoup de temps mais vous devrez cependant être prudent. Par exemple, si vous effacez toutes les instances d'un type particulier, les instances désactivées ne seront pas effacées (car elles n'existent plus). Aussi, ne pensez pas qu'une clé en possession d'un joueur peut ouvrir une porte désactivée si cette instance n'existe plus.

L'erreur la plus importante que vous pouvez commettre est de désactiver l'instance qui est responsable elle-même de l'activation. Pour éviter cette situation, certaines routines ci-dessous vous autorisent à préciser quelles doivent être les instances appelantes ne pouvant se désactiver par elles-mêmes.

Voici les routines disponibles :

instance_deactivate_all(notme) Désactive toutes les instances de la room. Si notme est positionné à true, l'instance appelante n'est pas désactivée (ce qui sera habituellement le résultat souhaité).
instance_deactivate_object(obj) Désactive toutes les instances de la room d'un objet donné. Vous pouvez également utiliser le mot all pour indiquer que toutes les instances doivent être désactivées ou l'ID d'une instance pour désactiver une instance particulière.
instance_deactivate_region(left, top, width, height, inside, notme) Désactive toutes les instances de la région indiquée (c'est à dire celles dont la boîte de rebond est en partie à l'intérieur de la région). Si inside vaut false , les instances totalement en dehors de la région seront désactivées. Si notme est à true, l'instance appelante ne sera pas désactivée (c'est ce que généralement vous désirerez).
instance_activate_all() Active toutes les instances de la room.
instance_activate_object(obj) Active toutes les instances de la room d'un objet donné. Vous pouvez employer le mot all pour indiquer que toutes les instances doivent être activées ou encore l'ID d'une instance pour activer cette instance individuellement.
instance_activate_region(left, top, width, height, inside) Active toutes les instances de la région indiquée. Si inside vaut false, les instance totalement en dehors de la région seront activées.

Par exemple, pour désactiver toutes les instances hors de la vue et activer celles à l'intérieur de cette vue, vous pourriez employer le code suivant dans l'événement step du personnage en déplacement :

{
  instance_activate_all();
  instance_deactivate_region(view_xview[0],view_yview[0],
                        view_wview[0],view_hview[0],false,true);
}

En pratique, il est préférable d'utiliser une région légérement plus grande que la vue.

Le Timing

room_speed Vitesse de jeu de la room courante (en steps par seconde).
fps* Nombre d'images (frames) actuellement affichées par seconde.
current_time* Nombre de millisecondes écoulées depuis le démarrage du système.
current_year* L'année en cours.
current_month* Le mois en cours.
current_day* Le jour actuel.
current_weekday* L'actuel jour de la semaine (1=dimanche, ..., 7=samedi).
current_hour* L'heure courante.
current_minute* La minute courante.
current_second* La seconde courante.

Parfois, vous souhaiterez suspendre le jeu pendant un court instant. A cet effet, vous utiliserez la fonction sleep.

sleep(numb) Suspend le jeu pendant numb millisecondes.

Comme vous le savez déjà, chaque instance posséde 12 alarmes d'horloge différentes que vous pouvez paramétrer. Pour modifier (ou lire) les valeurs des différentes alarmes, utilisez la variable suivante :

alarm[0..11] Valeur de l'alarme d'horloge indiquée (noter que les alarmes d'horloges ne sont mises à jour que lorsque l'événement d'alarme de l'objet contient des actions !)

Nous avons déjà vu que pour assurer une gestion complexe du timing, nous pouvions utiliser la ressource appelée ligne de temps. On peut associer à chaque instance une ressource ligne de temps. Les variables suivantes concernent cet aspect :

timeline_index Index de la ligne de temps associée à l'instance. Vous pouvez modifier cet index pour utiliser une position particulière de la ligne de temps. Réglez cet index à -1 pour arrêter l'utilisation de la ligne de temps affectée à l'instance.
timeline_position Actuelle position de la ligne de temps. Vous pouvez modifier la position afin de sauter ou répéter certaines parties de la ligne de temps.
timeline_speed Habituellement, la position de la ligne de temps est incrémentée de 1à chaque step. Vous pouvez changer cette valeur en affectant un autre montant à cette variable. Vous pouvez utiliser des nombres réels comme 0.5. Si la valeur est plus grande que un, plusieurs moments pourront survenir pendant le même step. Ils seront tous traités dans le bon ordre et aucune action ne sera sautée.

Les Rooms

{
  if (room != room_last)
  {
    room_goto_next();
  }
  else
  {
    game_end();
  }
}

Les variables et les fonctions suivantes concernent les rooms.

room Index de la room courante. Peut être modifié afin de se déplacer d'une room à une autre mais il est recommandé d'utiliser les routines suivantes.
room_first* Index de la première room du jeu.
room_last* Index de la dernière room du jeu.
room_goto(numb) Se rendre à la room d'index numb.
room_goto_previous() Aller à la room précédente.
room_goto_next() Aller à la room suivante.
room_restart() Relancer la room actuelle.
room_previous(numb) Retourne l'index de la room juste avant numb (-1 = aucune room) mais ne s'y rend pas.
room_next(numb) Retourne l'index de la room juste après numb (-1 = aucune room).
game_end() Termine le jeu.
game_restart() Relance le jeu à son point de départ.

Lors de l'appel de l'une des fonctions ci-dessus afin de changer de room ou encore de finir ou de relancer le jeu, veuillez bien noter que le changement n'intervient pas précisément lors de l'appel de la fonction mais uniquement après que l'action courante soit totalement exécutée. Les instructions de fin de script pourront donc être encore en cours d'exécution. La même règle s'appliquera également aux autres scripts en cours d'appel.

Les rooms présentent les propriétés supplémentaires suivantes :

room_width* Largeur de la room en pixels.
room_height* Hauteur de la room en pixels.
room_caption Chaîne contenant le titre de la room. Cette chaîne est affichée dans la zone de titre de la fenêtre de la room.
room_persistent Indique si la room actuelle est de type persistante.

La plupart des jeux offrent au joueur la possibilité de sauvegarder le jeu et de le recharger ultérieurement. Dans Game Maker, cela se produit automatiquement quand le joueur appuie sur <F5> pour sauver et <F6> pour charger le jeu. Vous pouvez également sauvegarder et recharger un jeu à partir d'un programme (N.B : le chargement ne prendra effet qu'à la fin du step courant).

game_save(string) Sauvegarde le jeu dans un fichier avec le nom string.
game_load(string) Charge un jeu à partir du fichier de nom string.

Seules les données de base du jeu seront sauvegardées. Si par exemple vous jouez un morceau de musique, la position précise de lecture du morceau musical ne sera pas sauvegardée. Les ressources modifiées ne seront pas sauvées également. De la même façon, il existe certaines autres choses qui ne sont pas sauvegardées comme par exemple le contenu des structures de donnée, les particules et les réglages du mode multi-joueurs.

Le Score

score Le score actuel.
lives Le nombre de vies.
health La santé actuelle (0 à 100).
show_score Indique si l'on doit afficher le score dans le titre de la fenêtre.
show_lives Indique si l'on doit afficher le nombre de vies restantes dans le titre de la fenêtre.
show_health Indique si l'on doit afficher la santé dans le titre de la fenêtre.
caption_score Le titre à utiliser pour le score.
caption_lives Le titre à utiliser pour le nombre de vies.
caption_health Le titre à utiliser pour la santé.

La Génération des Evénements

event_perform(type, numb) Exécute l'événement numb du type indiqué sur l'instance courante. Les types d'événements suivants peuvent être mentionnés :

ev_create
ev_destroy
ev_step
ev_alarm
ev_keyboard
ev_mouse
ev_collision
ev_other
ev_draw
ev_keypress
ev_keyrelease

En présence de plusieurs événements d'un type donné, numb peut être utilisé pour spécifier un événement précis. Pour l'événement alarme, numb peut varier de 0 à 11. En ce qui concerne l'événement clavier, vous devrez utiliser le code renvoyé par la touche pressée. Pour les événements souris, vous utiliserez les constantes suivantes :

ev_left_button
ev_right_button
ev_middle_button
ev_no_button
ev_left_press
ev_right_press
ev_middle_press
ev_left_release
ev_right_release
ev_middle_release
ev_mouse_enter
ev_mouse_leave
ev_mouse_wheel_up
ev_mouse_wheel_down
ev_global_left_button
ev_global_right_button
ev_global_middle_button
ev_global_left_press
ev_global_right_press
ev_global_middle_press
ev_global_left_release
ev_global_right_release
ev_global_middle_release
ev_joystick1_left
ev_joystick1_right
ev_joystick1_up
ev_joystick1_down
ev_joystick1_button1
ev_joystick1_button2
ev_joystick1_button3
ev_joystick1_button4
ev_joystick1_button5
ev_joystick1_button6
ev_joystick1_button7
ev_joystick1_button8
ev_joystick2_left
ev_joystick2_right
ev_joystick2_up
ev_joystick2_down
ev_joystick2_button1
ev_joystick2_button2
ev_joystick2_button3
ev_joystick2_button4
ev_joystick2_button5
ev_joystick2_button6
ev_joystick2_button7
ev_joystick2_button8

Pour l'événement de collision, vous donnerez l'index de l'objet other. Enfin, pour l'événement other, vous pourrez utiliser les constantes suivantes :

ev_outside
ev_boundary
ev_game_start
ev_game_end
ev_room_start
ev_room_end
ev_no_more_lives
ev_no_more_health
ev_animation_end
ev_end_of_path
ev_user0
ev_user1
ev_user2
ev_user3
ev_user4
ev_user5
ev_user6
ev_user7
ev_user8
ev_user9
ev_user10
ev_user11
ev_user12
ev_user13
ev_user14
ev_user15

Pour l'événement step, vous donnerez l'index qui peut utiliser les constantes suivantes :

ev_step_normal
ev_step_begin
ev_step_end

event_perform_object(obj, type, numb) Ces fonctions fonctionnent de la même manière que la fonction ci-dessus hormis que cette fois, vous pourrez indiquer des événements d'un autre objet. Veuillez noter que les actions de ces événements s'appliquent à l'instance courante et non pas aux instances de l'objet indiqué..
event_user(numb) Dans les événements other, il vous est possible de définir 16 événements utilisateur. Ils seront exécutés uniquement si vous appelez cette fonction. numb représente une valeur allant de 0 à 15.
event_inherited() Exécute un événement issu de l'héritage. Cela ne fonctionne que si l'instance posséde un objet parent.

Vous pouvez obtenir des informations sur l'événement courant en cours d'exécution en utilisant les variables en lecture seule suivantes :

event_type* Type de l'événement courant en cours d'exécution.
event_number* Numéro de l'événement courant en cours d'exécution.
event_object* L'index de l'objet pour lequel l'événement courant est en cours d'exécution.
event_action* L'index de l'action en cours d'exécution (0 correspond au premier événement, etc.).

Variables et Fonctions Diverses

error_occurred Indique qu'une erreur est apparue
error_last Chaîne de caractères contenant le message de la dernière erreur survenue
show_debug_message(str) Affiche la chaîne en mode déboguage (debug mode)

Les fonctions suivantes existent et vous permettent de vérifier si certaines variables existent; variables dont vous pourrez initialiser et lire le contenu. Dans toutes ces fonctions, le nom de la variable est passé en paramètre à l'aide d'une chaîne de caractères !

variable_global_exists(name) Retourne si une variable globale de nom name (une chaîne) existe.
variable_local_exists(name) Retourne si une variable locale de nom name (une chaîne) existe pour l'instance courante.
variable_global_get(name) Retourne la valeur de la variable globale de nom name (une chaîne).
variable_global_array_get(name, ind) Retourne la valeur de l'index ind de la variable globale tableau de nom name (une chaîne).
variable_global_array2_get(name, ind1, ind2) Retourne la valeur des index ind1,ind2 de la variable globale du tableau à 2 dimensions de nom name (une chaîne).
variable_local_get(name) Retourne la valeur de la variable locale de nom name (une chaîne).
variable_local_array_get(name, ind) Retourne la valeur de l'index ind de la variable locale du tableau de nom name (une chaîne).
variable_local_array2_get(name, ind1, ind2) Retourne la valeur des index ind1,ind2 de la variable locale du tableau à 2 dimensions de nom name (une chaîne).
variable_global_set(name, value) Affecte la valeur value à la variable globale de nom name (une chaîne).
variable_global_array_set(name, ind, value) Affecte la valeur value à l'index ind de la variable globale tableau de nom name (une chaîne).
variable_global_array2_set(name, ind1, ind2, value) Affecte la valeur value aux index ind1,ind2 de la variable globale tableau à 2 dimensions de nom name (une chaîne).
variable_local_set(name, value) Affecte la valeur value à la variable locale de nom name (une chaîne).
variable_local_array_set(name, ind, value) Affecte la valeur value à l'index ind de la variable locale du tableau de nom name (une chaîne).
variable_local_array2_set(name, ind1, ind2, value) Affecte la valeur value aux index ind1,ind2 de la variable locale du tableau à 2 dimensions de nom name (une chaîne).

Par exemple, vous pourrez écrire :

{
  if variable_global_exists('munition')
    global.munition += 1
  else
    global.munition = 0
}

Vous pouvez aussi utiliser ces fonctions pour passer des variables à un script par référence, en donnant le nom des variables sous forme de chaînes et en utilisant les fonctions pour modifier le contenu de ces variables.

Vous pouvez modifier la priorité d'exécution du programme à l'aide des fonctions suivantes :

set_program_priority(priority) Fixe la priorité du programme. Vous pouvez indiquer une valeur allant de -3 à +3. Une valeur de -3 signifie que le programme s'exécutera si aucun autre processus sur l'ordinateur ne demande du temps processeur, soit autrement dit, lorsque tous les autres processus sont à l'état prêt. Des valeurs de -2 et -1 sont en dessous de la normale, ainsi les autres processus auront la priorité. 0 est la valeur normale. +1 et +2 accordent une plus haute priorité au programme de jeu, permettant d'obtenir une plus grande vitesse d'exécution du jeu ainsi qu'un affichage plus coulé. Mais les autres processus bénéficieront de moins de temps processeur. +3 indique un mode en temps réel. Dans ce dernier mode, tout le temps processeur sera théoriquement attribué au jeu. Cela peut conduire à de sérieux problèmes en ce qui concerne les autres applications tournant actuellement sur l'ordinateur. Même les événements clavier ou souris (comme par exemple le clic sur le bouton de fermeture de la fenêtre), pourront ne plus être gérés correctement par Windows. Aussi, cette fonction sera à utiliser uniquement si vous souhaitez véritablement réserver tout le temps processeur pour le jeu. Il est conseillé d'utiliser cette fonction avec précaution et de sauvegarder le jeu avant de l'employer.

Interactions avec l'Utilisateur

Le Clavier

keyboard_lastkey Code de la dernière touche pressée. Voir ci-dessous pour connaître la liste complète des codes du clavier. Vous pouvez modifier le code retourné. Par exemple, vous pouvez lui affecter la valeur 0 si vous souhaitez le gérer par vous-même.
keyboard_key Code de l'actuelle touche pressée (voir plus bas; 0 si aucune).
keyboard_lastchar Dernier caractère pressé (retourné dans une chaîne de caractères).
keyboard_string La chaîne contient au plus les 1024 derniers caractères frappés au clavier. Cette chaîne ne contiendra que les caractères tapés imprimables. La chaîne assure une gestion correcte lors de la pression de la touche retour arrière (backspace) en effaçant le dernier caractère à chaque appui sur cette dernière.

Il est parfois utile de simuler l'appui d'une touche par une autre. C'est par exemple le cas lorsque vous souhaitez que le joueur utilise à la fois les touches flêchées et les touches du pavé numérique. Plutôt que de dupliquer les actions, vous pourrez faire en sorte que les touches du clavier numérique correspondent à celles des touches flêchées. Vous voudrez peut-être également implémenter un mécanisme dans lequel le joueur pourra choisir lui-même les touches à utiliser dans le jeu. Les fonctions suivantes sont dédiées à cet usage :

keyboard_set_map(key1, key2) Simule l'emploi de la touche de code key1 avec la touche de code key2.
keyboard_get_map(key) Retourne l'actuel mappage de la touche key.
keyboard_unset_map() Réinitialise toutes les touches à leur valeur d'origine (plus de mappage).

Pour contrôler qu'une touche particulière du clavier ou qu'un bouton de la souris aient été pressés, vous pouvez employer les fonctions ci-après. Cela sera particulièrement utile lorsque plusieurs touches seront pressées simultanément.

keyboard_check(key) Retourne si la touche de code key, est actuellement pressée.
keyboard_check_pressed(key) Retourne si la touche de code key a été pressée depuis le dernier step.
keyboard_check_released(key) Retourne si la touche de code key a été relâchée depuis le dernier step.
keyboard_check_direct(key) Retourne si la touche de code key a été pressée en effectuant directement un contrôle hardware. Le résultat est indépendant de l'application en cours. Cela permettra d'effectuer davantage de vérifications. En particulier, vous pouvez utiliser les code de touches vk_lshift, vk_lcontrol, vk_lalt, vk_rshift, vk_rcontrol et vk_ralt pour vérifier si les touches shift gauche, shift droit, contrôle (Ctrl) ou encore alt ont été pressées.

Les routines suivantes peuvent être utilisées pour vérifier l'état du clavier :

keyboard_get_numlock() Retourne si la touche de verrouillage numérique (Verr num) est actuellement en fonction.
keyboard_set_numlock(on) Mets en service (true) ou hors service (false) la touche de verrouillage numérique (Verr num).
keyboard_key_press(key) Simule la pression d'une touche avec le code touche key indiqué.
keyboard_key_release(key) Simule le relâchement d'une touche avec le code touche key indiqué.

Les constantes suivantes existent et concernent les codes touches virtuelles :

vk_nokey code touche indiquant qu'aucune touche n'a été pressée
vk_anykey code touche indiquant qu'une touche quelconque a été pressée
vk_left code touche correspondant à la touche flêche de gauche
vk_right code touche correspondant à la touche flêche de droite
vk_up code touche correspondant à la touche flêche du haut
vk_down code touche correspondant à la touche flêche du bas
vk_enter touche Entrée (enter)
vk_escape touche Esc (escape)
vk_space touche espace
vk_shift touche shift
vk_control touche contrôle (Ctrl)
vk_alt touche alt
vk_backspace touche retour arrière (backspace)
vk_tab touche tabulation (tab)
vk_home touche home (place le curseur en haut et à gauche de l'écran)
vk_end touche Fin (end)
vk_delete touche Suppr (delete)
vk_insert touche Inser (insert)
vk_pageup touche page précédente (pageup)
vk_pagedown touche page suivante (pagedown)
vk_pause touche pause/break
vk_printscreen touche printscreen/sysrq
vk_f1 ... vk_f12 codes touches pour les touches de fonction F1 à F12
vk_numpad0 ... vk_numpad9 touches correspondant aux chiffres du pavé numérique
vk_multiply touche multiplication (*) du pavé numérique
vk_divide touche division (/) du pavé numérique
vk_add touche addition (+) du pavé numérique
vk_subtract touche soustraction (-) du pavé numérique
vk_decimal touche point décimal (.) du pavé numérique

Pour les touches correspondant aux lettres, utilisez par exemple ord('A') (lettres capitales). Pour les touches correspondant aux chiffres, utilisez par exemple ord('5') pour obtenir la touche <5>. Les constantes suivantes peuvent être seulement utilisées avec keyboard_check_direct :

vk_lshift touche shift gauche
vk_lcontrol touche contrôle (Ctrl) gauche
vk_lalt touche alt gauche
vk_rshift touche shift droite
vk_rcontrol touche contrôle (Ctrl) droite
vk_ralt touche alt droite

Par exemple, supposons que vous ayez un objet que le joueur doit contrôler avec les touches flêchées, vous pourrez alors insérer le code programme suivant dans l'événement step de l'objet :

{
  if (keyboard_check(vk_left))  x -= 4;
  if (keyboard_check(vk_right)) x += 4;
  if (keyboard_check(vk_up))    y -= 4;
  if (keyboard_check(vk_down))  y += 4;
}

Bien entendu, il eût été beaucoup plus simple de mettre le code ci-dessus dans les événements clavier de l'objet.

Il existe quelques fonctions supplémentaires concernant l'interactivité clavier avec l'utilisateur.

keyboard_clear(key) Efface l'état de la touche key mentionnée. Cela signifie que celle-ci ne générera plus aucun événement clavier jusqu'au prochain appui sur la touche key.
io_clear() Efface tous les états du clavier et de la souris.
io_handle() Gestion des entrées-sorties (I/O) utilisateur, avec mise à jour du statut du clavier et de la souris.
keyboard_wait() Attends que l'utilisateur presse une touche au clavier.

La Souris

mouse_x* Coordonnée en X de la souris dans la room. Ne peut être changée.
mouse_y* Coordonnée en Y de la souris dans la room. Ne peut être modifiée.
mouse_button Bouton de la souris actuellement pressé. Retourne comme valeur mb_none, mb_any, mb_left, mb_middle, ou mb_right.
mouse_lastbutton Dernier bouton pressé de la souris.

Pour déterminer le bouton de la souris venant d'être pressé, vous pouvez utiliser les fonctions suivantes. Cela sera particulièrement utile lorsque plusieurs touches seront pressées en même temps.

mouse_check_button(numb) Retourne si le bouton de la souris numb est actuellement pressé (utilisez comme valeurs mb_none, mb_left, mb_middle, ou mb_right).
mouse_check_button_pressed(numb) Retourne si le bouton de la souris numb a été pressé depuis le dernier step.
mouse_check_button_released(numb) Retourne si le bouton de la souris numb a été relâché depuis le dernier step.

Il existe quelques fonctions supplémentaires ayant traits aux interactions avec la souris.

mouse_clear(button) Efface l'état du bouton button de la souris. Cela signifie que ce bouton ne générera plus aucun événement souris jusqu'à ce que le joueur relâche ce bouton puis le presse de nouveau.
io_clear() Efface tous les états du clavier et de la souris.
io_handle() Gestion des entrées-sorties (I/O) utilisateur, avec mise à jour des statuts du clavier et de la souris.
mouse_wait() Attends que l'utilisateur presse un bouton de la souris
.

Les Joysticks

joystick_exists(id) Retourne si l'ID du joystick (1 ou 2) existe.
joystick_name(id) Retourne le nom du joystick.
joystick_axes(id) Retourne le nombre d'axes du joystick.
joystick_buttons(id) Retourne le nombre de boutons du joystick.
joystick_has_pov(id) Retourne si le joystick posséde des fonctionnalités de point de vue.
joystick_direction(id) Retourne le code touche (vk_numpad1 à vk_numpad9) correspondant à la direction de l'ID du joystick (1 ou 2).
joystick_check_button(id, numb) Retourne si le bouton numb du joystick ID est pressé (numb allant de 1 à 32).
joystick_xpos(id) Retourne la position (-1 à 1) de l'axe en X de l'ID du joystick.
joystick_ypos(id) Retourne la position en Y du joystick.
joystick_zpos(id) Retourne la position en Z du joystick (si celui posséde un axe Z).
joystick_rpos(id) Retourne la position du manche (ou quatrième axe).
joystick_upos(id) Retourne la position en U du joystick (ou cinquième axe).
joystick_vpos(id) Retourne la position en V du joystick (ou sixième axe).
joystick_pov(id) Retourne la position du point de vue du joystick d'id ID. Cela correspond à un angle entre 0 et 360 degrés. 0 correspond vers l'avant, 90 vers la droite, 180 vers le bas et 270 vers la gauche. Lorsqu'aucune direction de point de vue n'est sélectionnée par le joueur, la valeur -1 est retournée.

Les graphiques du jeu

Sprites et Images

visible Si visible a la valeur true (1), l'image sera affichée sinon elle ne le sera pas. Les instances invisibles restent cependant actives et créent toujours des événements de collision mais vous ne les verrez pas. Paramétrer la visibilité à false peut être utile par exemple pour les objets contrôleurs (donnez leur le type non-solid pour éviter l'apparition d'événements de collision) ou encore pour des interrupteurs cachés dans votre jeu.
sprite_index C'est l'index du sprite courant de l'instance. Vous pouvez le changer en donnant un sprite différent à l'instance. Vous pouvez utiliser comme valeur le nom des sprites que vous aurez définis. Changer le sprite ne changera pas l'index de la sous-image actuellement visible.
sprite_width* Indique la largeur du sprite. Cette valeur ne peut être modifiée mais il vous est possible de l'utiliser.
sprite_height* Indique la hauteur du sprite. Cette valeur ne peut être modifiée mais il vous est possible de l'utiliser.
sprite_xoffset* Indique l'offset horizontal du sprite comme défini dans ses propriétés. Cette valeur ne peut être modifiée mais il vous est possible de l'utiliser.
sprite_yoffset* Indique l'offset vertical du sprite comme défini dans ses propriétés. Cette valeur ne peut être modifiée mais il vous est possible de l'utiliser.
image_number* Le nombre de sous-images de l'actuel sprite de l'instance (ne peut être changé).
image_index Lorsque l'image posséde plusieurs sous-images, le programme effectue un affichage en boucle de ces images. Cette variable indique la sous-image actuellement affichée (elles sont numérotées en partant de 0). Vous pouvez modifier l'image courante en changeant cette variable. Le programme poursuivra l'affichage en boucle des images mais en commençant à ce nouvel index (la valeur peut comprendre une partie fractionnaire. Dans ce cas, l'index sera toujours arrondi à la valeur entière inférieure afin d'obtenir la sous-image pouvant être correctement affichée).
image_speed La vitesse à laquelle le programme affiche les sous-images. Une valeur de 1 indique que lors de chaque step, le programme n'affichera qu'une seule image. De plus petites valeurs rendront plus lent l'affichage des sous-images, en affichant plusieurs fois chaque même sous-image à chaque step. Une valeur plus grande sautera des sous-images rendant l'animation plus rapide. Parfois, vous souhaiterez rendre visible une sous-image particulière et ne voudrez pas que le programme effectue un affichage en boucle des autres images. On peut réaliser cela en paramétrant la vitesse à 0 et en choisissant la sous-image souhaitée. Par exemple, supposons que vous ayez un objet en rotation et que vous vouliez créer un sprite qui dispose de sous-images pour effectuer un certain nombre d'orientations (dans le sens contraire des aiguilles d'une montre). Aussi, dans l'événement step de l'objet, vous pourrez écrire ceci :

{
  image_index = direction * image_number/360;
  image_speed = 0;
}

depth Habituellement, les images sont affichées selon l'ordre de création des instances. Vous pouvez modifier cela en réglant la profondeur de l'image (image depth). Par défaut, cette valeur est de 0 à moins que vous n'ayez indiqué une autre valeur dans les propriétés de l'objet. Plus cette valeur sera grande et plus l'instance sera éloignée (il est possible d'utiliser des valeurs négatives). Les instances de profondeur très grande seront situées derrière les instances de profondeur plus faible. Le paramétrage de la profondeur vous garantira que les instances seront affichées dans l'ordre souhaité (ex: un avion devant des nuages). Les instances d'arrière-plan devront avoir une très grande profondeur (donc positive) alors que celles de premier plan auront une profondeur très faible (soit négative).
image_xscale Ceci est un facteur d'échelle pour rendre les images plus grandes ou plus petites. Une valeur de 1 indique une taille normale. Vous devrez paramétrer séparément l'échelle horizontale xscale et celle verticale yscale. La modification de l'échelle aura une incidence sur les valeurs de largeur et de hauteur de l'image et influencera aussi les événements de collision comme on pouvait s'y attendre. On peut utiliser le changement d'échelle pour obtenir un effet 3D. Une valeur de -1 donnera au sprite un effet de miroir horizontal.
image_yscale Correspond à l'échelle verticale yscale. La valeur 1 indique aucune mise à l'échelle. Une valeur de -1 effectuera un retournement du sprite dans le sens vertical.
image_angle Correspond à l'angle de rotation du sprite. Vous devrez spécifier cette valeur en degrés et en suivant le sens contraire des aiguilles d'une montre. Une valeur de 0 signifie aucune rotation. Cette variable n'est disponible que dans la version enregistrée !
image_alpha La valeur de transparence (alpha) à utiliser lors de l'affichage de l'image. Une valeur de 1 correspond à un réglage normal de l'opacité alors qu'une valeur de 0 signifie une transparence totale.
image_blend La couleur de mélange de couleur (Blending color) utilisée lors de l'affichage du sprite. La valeur c_white est celle utilisée par défaut. Si vous indiquez une autre valeur, l'image sera mélangée avec cette couleur. Cela peut être utilisé pour colorier le sprite à la volée. Cette variable n'est disponible que dans la version enregistrée !
bbox_left* Côté gauche de la boîte des bords utilisée par l'image de l'instance (tient compte de l'échelle).
bbox_right* Côté droit de la boîte des bords de l'image de l'instance.
bbox_top* Côté supérieur de la boîte des bords de l'image de l'instance.
bbox_bottom* Côté inférieur de la boîte des bords de l'image de l'instance.

Les Arrière-Plans (Backgrounds)

background_color Couleur d'arrière-plan de la room.
background_showcolor Indique si l'on doit effacer la fenêtre avec la couleur d'arrière-plan.
background_visible[0..7] Indique si l'image d'un arrière-plan particulier doit être visible.
background_foreground[0..7] Indique si l'arrière-plan est actuellement un avant-plan.
background_index[0..7] Index de l'image d'arrière-plan pour l'arrière-plan.
background_x[0..7] position en X de l'image d'arrière-plan.
background_y[0...7] Position en Y de l'image d'arrière-plan.
background_width[0...7]* Largeur de l'image d'arrière-plan.
background_height[0...7]* Hauteur de l'image d'arrière-plan.
background_htiled[0..7] Indique si l'arrière-plan utilise des tuiles dans le sens horizontal.
background_vtiled[0..7] Indique si l'arrière-plan utilise des tuiles dans le sens vertical.
background_xscale[0..7] Facteur d'échelle horizontal pour l'arrière-plan (cette variable doit être positive : vous n'êtes pas autorisé à employer une valeur négative pour donner un effet miroir à l'arrière-plan).
background_yscale[0..7] Facteur d'échelle vertical pour l'arrière-plan (cette variable doit être positive : vous ne pouvez pas utiliser une valeur négative pour créer un effet de retournement de l'arrière-plan).
background_hspeed[0..7] Vitesse de scrolling horizontal de l'arrière-plan (pixels par step).
background_vspeed[0..7] Vitesse de scrolling vertical de l'arrière-plan (pixels par step).
background_blend[0..7] Couleur de mélange à utiliser lors de l'affichage de l'arrière-plan. La valeur c_white est celle utilisée par défaut. Uniquement disponible dans la version enregistrée !
background_alpha[0..7] Valeur de transparence (alpha) utilisée lors de l'affichage de l'arrière-plan. Une valeur de 1 correspond à la valeur normale alors qu'une valeur de 0 indique une transparence totale.

Affichage des Sprites et des Arrière-plans (Backgrounds)

draw_sprite(sprite, subimg, x, y) Dessine la sous-image subimg (-1 = image courante) du sprite d'index sprite avec son origine en position (x,y) (sans couleur de mélange et transparence alpha).
draw_sprite_stretched(sprite, subimg, x, y, w, h) Dessine le sprite en l'étirant de telle manière qu'il remplisse la zone située au coin supérieur gauche (x,y), de largeur w et de hauteur h.
draw_sprite_tiled(sprite, subimg, x, y) Dessine le sprite sous forme de tuiles de façon qu'il remplisse entièrement la room. (x,y) correspond aux coordonnées où le sprite de départ est affiché.
draw_sprite_part(sprite, subimg, left, top, width, height, x, y) Dessine la sous-image indiquée subimg (-1 = image courante) du sprite en plaçant le coin supérieur gauche de cette sous-image à la position (x,y).

draw_background(back, x, y) Dessine l'arrière-plan à la position (x,y) (sans couleur de mélange et transparence alpha).
draw_background_stretched(back, x, y, w, h) Dessine l'arrière-plan en l'étirant de telle manière qu'il occupe toute la région indiquée en paramétre.
draw_background_tiled(back, x, y) Dessine l'arrière-plan sous forme de tuiles de façon à ce qu'il remplisse entièrement la room.
draw_background_part(back, left, top, width, height, x, y) Dessine la zone indiquée de l'arrière-plan en plaçant le coin supérieur gauche de cette zone à la position (x,y).

Les fonctions suivantes sont des fonctions étendues de celles vues précédemment. Elles ne peuvent être utilisées que dans la version enregistrée !

draw_sprite_ext(sprite, subimg, x, y, xscale, yscale, rot, color, alpha) Dessine le sprite avec un facteur d'échelle xscale et yscale, en appliquant une rotation dans le sens contraire des aiguilles d'une montre de rot degrés. La couleur est celle utilisée pour le mélange de couleur (utilisez c_white pour ne pas utiliser de couleur de mélange) et alpha indique le niveau de transparence avec lequel les images seront fusionnées avec le fond. Une valeur de 0 créera un sprite totalement transparent. Une valeur de 1 rendra le sprite entièrement solide. Cette fonction est capable de créer de très grands effets (par exemple, des explosions partiellement transparentes).
draw_sprite_stretched_ext(sprite, subimg, x, y, w, h, color, alpha) Dessine le sprite en l'étirant de telle manière qu'il remplisse la région indiquée en paramétre, avec le coin supérieur gauche situé à la position (x,y), de largeur w et de hauteur h. La couleur sera la couleur de mélange et alpha correspond au paramétrage de la transparence.
draw_sprite_tiled_ext(sprite, subimg, x, y, xscale, yscale, color, alpha) Dessine le sprite sous forme de tuiles de façon à remplir complétement la room mais cette fois-ci en utilisant une mise à l'échelle, une couleur et un paramétrage de la transparence.
draw_sprite_part_ext(sprite, subimg, left, top, width, height, x, y, xscale, yscale, color, alpha) Dessine la sous-image indiquée subimg (-1 = image courante) du sprite en plaçant le coin supérieur gauche de cette image à la position (x,y) mais en utilisant une mise à l'échelle, une couleur et un paramétrage de la transparence.
draw_sprite_general(sprite, subimg, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha) La fonction d'affichage la plus générale pour les sprites. Elle dessine la sous-image indiquée subimg (-1 = image courante) du sprite en plaçant le coin supérieur gauche de cette image à la position (x,y) mais en utilisant aussi une mise à l'échelle, un angle de rotation, une couleur pour chacun des quatre vertices (haut-gauche, haut-droit, bas-droit et bas-gauche) et une valeur de transparence alpha. Veuillez noter que la rotation s'effectue à proximité immédiate du coin supérieur gauche de la sous-image.

draw_background_ext(back, x, y, xscale, yscale, rot, color, alpha) Dessine l'arrière-plan avec une mise à l'échelle et une rotation en utilisant une couleur de mélange (utilisez c_white pour ne pas avoir de couleur de mélange) et une transparence alpha (0-1).
draw_background_stretched_ext(back, x, y, w, h, color, alpha) Dessine l'arrière-plan en l'étirant selon les coordonnées indiquées. La couleur est celle de la couleur de mélange et la valeur alpha indique le paramétrage de la transparence.
draw_background_tiled_ext(back, x, y, xscale, yscale, color, alpha) Dessine l'arrière-plan sous forme de tuiles de manière à remplir totalement la room mais en utilisant cette fois-ci une mise à l'échelle, une couleur et un paramétrage de la transparence.
draw_background_part_ext(back, left, top, width, height, x, y, xscale, yscale, color, alpha) Dessine la zone indiquée de l'arrière-plan en plaçant le coin supérieur gauche de cette zone à la position (x,y) mais en utilisant également une mise à l'échelle, une couleur et un paramétrage de la transparence.
draw_background_general(back, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha) La fonction d'affichage la plus générale pour les arrière-plans. Elle dessine la région indiquée de l'arrière-plan en plaçant le coin supérieur gauche de cette zone à la position (x,y) mais en employant aussi une mise à l'échelle, un angle de rotation, une couleur pour chacun des quatre vertices (haut-gauche, haut-droit, bas-droit et bas-gauche) et une valeur de transparence alpha. Veuillez noter que la rotation s'effectue à proximité du coin supérieur gauche de la région indiquée.

Affichage de Formes (Shapes)

draw_clear(col) Efface complétement la room en utilisant la couleur indiquée (pas de couleur de mélange alpha).
draw_clear_alpha(col, alpha) Efface complétement la room avec la couleur indiquée et en utilisant une valeur alpha (utile en particulier pour les surfaces).
draw_point(x, y) Affiche un point à la position (x,y) avec la couleur courante.
draw_line(x1, y1, x2, y2) Affiche une ligne à partir de (x1,y1) jusqu'à (x2,y2).
draw_rectangle(x1, y1, x2, y2, outline) Affiche un rectangle. outline indique si seule la bordure doit être affichée (valeur true) ou si le rectangle doit être plein (valeur false).
draw_roundrect(x1, y1, x2, y2, outline) Affiche un rectangle avec bords arrondis. outline signale si seule la bordure doit être affichée (true) ou si le rectangle doit être plein (false).
draw_triangle(x1, y1, x2, y2, x3, y3, outline) Affiche un triangle. outline précise si seule la bordure doit être affichée (true) ou si le triangle doit être plein (false).
draw_circle(x, y, r, outline) Affiche un cercle à la position (x,y) et de rayon r. outline indique si seule la bordure doit être affichée (true) ou si le cercle doit être plein (false).
draw_ellipse(x1, y1, x2, y2, outline) Dessine une ellipse. outline précise si seule la bordure doit être affichée (true) ou si l'ellipse doit être pleine (false).
draw_arrow(x1, y1, x2, y2, size) Affiche une flêche de la position (x1,y1) à la position (x2,y2). size fournit la taille de la flêche exprimée en pixels.
draw_button(x1, y1, x2, y2, up) Affiche un bouton. up indique si le bouton est non pressé (1) ou pressé (0).
draw_path(path, x, y, absolute) Vous pourrez afficher avec cette fonction le chemin indiqué dans la room avec comme position de départ la position (x,y). Si absolute est à true, le chemin sera affiché à la position où il a été défini et les valeurs x et y seront purement et simplement ignorées.
draw_healthbar(x1, y1, x2, y2, amount, backcol, mincol, maxcol, direction, showback, showborder) A l'aide de cette fonction, vous pourez afficher une barre de santé (ou n'importe quelle barre représentant une valeur comme par exemple les dommages subis). Les arguments x1, y1, x2 et y2 indiquent la largeur totale (100%) de la barre. amount correspond au pourcentage de la barre qui doit être remplie (valeur entre 0 et 100). backcol représente la couleur de l'arrière-plan pour cette barre. mincol et maxcol indiquent la couleur que doit avoir la barre lorsque respectivement le pourcentage est de 0 ou de 100. Pour les valeurs intermédiaires, la couleur de la barre sera interpolée. Ainsi, vous pourrez facilement créer une barre qui passe progressivement du vert au rouge. La direction correspond à celle de la barre affichée. 0 signale que la barre est ancrée à gauche, 1 à droite, 2 en haut et 3 en bas. Enfin, showback mentionne si un fond doit être affiché et showborder précise si la boîte et la barre doivent posséder une ligne noire pour la bordure.

La plupart des fonctions suivantes utilisent le paramétrage de couleur et la valeur alpha que l'on peut modifier avec les fonctions ci-dessous.

draw_set_color(col) Régle la couleur d'affichage à utiliser désormais pour les primitives de dessin.
draw_set_alpha(alpha) Régle la valeur de transparence alpha à utiliser à partir de maintenant pour les primitives de dessin. La valeur doit être comprise entre 0 et 1. Une valeur de 0 indique une transparence totale alors que la valeur 1 correspond à une opacité compléte.
draw_get_color() Retourne la couleur d'affichage pour les primitives de dessin.
draw_get_alpha() Retourne la valeur alpha utilisée par les primitives de dessin.

Les couleurs prédéfinies ci-dessous peuvent être utilisées :

c_aqua
c_black
c_blue
c_dkgray
c_fuchsia
c_gray
c_green
c_lime
c_ltgray
c_maroon
c_navy
c_olive
c_purple
c_red
c_silver
c_teal
c_white
c_yellow

Les fonctions suivantes vous aideront à créer les couleurs que vous souhaitez.

make_color_rgb(red, green, blue) Retoune une couleur avec les composants indiqués rouge (red), vert (green) et bleu (blue) pour lesquels red, green et blue doivent être des valeurs comprises entre 0 et 255.
make_color_hsv(hue, saturation, value) Retourne une couleur avec les composants de tonalité, de saturation et de valeur indiqués (chaque valeur devant être comprise entre 0 et 255).
color_get_red(col) Retourne le composant rouge (red) de la couleur mentionnée.
color_get_green(col) Retourne le composant vert (green) de la couleur indiquée.
color_get_blue(col) Retourne le composant bleu (blue) de la couleur précisée.
color_get_hue(col) Retourne le composant de tonalité de la couleur indiquée.
color_get_saturation(col) Retourne le composant de saturation de la couleur mentionnée.
color_get_value(col) Retourne le composant de valeur de la couleur précisée.
merge_color(col1, col2, amount) Retourne une couleur mélangée avec les couleurs col1 et col2. Le mélange est déterminé en utilisant une valeur donnée. Une valeur de 0 correspond à la couleur col1, une valeur de 1 à la couleur col2 et des valeurs intermédiaires à des couleurs fusionnées avec col1 et col2.

Les fonctions diverses suivantes peuvent être également utilisées.

draw_getpixel(x, y) Retourne la couleur du pixel à la position (x,y) de la room. Cette fonction n'est pas très rapide : il convient donc de l'utiliser en connaissance de cause.
screen_save(fname) Sauvegarde l'écran dans une image de type BMP dans le fichier de nom fname. Très utile pour effectuer une copie d'écran de votre jeu.
screen_save_part(fname, x, y, w, h) Sauvegarde une partie de l'écran dans le fichier de nom fname.

Polices de caractères et Texte

Les fonctions suivantes peuvent être employées pour afficher du texte :

draw_set_font(font) Indique la police de caractères à utiliser pour afficher du texte. La valeur -1 sera utilisée pour employer la fonte par défaut (Arial 12).
draw_set_halign(halign) Régle l'alignement horizontal à utiliser lors de l'affichage de texte. Choisissez comme paramètre halign l'une des constantes ci-dessous :

fa_left
fa_center
fa_right

draw_set_valign(valign) Détermine l'alignement vertical à utiliser pour afficher du texte. Les constantes suivantes peuvent être utilisées :

fa_top
fa_middle
fa_bottom

draw_text(x, y, string) Affiche la chaîne à la position (x,y), à l'aide de l'actuelle couleur du crayon et la valeur alpha. Un symbole # ou un retour chariot chr(13) ou encore un saut à la ligne suivante chr(10) seront interprétés comme des caractères de nouvelle ligne (newline). Ainsi, vous serez en mesure d'afficher du texte sur plusieurs lignes (utilisez \# si vous souhaitez utiliser le symbole # lui-même).
draw_text_ext(x, y, string, sep, w) Similaire à la fonction précédente mais cette fois-ci, vous pourrez indiquer deux valeurs supplémentaires. En premier lieu, le paramétre sep indiquera la distance de séparation entre deux lignes pour tout texte s'affichant sur plusieurs lignes. Utilisez la valeur -1 afin d'obtenir la distance par défaut. Employez le paramétre w pour préciser la largeur du texte en pixels. Les lignes dépassant cette longueur seront sectionnées avec un espace ou un trait d'union. Utilisez la valeur -1 pour interdire le sectionnement des lignes.
string_width(string) Affiche la largeur de la chaîne de la police courante telle qu'elle serait affichée avec la fonction draw_text(). A utiliser pour positionner des graphiques de manière précise.
string_height(string) Hauteur de la chaîne de la police courante telle qu'elle serait affichée avec la fonction draw_text().
string_width_ext(string, sep, w) Largeur de la chaîne de la police courante telle quelle serait affichée avec la fonction draw_text_ext(). On l'utilise pour positionner précisément des graphiques.
string_height_ext(string, sep, w) Hauteur de la chaîne de la police courante telle qu'elle serait affichée avec la fonction draw_text_ext().

Les routines suivantes vous permettront d'afficher du texte selon une certaine échelle et orientation mais également vous autoriseront l'emploi de couleurs progressives dans vos textes. Ces fonctions ne sont disponibles que dans la version enregistrées !

draw_text_transformed(x, y, string, xscale, yscale, angle) Affiche la chaîne à la position (x,y) de la même manière que les fonctions vues plus haut mais en effectuant une mise à l'échelle horizontale et verticale à l'aide des facteurs indiqués et en inclinant le texte de angle degrés dans le sens contraire des aiguilles d'une montre.
draw_text_ext_transformed(x, y, string, sep, w, xscale, yscale, angle) Combine les fonctions draw_text_ext et draw_text_transformed. Cela vous permettra d'afficher du texte sur plusieurs lignes tout en appliquant une orientation et une mise à l'échelle de ce texte.
draw_text_color(x, y, string, c1, c2, c3, c4, alpha) Affiche la chaîne à la position (x,y) comme précédemment. Les quatre couleurs indiquent respectivement les couleurs du coin supérieur gauche, supérieur droit, inférieur droit et inférieur gauche du texte. alpha correspond à la transparence alpha à utiliser (0-1).
draw_text_ext_color(x, y, string, sep, w, c1, c2, c3, c4, alpha) Similaire à la fonction draw_text_ext() mais avec des vertices de couleurs.
draw_text_transformed_color(x, y, string, xscale, yscale, angle, c1, c2, c3, c4, alpha) Similaire à la fonction draw_text_transformed() mais avec des vertices de couleurs.
draw_text_ext_transformed_color(x, y, string, sep, w, xscale, yscale, angle, c1, c2, c3, c4, alpha) Similaire à la fonction draw_text_ext_transformed() mais avec des vertices de couleurs.

Fonctions de Dessin Avancées

Nous avons vu et décrit précédemment un certain nombre de fonctions de base concernant l'affichage. Vous trouverez ici des fonctions supplémentaires qui vous offriront encore davantage de possibilités. En premier lieu, nous trouvons les fonctions pour afficher des formes (shapes) avec des couleurs en arc-en-ciel. En second lieu, nous détaillerons les fonctions permettant d'afficher des polygones plus généraux puis enfin, nous parlerons de la possibilité d'afficher des textures projetées sur des polygones.

Il existe les versions évoluées suivantes venant compléter les fonctions de base pour l'affichage. Chacune d'entre elles présente des paramétres supplémentaires concernant la couleur utilisée afin de déterminer la couleur des différents vertices. La couleur standard d'affichage n'est pas utilisée par ces fonctions.

draw_point_color(x, y, col1) Affiche un point à la position (x,y) dans la couleur indiquée col1.
draw_line_color(x1, y1, x2, y2, col1, col2) Affiche une ligne de la position (x1,y1) à la position (x2,y2), avec interpolation de la couleur de col1 à col2.
draw_rectangle_color(x1, y1, x2, y2, col1, col2, col3, col4, outline) Affiche un rectangle. Les quatre couleurs représentent les couleurs des vertex supérieur gauche, supérieur droit, inférieur droit et inférieur gauche. outline précise si seule la bordure doit être dessinée (true) ou si le rectangle doit être plein (false).
draw_roundrect_color(x1, y1, x2, y2, col1, col2, outline) Affiche un rectangle à bords arrondis. col1 est la couleur du centre et col2 celle du bord. outline indique si seule la bordure doit être affichée (true) ou si le rectangle doit être plein (false).
draw_triangle_color(x1, y1, x2, y2, x3, y3, col1, col2, col3, outline) Affiche un triangle. Les trois couleurs correspondent aux couleurs des trois vertices, couleurs qui seront interpolées dans le triangle. outline indique si seule la bordure doit être affichée (true) ou si le triangle doit être plein (false).
draw_circle_color(x, y, r, col1, col2, outline) Dessine un cercle à la position (x,y) et de rayon r. col1 représente la couleur du centre et col2 celle des bords. outline indique si seule la bordure doit être affichée (true) ou si le cercle doit être plein (false).
draw_ellipse_color(x1, y1, x2, y2, col1, col2, outline) Dessine une ellipse. col1 est la couleur au centre et col2 la couleur du bord. outline indique si seule la bordure doit être affichée (true) ou si l'ellipse doit être pleine (false).

Vous avez également la possibilité de dessiner de plus grandes primitives. Le fonctionnement est quelques peu différent. Vous commencerez à spécifier la primitive que vous souhaitez afficher. Ensuite, vous indiquerez les vertices (sommets) de la primitive puis enfin, vous terminerez la primitive qui sera ensuite affichée. Six types de primitives existent :

pr_pointlist Les vertices sont formés d'un jeu de points.
pr_linelist Les vertices sont un jeu de segments de ligne. Chaque paire de vertices forme un segment de ligne. Ainsi, il doit y avoir un jeu pair de vertices.
pr_linestrip Les vertices forment un ensemble de lignes dont la première est reliée à la seconde, la deuxième reliée à la troisième, etc. La dernière ligne ne sera pas reliée à la première. Vous devrez indiquer une copie supplémentaire du premier vertex.
pr_trianglelist Les vertices sont un ensemble de triangles. Chaque triplet de sommets forme un triangle. Ainsi, le nombre de vertices doit donc être un multiple de 3.
pr_trianglestrip Les vertices forment à nouveau des triangles mais cette fois, cela fonctionne un peu différemment. Les trois premiers sommets forment un triangle. Les deux derniers vertices, en même temps que le prochain sommet, forme le second triangle, etc. Aussi, chaque nouveau vertex indique un nouveau triangle, relié au précédent.
pr_trianglefan Similaire à une liste de triangle mais cette fois, le premier vertex fait partie de tous les triangles. A nouveau, chaque nouveau vertex infique un nouveau triangle, relié au précédent vertex et au premier vertex.