Création de jeux avec Game Maker

Version 4.2 (8 Mai 2002)

Mark Overmars

Note du traducteur :
Ce document est plus une adaptation qu’une traduction littérale. En effet, dans
certains cas, j’ai préféré remanier le texte original et y ajouter quelques
développements pour bien préciser le contexte. Je me suis aussi permis d'ajouter
quelques captures d'écrans pour faciliter la compréhension.
Si vous trouvez des erreurs ou des contresens, veuillez me les indiquer afin que tous
puissent bénéficier de la mise à jour, merci.
Version 1.0 – Octobre 2002
Version 1.1 – Mars 2003
 patrikcarpentier@homail.com

2
Table des Matières

Chap. 1 Ainsi vous désirez créer votre propre jeu....................................................5

Chap. 2 Installation..................................................................................................6
Chap. 3 Idée Générale.............................................................................................7
Chap. 4 Analysons un Exemple..............................................................................9
Chap. 5 Fenêtre Principale....................................................................................11
5.1 Menu File (Fichier)...................................................................................................11
5.2 Menu Edit (Edition)..................................................................................................12
5.3 Menu Add (Ajout).....................................................................................................13
5.4 Menu Window (Fenêtre)...........................................................................................13
5.5 Menu Help (Aide).....................................................................................................13
5.6 Explorateur de Ressources........................................................................................13
Chap. 6 Définition de sprites.................................................................................14
Chap. 7 Sons et Musiques......................................................................................16
Chap. 8 Arrière-plans............................................................................................17
Chap. 9 Définition d’objets...................................................................................18
Chap. 10 Evénements...............................................................................................20
Chap. 11 Actions......................................................................................................24
11.1 Actions de Mouvement............................................................................................24
11.2 Object related actions (objets)..................................................................................26
11.3 Miscellaneous Actions (divers).................................................................................27
11.4 Questions...................................................................................................................29
11.5 Actions de Dessin.....................................................................................................31
11.6 Actions de Code........................................................................................................32
11.7 Utilisation des expressions et des variables..............................................................32
Chap. 12 Création de salles.....................................................................................34
12.1 Ajout d'instances.......................................................................................................35
12.2 Paramètres de Salle...................................................................................................35
12.3 Paramètres d'Arrière-Plans........................................................................................36
Chap. 13 Un peu plus sur les Sprites......................................................................37
13.1 Editez vos sprites......................................................................................................37
13.2 Edition des sous images individuelles......................................................................41
13.3 Options avancées sur les Sprites...............................................................................42
Chap. 14 Plus sur les Sons et les Musiques............................................................43
Chap. 15 Plus sur les Arrière-Plans.......................................................................44
Chap. 16 Plus sur les objets.....................................................................................45
16.1 Profondeur (Depth)...................................................................................................45
16.2 Objets persistants (Persistent objects).......................................................................45
16.3 Parents.......................................................................................................................45
16.4 Masques (Masks)......................................................................................................46
Chap. 17 Plus sur les Salles.....................................................................................47
17.1 Onglet Settings (Paramètres)....................................................................................47
17.2 Onglet Tiles (Tuiles).................................................................................................47
17.3 Onglet Views (Vues).................................................................................................49
Chap. 18 Chemins (Paths).......................................................................................50

3
 18.1 Définir des Chemins.................................................................................................50
18.2 Affecter un chemin à un objet...................................................................................51
18.3 Evénement Path........................................................................................................52
Chap. 19 Scripts.......................................................................................................53
Chap. 20 Informations sur le Jeu (Game information)........................................54
Chap. 21 Options de Jeu (Game options)..............................................................55
21.1 Options graphiques (Graphics).................................................................................55
21.2 Options de Clavier (Key)..........................................................................................56
21.3 Options d'Interaction.................................................................................................57
21.4 Options de Score.......................................................................................................57
21.5 Options de Chargement (Loading)............................................................................58
21.6 Options d'Erreur (Error)............................................................................................58
Chap. 22 Considérations sur la Vitesse..................................................................59
Chap. 23 Distribuez votre Jeu.................................................................................60
Chap. 24 Le Langage de Game Maker (GML).....................................................61
24.1 Programme................................................................................................................61
24.2 Variables...................................................................................................................61
24.3 Affectations...............................................................................................................62
24.4 Expressions...............................................................................................................62
24.5 Variables Locales et Globales...................................................................................63
24.6 Adresser les variables d'autres instances...................................................................63
24.7 Tableaux....................................................................................................................64
24.8 Instruction If..............................................................................................................64
24.9 Instruction Repeat.....................................................................................................65
24.10 Instruction While..................................................................................................65
24.11 Instruction For.......................................................................................................66
24.12 Instruction Exit......................................................................................................66
24.13 Fonctions...............................................................................................................66
24.14 Scripts...................................................................................................................67
24.15 Constructeur With.................................................................................................67
24.16 Commentaires //....................................................................................................68
24.17 Style Pascal...........................................................................................................69
24.18 Fonctions et Variables en GML............................................................................69
Chap. 25 Fonctions de Calcul..................................................................................70
25.1 Constantes.................................................................................................................70
25.2 Fonctions Mathématiques.........................................................................................70
25.3 Fonctions Alphanumériques.....................................................................................71
Chap. 26 GML: Déroulement du Jeu.....................................................................72
26.1 Concernant le Déplacement......................................................................................72
26.2 Instances....................................................................................................................74
26.3 Le Temps..................................................................................................................76
26.4 Salles et Scores.........................................................................................................77
26.5 Gestion des Evénements...........................................................................................78
26.6 Variables et Fonctions diverses................................................................................79
Chap. 27 Les Interactions Utilisateur (Souris et Clavier)....................................80
27.1 Le Support du Joystick..............................................................................................82
Chap. 28 Les graphiques.........................................................................................83
28.1 Fenêtre et Curseur.....................................................................................................83
28.2 Sprites et Images.......................................................................................................84

4
 28.3 Arrière-plans.............................................................................................................87
28.4 Tuiles.........................................................................................................................89
28.5 Fonctions de Dessin..................................................................................................91
28.6 Vues..........................................................................................................................94
28.7 Transitions.................................................................................................................95
28.8 Redessiner l'Ecran.....................................................................................................95
Chap. 29 GML : Son et Musique............................................................................96
Chap. 30 GML: Splash, Highscores, et autres pop-ups........................................98
Chap. 31 GML: Fichiers, Registres, et Exécutables...........................................100
Chap. 32 GML: Mode Multi Joueurs...................................................................102
32.1 Configurer une connexion.......................................................................................102
32.2 Créer et Rejoindre des Sessions..............................................................................103
32.3 Joueurs....................................................................................................................104
32.4 Partage de Données.................................................................................................104
32.5 Messages.................................................................................................................105
Chap. 33 GML: Utilisation de DLL.....................................................................106

5
Chap. 1 Ainsi vous désirez créer votre propre jeu
Jouer aux jeux sur ordinateur est amusant. Mais il est encore plus amusant de les créer soi-
même et que les autres jouent sur vos créations. Malheureusement, fabriquer ces jeux n’est
pas facile. Les jeux vidéo commerciaux que vous achetez demandent en général 3 ans de
développement à des équipes de 10 à 50 personnes. Le budget alloué se calculent en millions
d’euros et toutes les personnes impliquées sont des professionnels : programmeurs, artistes,
musiciens…

Donc, serait-il impossible de créer son propre jeu ? Heureusement non ! Naturellement, vous
ne pouvez pas prétendre créer votre propre Quake ou votre Age of Empire en quelques
semaines. Mais une simple jeu comme Tetris, Pacman, Space Invader etc… sont tout aussi
amusants à jouer et nettement plus facile à programmer. Malheureusement, ils exigent
toujours de bons talents en programmation ainsi que pour les graphismes, le son, l’ergonomie
etc…

Mais voilà qu’arrive Game Maker !

Game Maker a été écrit pour simplifier la création de tels jeux. Cà ne demande plus de savoir
programmer (ou si peu). Un interface intuitive et basée sur le Cliquer-Glisser (Drag and Drop)
vous permet de créer vos propres jeux très rapidement. Vous pouvez importer ou créer des
images, des sprites (images animées), des sons et les utiliser. Vous définissez facilement les
objets de votre jeu et vous indiquez leurs comportements. Et vous définissez d’attrayantes
salles (pièces, univers ou écrans) avec un arrière plan défilant dans lesquels votre jeu se
déroule. Et si vous voulez avoir la pleine maîtrise, il existe un langage de programmation
simple inclus dans Game Maker qui vous permet de contrôler tout ce qui se passe dans votre
jeu.

Game Maker est principalement axé sur les jeux en 2 dimensions (2D). Pas sur les jeux en 3
dimensions (3D) comme Quake. Mais ne vous en préoccuper pas de trop car beaucoup de
jeux comme Age of Empires, Command & Conquer et Diablo utilisent en réalité des sprites
en 2D, donnant l’illusion de la 3D. De plus, créer un jeu en 2 dimensions est nettement plus
simple et rapide.

Le meilleur argument de Game Maker est qu’il est gratuit. Et il n’y a aucune restriction en ce
qui concerne les jeux créés avec. Pas d’écran de rappel, pas de publicité et vous pouvez
vendre vs créations si vous le voulez. Voyez la licence pour plus de détails.

Ce livre vous expliquera tout ce que vous avez à connaître concernant Game Maker et
comment vous pouvez créer vos propres jeux avec lui. SVP, réalisez ceci : la création d’un
jeu n’est pas triviale, il y a beaucoup d’aspects importants comme l’interactivité, les
graphismes, les sons… Commencez par des exemples simples et vous réaliserez que la
création de jeux est amusante. Aussi, allez sur le site :

http://www.cs.uu.nl/~markov/gmaker/index.html

et aussi sur le forum (en anglais), vous y trouverez un tas d’exemples, d’idées et d’aides. Et
ainsi, vous deviendrez vous-même un Maître dans la création de jeux.
Bon amusement !

6
Chap. 2 Installation
Vous l’avez probablement déjà fait, mais si ce n’est pas le cas, voici comment installer Game
Maker. Lancez simplement le programme gmaker.exe. Suivez les instructions (en anglais)
qui s’affichent. Vous pouvez installer le programme où vous voulez mais il est préférable de
garder le répertoire suggéré par défaut. Une fois l’installation faite, Dans le bouton Démarrer,
vous trouverez un nouveau groupe dans lequel vous lancerez Game Maker et vous lirez sa
documentation et aide.

Dans le dossier d’installation (par defaut C:/Program Files/Game_Maker4/) se trouvent

d’autres sous-dossiers :
examples contient des exemples de jeux que vous testez ou modifiez.
sprites contient une collection de sprites gratuits que vous pouvez utiliser dans
vos jeux. Les personnes suivantes ont donné des sprites :
 Primalmania, voir http://primalmania.fateback.com/.
 Morphosis, voir http://www.geocities.com/morphosisgames/.
 Billy McQuown.
backgrounds contient des arrière-plans gratuits utilisables dans vos jeux. Il y a aussi
un certain nombre de tuiles (petites images) :
 platform1.bmp et platform2.bmp sont des collections
de tuiles. Copyright Ari Feldman. Pour plus d’informations,
voir le site  http://www.arifeldman.com/free/spritelib.html.
 rpg1.bmp et rpg2.bmp sont utilisés pour les jeux de
stratégie. Ce sont des versions allégées créées par Hermann
Hillmann. voir http://www.vbexplorer.com/charpack1.asp pour
plus d’informations.
 km.bmp, pk.bmp et ps.bmp ont été créés par e.m.b.u. Voir
http://www.embu.cjb.net pour les conditions d’utilisation et
pour d’autres jeux de tuiles.
sounds contient un certain nombre de sons et d’effets spéciaux gratuits que
vous pouvez inclure dans vos jeux..
scripts contient divers scripts utiles (voir chapitre 18).

Les sprites, les arrière-plans, les tuiles, les sons ne sont pas directement liés à Game Maker
mais proviennent de collections gratuites.

Game Maker exige un compatible PC muni d’un Pentium tournant sous Windows 95, 98, NT,
2000, Me et ultérieurs. Il exige aussi une résolution vidéo d’au moins 800x600 en 65000
couleurs (16 bits) ainsi que DirectX soit installé sur votre ordinateur. Il est préférable que
vous ayez au bas mot 32 Mo de mémoire lors de la création du jeu. L’exécution même du jeu
(le résultat final distribuable) demande en général moins de mémoire mais dépend du type de
jeu programmé.

7
Chap. 3 Idée Générale
Avant de passer en revue les possibilités de Game Maker, il est bon comprendre l’idée
générale qui se cache derrière le programme. Les jeux créés avec GM prennent place dans des
salles (des pièces, des écrans, des univers). Ces salles sont plates, pas en 3D mais peuvent
avoir un look 3D. Dans ces salles, vous placez des objets que vous définissez dans le
programme. Généralement, les objets sont des murs, des balles qui bougent, le personnage
principal, des monstres etc…
Certains de ces objets (ex : murs) sont statiques et ne font rien. D’autres (ex : personnage
principal, monstres) se déplacent et réagissent aux directives du joueur (clavier, joystick,
souris) et/ou aux autres objets. Exemple : quant le personnage principal rencontre un monstre,
il peut mourir (le personnage). Les objets sont la partie la plus importante des jeux créés avec
GM, c’est pourquoi nous en parlerons plus qu’un peu !

Tous d’abord, 99% des objets exigent des images afin qu’ils soient visibles sur l’écran. De
telles images s’appellent des sprites. Un sprite est souvent composé d’une série d’images
affichées les unes après les autres, générant ainsi une animation. C’est ainsi qu’on simule un
personnage qui marche, une balle qui roule, un astronef qui explose etc… Durant le jeu, le
sprite d’un objet peut changer (ex : le personnage change d’aspect selon qu’il aille vers la
droite ou la gauche). Vous pouvez créer vos propres sprites dans GM ou les charger à partir
de fichiers (ex : Gif animés).

Certaines choses arrivent à des objets, on appelle çà des événements. Les objets peuvent
avoir certaines actions en fonction de ces événements. Il y a beaucoup d’événements possibles
et encore plus d’actions en découlant. Par exemple, il y a un événement de Création (Create)
quand l’objet est créé (pour être plus précis, quand une instance, une copie, d’un objet est
créée, il peut y avoir de multiples instances d’un objet). Par exemple, quand une balle est
créée, vous pouvez lui indiquer l’action de se déplacer dans une direction choisie. Quand 2
objets se rencontrent, il y a un événement de Collision. Dans ce cas, vous pouvez arrêter la
balle ou changer sa direction. Vous pouvez aussi jouer un son. Pour ce faire, GM vous permet
de définir des sons. Quand le joueur appuie sur une touche du clavier, il y a un événement
Clavier (Keyboard) et l’objet exécute une action appropriée comme se déplacer dans une
direction voulue. Pour chaque objet, vous indiquez les actions liées aux divers événements,
définissant ainsi le comportement de l’objet.

Une fois que vous avez défini vos objets, il est temps de définir les salles (Rooms) dans
lesquelles ils vont vivre. Les salles peuvent être utilisées comme niveaux (Levels) dans votre
jeu ou pour simuler différents endroits. Des actions permettent de passer d’une salle à une
autre. Les salles ont avant tout un arrière-plan (Background) qui peut être une image ou une
couleur de fond. Ces images peuvent être créées avec GM ou chargées à partir d’un fichier.
Un arrière-plan peut faire un tas de choses mais considérons pour l’instant qu’il s’agit d’un
décor pour faire joli. Puis vous placez les objets dans la salle. Vous pouvez placer de
multiples instances (copies) du même objet dans la salle. Par exemple, vous définissez un mur
et vous le placez autant de fois que nécessaire dans la salle, même chose pour les monstres qui
auront tous le même comportement.

Maintenant vous être prêt pour lancer le jeu. La 1ère salle sera affichée et les objets
commenceront à vivre à cause des actions écrites dans leurs événements de création. Puis ils
réagiront les uns aux autres à cause des actions écrites dans les événements de collision. Ils
réagiront aussi au joueur à cause des événements du clavier ou de la souris.

8
En résumé, les choses suivantes (souvent appelées ressources) jouent un rôle crucial :
 Objets : qui sont les vraies entités du jeu
 Salles : les endroits ou les objets vivent
 Sprites : les images animées qui représentent les objets
 Sons : utilisés soit comme musique de fon ou comme effets
 Arrière-plans : images de fond d’écran dans une salle

Il y a aussi un autre type de ressource : les scripts. Les scripts sont des petits morceaux de
code (programmation) qui étendent les possibilités de GM. Ils seront détaillés dans les
chapitres avances de ce livre.

9
Chap. 4 Analysons un Exemple
Il est bon de commencer par un exemple simple. La 1 ère étape est de décrire le jeu que nous
allons réaliser (Faites toujours en 1er, çà vous épargnera un tas de problèmes par la suite). Le
jeu sera simple : une balle qui rebondit sur des murs. Le joueur pourra cliquer sur la balle avec
la souris, chaque fois qu’il réussit, il marque un point.

Comme nous le constatons, il y a 2 objets : la balle et le mur. Nous aurons besoin de 2 sprites
différents : un pour l’objet objBalle et l’autre pour l’objet objMur. Nous voulons entendre un
son à chaque fois que le joueur réussira à cliquer sur la balle. Nous avons besoin d’une seule
salle dans laquelle le jeu prendra place. Si vous ne voulez pas créer le jeu vous-même,
chargez-le à partir du dossier Examples sous le nom de touch the ball.gmd.

Commençons par les sprites. A partir du menu Add, sélectionnez Add Sprite (vous pouvez
utiliser le bouton approprié sur la barre d’outils). Une fenêtre s’ouvre. Dans la zone de saisie
Name, écrivez « sprMur ». Cliquez sur le bouton Load Sprite et choisissez une image
adéquate (vous en trouverez une dans le dossier Maze). C’est tout, vous pouvez fermer la
fenêtre. Créez de la même façon un sprite sprBalle.

Maintenant, nous allons créer le son. Dans le menu Add, sélectionnez Add Sound. Une autre
fenêtre s’ouvre. Donnez un nom au son et cliquez sur Load Sound. Choisissez une son
approprié, écoutez-le en cliquant sur le bouton Play. Si vous êtes satisfait, fermez la fenêtre.

La prochaine étape sera de créer 2 objets. Commençons par l’objet objMur. Dans le menu
Add, sélectionnez Add Object. Une fenêtre un peu plus complexe s’ouvre. A gauche, un
panneau avec des informations générales sur l’objet. Donnez comme nom « objMur » et dans
le combo (liste déroulante), choisissez le sprite sprMur. Parce qu’un mur est solide, dur,
cochez sur Solid. C’est tout pour le moment.

Créez maintenant l’objet objBalle et nommez-le ainsi. Liez-la au sprite sprBalle. La balle
n’est pas solide, donc ne cochez pas sur la case Solid. Pour la balle, nous avons besoin de
comportements. Au milieu, vous voyez Events (les événements, une série de boutons empilés
les uns sur les autres). Cliquez sur Create. A l’extrême droite, vous voyez toutes les actions
possibles, cliquez sur l’onglet Move et choisissez l’action avec 8 flèches rouges et jetez-la
dans la liste du milieu (le grand rectangle blanc). Sélectionnez maintenant dans la boîte de
dialogue qui vient de s’ouvrir automatiquement toutes les directions. Laissez la vitesse
(Speed) à 8. Fermez la boîte de dialogue.

Maintenant, lors de la création de l’objet objBalle,.celui-ci partira dans l’une des 8 directions.
Programmons maintenant ce qui doit arriver lors d’une collision avec un mur. Cliquez sur le
bouton Collision/Objects (celui avec 2 flèches rouge) puis sélectionnez l’objet objMur. Pour
cet événement, nous avons besoin de l’action Bounce. Finalement, nous devons définir ce
qu’il faut faire quand le joueur appuie sur le bouton gauche (Left) de la souris (Mouse).
Cherchez ces options dans les menus du bouton. Il nous faut 3 actions : jouer un son, changer
le score et changer de direction. Cliquez sur l’ongle Misc (à l’extrême droite). Jetez l’icône
Son, choisissez le son dans le combo. Pour le changement de score, jetez l’icône Score,
comme valeur numérique, écrivez 1 et cochez sur Relative. Cela ajoute 1 au score en cours.
Puis jetez l’icône des directions (celle avec les 8 flèches rouges comme tout à l’heure).

10
Notre objet est fin prêt. Il nous faut définir la salle.

Dans le menu Add, choisissez Add Room. A droite, vous voyez une salle vide. A gauche, une
liste de propriétés que vous pouvez changer comme la largeur (Width) et la hauteur (Height)
de la pièce, écrivez par exemple 12 dans les 2 cas. En bas à gauche, vous pouvez choisir un
objet, prenez l’objet objMur. Puis cliquez dans la salle pour y dessiner des murs. N’oubliez
pas de clore la salle par des murs afin que la balle ne puisse sortir de l’écran ! Enfin, placez 1
ou 2 objBalle dans la salle.

Maintenant, il est temps de tester notre petit jeu. Cliquez sur le bouton Run (dans la barre des
outils) et regardez ce qu’il se passe. Si vous n’avez pas fait d’erreurs, la balles (ou les balles)
se déplace, cliquez sur la balle avec la souris et regardez le résultat. Vous pouvez arrêter le jeu
en appuyant sur la touche ESC ou Echap. Vous pouvez maintenant opérer des changements si
vous le désirez.

Félicitations, vous venez de fabriquer votre 1er petit jeu. Mais je pense qu’il est temps
maintenant d’en apprendre un peu plus sur GM…

11
Chap. 5 Fenêtre Principale
Quand vous démarrez Game Maker, la fenêtre suivante apparaît :

A gauche, vous voyez les différentes ressources (Sprites, Sounds , Backgrounds, Paths,
Scripts, Objects, Rooms, Game Information et Game Options).
En haut, le menu et la barre des outils. Dans ce chapitre, je décrirai brièvement les menus
ainsi que les icônes. Dans les prochains chapitres, nous détaillerons ceux-ci. Notez que vous
pouvez lancer une commande de différentes façons : menu, icône ou click droit de la souris
sur la ressource.

5.1 Menu File (Fichier)

Dans le menu fichier, vous trouvez les commandes usuelles d’Ouvrir et d’enregistrer, plus
d’autres :
 New. Choisissez cette commande pour créer un nouveau jeu. Si le jeu en cours a subi
un changement, une boîte de dialogue vous demandera si vous voulez l’enregistrer.
Cette commande est prévue aussi sur la barre des outils.
 Open. Ouvre un fichier de jeu. Les fichiers Game Maker ont pour extension .gmd. Il
existe aussi un bouton sur la barre des outils. Vous pouvez aussi ouvrir un jeu en jetant
le fichier depuis l’explorateur dans la fenêtre de GM.
 Save. Enregistre le jeu sous son nom actuel. Si le jeu vient d’être créé, cela agit
comme Save As. Disponible aussi dans la barre des outils Cette commande n’est
disponible que si il y a eu un changement dans le jeu.
 Save As. Enregistre le jeu sous un autre nom qui vous sera demandé.
 Create stand-alone. Pour créer un jeu distribuable sous forme d’un programme. Vous
aurez plus d’informations sur la distribution des jeux au chapitre 23
 Import scripts. Pour importer des scripts (programmation). Plus de détails au
chapitre 18.

12
  Export scripts. Pour exporter vos propres scripts (programmation). Plus de détails au
chapitre 18.
 Preferences. Ici vous pouvez choisir vos préférences pour l’utilisation de GM.:
o Show recently edited games in the file menu. Voir les fichiers dernièrement
enregistrés dans le menu File.
o Use compression when saving games. Utiliser la compression quand vous
enregistrez le jeu. Cela réduit la taille (octets) du jeu mais augmente le temps
d’ouverture et d’enregistrement du jeu.
o Keep backup copies of files. Enregistrer une copie de secours de l’ancienne
version du jeu sous l’extension .bak. Vous pouvez renommer un .bak en .gmd.
o Hide the designer and wait while the game is running. Cache la fenêtre du
générateur de jeu GM lors de l’exécution du jeu. Une fois le jeu fini, la fenêtre
de GM redevient visible.
o Run games in secure mode. Exécuter les jeux en mode sécurisé. Interdit
l’exécutio d’autres programmes lors de l’exécution d’un jeu (impossible de
lancer, renommer ou de détruire quoique ce fût). C’est aussi une protection
contre les virus type Cheval de Troie (Trojan Horse).
o In object properties, show hints for actions. Si cette option est cliquée, dans
la fenêtre des Objets, quand votre souris survole une action, un court descriptif
est alors visible.
o Scripts and code. Voir chapitre 18.
o Image editor. Il est possible de choisir un autre éditeur d’image (Photoshop,
Paint Shop Pro, Photopaint…) plutôt que celui est fourni avec GM.
 Recent Files. Les 4 derniers jeux sont listés dans le menu File et ouvrables par un
simple clic.
 Exit. Pour quitter Game Maker. Une boîte de dialogue pour enregistrer le jeu en cours
apparaît.

5.2 Menu Edit (Edition)

Le menu Edit contient des commandes relatives aux ressources (objets, sprites…) ou à un
groupe de ressources. En fonction de la ressource, certaines commandes sont valides ou non.
 Insert resource. Insère une nouvelle ressource. Une fenêtre apparaît afin que vous
choisissiez le type de ressource. Voir chapitres suivants.
 Duplicate. Duplique la ressource courante et l’ajoute à la liste. Une fenêtre s’ouvre
dans laquelle vous pouvez changer la ressource.
 Insert group. Les ressources peuvent être regroupées, un peu comme les fichiers qui
sont regroupés par dossiers. Cela simplifie le classement et limite la longueur de la
liste des ressources. Un groupe peut contenir des groupes.
 Delete. Détruit une ressource. Attention, ce qui est détruit l’est définitivement, il n’y a
pas d’annulation possible. Faites attention !
 Rename. Renommer la ressource, lui changer son nom. Cela peut aussi être fait dans
les propriétés de la ressource. On peut aussi sélectionner la ressource puis cliquer sur
son nom.
 Properties. Pour éditer la liste des propriétés d’un ressource. Vous pouvez éditer
plusieurs ressources à la fois. Vous pouvez éditer une ressource en double-cliquant
dessus.
 Show Object Information. Pour avoir un aperçu de tous les objets d’un jeu.

Notez que toutes ces commandes peuvent être obtenues par un clic droit sur la ressource
concernée.

13
5.3 Menu Add (Ajout)
Dans ce menu, vous pouvez ajouter une nouvelle ressource. Il existe aussi un bouton (barre
des outils) pour chaque type de ressource ainsi qu’un raccourci clavier.

5.4 Menu Window (Fenêtre)

Dans ce menu, vous pouvez arranger les différentes fenêtres :
 Cascade. Les fenêtres se superposent en quinconces.
 Arrange Icons. Reclasse les différentes fenêtres iconisées.
 Close All. Ferme toutes les fenêtres.

5.5 Menu Help (Aide)

Ici vous trouvez les commandes qui vous aident :
 Contents. Aide (en anglais) de GM.
 How to use help. Comment utiliser l’aide.
 Web site. Se connecte sur le site web de GM afin d’avoir les dernières informations,
mises à jour ainsi que de la documentation et autres exemples. Je vous recommande
d’aller une fois par mois sur mon site.
 About Game Maker. Donne le numéro de version de Game Maker.

5.6 Explorateur de Ressources

A gauche de la fenêtre principale de GM, vous trouvez l’explorateur de ressources qui liste
sous la forme d’une arborescence (arbre) les diverses composantes du jeu (objets, sprites…).
Il ressemble beaucoup à l’explorateur fourni avec Windows (Explorer.exe) et fonctionne
globalement de la même façon. Si vous cliquez sur le signe + qui précède un élément alors
vous voyez les ressources situées au-dedans. Le signe – fait disparaître ces mêmes ressources.
Vous pouvez changer le nom d’une ressource en la sélectionnant puis en cliquant à nouveau
sur le nom de celle-ci. Un double clic affiche les propriétés de la ressource. Un clic droit
affiche un menu contextuel identique au menu Edit.
Vous pouvez changer l’ordre des ressources en cliquant dessus puis laissez le bouton gauche
de la souris enfoncée et déplacez ainsi la ressource. Relâchez le bouton pour déplacer
définitivement la ressource. C’est une opération de Cliquer/Glisser (Drag and Drop).
Bien sur, il est impossible de relâcher un son dans la liste des sprites !

14
Chap. 6 Définition de sprites
Les sprites sont la représentation visuelle de tous les objets d’un jeu. Un sprite est soit une
simple image (provenant de n’importe quel logiciel de dessin) ou une série d’images (qui
s’afficheront les unes après les autres, créant une petite animation). Par exemple, les 4 images
suivantes constituent un pacman se déplaçant vers la droite.

Quand vous fabriquez un jeu, commencez par récupérer des sprites intéressants ou jolis. GM
vous en fournit une bonne petite collection de sprites statiques ou animés. D’autres sprites
peuvent être trouvés sur Internet, sous la forme de Gif animés.

Pour ajouter un sprite, passez par Add Sprite du menu Add ou bien passez par l’icône de la
barre d’outils. La fenêtre suivante s’ouvre :

En haut, vous pouvez indiquer le nom du sprite. Tous les sprites ont un nom (les autres
ressources aussi). Il est préférable que ce nom soit descriptif. Vérifiez que toutes les
ressources aient un nom différent. Un nom est une suite de lettres (a..z) et de chiffres (0..9) et
de souligné ( _ ). Un nom commence par une lettre.
NdT : Utilisez quand vous le pouvez la notation hongroise qui consistent à préfixer une ou
plusieurs lettres qui indiquent le type de la ressource, exemple sprMonSprite ou
objMonObjet. Cela évite de confondre, par exemple, l’objet Balle avec le sprite Balle. Ce
sera très pratique quand vous vous lancerez dans la programmation pure et dure.

Il y a 2 onglets : Standard et Advanced. Pour l’instant nous ne parlerons que de l’ongle

Standard. L’onglet Advanced sera vu au chapitre 13.

15
Pour charger un sprite, cliquez sur le bouton Load Sprite. Une boîte de dialogue standard
d’ouverture de fichiers s’affiche. GM peut charger différents formats d’images. Seule la 1ère
image d’un Gif animé s’affiche sur la droite. Vous pouvez visionner les autres images d’une
animation en utilisant les boutons flèches rouges.

Une case à cocher Transparent indique si le fond peut être considéré comme transparent.
C’est la couleur du coin inférieur gauche qui conditionne la transparence. Certains Gif sont
déjà transparents mais GM n’utilise pas cette transparence sauvegarder avec l’image.

Avec le bouton Edit Sprite, vous pouvez éditer le sprite ou en créer un nouveau. Pour plus
d’information, voir le chapitre 13.

16
Chap. 7 Sons et Musiques
La plupart de jeux ont des effets sonores et une musique de fond. GM vous en fournit.
D’autres peuvent être trouvés sur Internet.

Pour ajouter une ressource sonore, utilisez Add Sound du menu Add ou bien passez par
l’icône de la barre des outils. Vous verrez alors cette fenêtre :

Comme déjà vu pour les sprites, vous pouvez donner un nom. Une fois de plus, vous avez 2
onglets : Standard and Advanced. Nous parlerons ici que du 1er (Standard). Pour l’autre, voir
le chapitre 14.

Pour charger un son, cliquez sur le bouton Load Sound. Une boîte e dialogue s’ouvrira dans
laquelle vous choisirez un son. Il y a 2 types de fichiers sonores : Wav et Midi (pour les Mp3
voir le chapitre 14) :
 Les fichiers Wav sont utilisés pour les effets sonores courts car ils sont
particulièrement volumineux. Ils exigent donc de la mémoire mais sont joués
instantanément et aussi simultanément.
 Les fichiers Midi sont nettement plus légers mais ne peuvent jouer que des mélodies
instrumentales. Ils sont donc souvent réservés aux musiques de fond. De plus, un seul
fichier Midi peut être joué à la fois, contrairement aux Wav.

Vous pouvez écouter le son ou la musique en cliquant sur le bouton Play (triangle vert).

17
Chap. 8 Arrière-plans
Le 3ème type de ressource est l’arrière-plan (le fond). L’arrière-plan est en général une grande
image utilisée justement comme arrière-plan (ou parfois avant-plan) des salles de votre jeu.
En général, l’image coïncide avec les tuiles de la salle. Si l’image est plus petite que la salle,
elle est répétée comme le papier peint de Windows. Des images de fond sont proposées avec
GM, d’autres sont disponibles sur Internet.

Pour ajouter un arrière-plan, passez par Add Background du menu Add ou bien par l’icône
de la barre des outils. La fenêtre suivante s’ouvre :

Comme d’habitude, vous pouvez changer le nom. Même topo pour les 2 onglets Standard et
Advanced. Pour Advanced voir le chapitre 15. Cliquez sur le bouton Load Background
Pour charger une image. Game Maker accepte beaucoup de formats. Attention, les arrière-
plans ne peuvent pas être animés.

Beaucoup d’arrière-plans ne sont pas naturellement transparent. La case à cocher

Transparent le permet. La transparence est conditionnée par la couleur du pixel du coin
inférieur gauche.

Vous pouvez changer l’arrière-plan ou en créer un nouveau en cliquant sur le bouton Edit
Background. Pour plus d’informations, voir le chapitre 15.

18
Chap. 9 Définition d’objets
Nous avons ajouté quelques jolies images et sons à notre jeu mais ceux-ci ne font rien. Nous
allons voir maintenant la plus importante ressource de GM : les objets. Les objets sont des
entités qui font des choses, qui ont des actions. Ils sont liés à au moins un sprite qui est la
représentation graphique de ceux-ci. Ils ont aussi des comportements car ils réagissent à
certains événements. Toutes le choses que vous voyez dans un jeu (sauf les arrière-plans) sont
des objets. Les personnages, les monstres, les balles, les murs etc… sont des objets. Il existe
aussi des objets que vous ne voyez pas mais qui contrôlent certains aspects du jeu.

Réalisez bien, svp, la différence entre les sprites et les objets. Les sprites sont seulement des
images animées ou non qui n’ont pas de comportement. Les objets ont un sprite qui les
représente mais les objets ont des comportements. Sans objets, il n’y a pas de jeu !

Réalisez aussi la différence entre les objets et les instances (copies). Un objet décrit une
certaine entité, un type (ex : un monstre). Il peut y avoir différentes instances de ce même
objet dans un jeu. Ainsi dans une salle, il peut y avoir plusieurs monstres (qui sont des copies
du même monstre de base) qui poursuive le héro. Quand nous parlerons d’une instance d’un
objet, nous signifions par là UNE instance particulière de l’objet. Quand nous parlons d’objet,
nous évoquons en réalité TOUTES les instance de l’objet.

Pour ajouter un objet, passez par Add Object du menu Add (ou la barre d’outils). La fenêtre
suivant s’affiche :

C’est un chouia plus complexe. A gauche, diverses informations générales sur l’objet. Au
milieu, les divers événements qui peuvent survenir à cet objet (voir le prochain chapitre pour
les détails). A droite, les différentes actions que l’objet peut accomplir (voir chapitre 11).

Toujours et encore, vous pouvez donnez un nom à l’objet puis vous indiquez le sprite qui
représentera l’objet. Pour ce faire, cliquez dans la zone de saisie du sprite ou sur le bouton
situé contre à droite. Un menu liste alors les sprites disponibles, choisissez celui que vous
voulez.

19
En dessous 2 cases à cocher :
 Solid indique s’il s’agit d’un objet solide, dur (un mur). Les collisions entre objets
solides sont traitées différemment des collisions entre objets non solides. (NdT : les
machins qui bougent sont en général des non solides). Voir chapitre suivant.
 Visible indique si l’objet est visible. Implicitement, la plupart des objets sont visibles
mais il est parfois utile d’utiliser des objets invisibles. Par exemple comme indication
de chemin pour un monstre. Un objet invisible réagit toujours à une collision.

Le bouton Show Information donne un aperçu de toutes les informations disponibles sur un
objet, aperçu qui peut être imprimé. C’est particulièrement pratique quand vous vous mélangé
les pinceaux sur les actions et événements de l’objet.

20
Chap. 10 Evénements
Game Maker utilise une approche événementielle. Toutes les instances des objets reçoivent
des événements, des messages. Ils peuvent réagir à ces événements en exécutant certaines
actions. Pour chaque objet, vous devez indiquer à quels événements il réagit et par quelles
actions il répond. Cà peut paraître compliqué mais c’est en réalité très simple. Et puis,
beaucoup d’objets réagissent à peu d’événements. Pour « programmer » les actions aux
événements, nous allons utiliser la méthode du Cliquer/Glisser, ce qui simplifie pas mal de
chose.

Au centre de la fenêtre des propriétés des objets, vous voyez une série de boutons intitulés
Create, Destroy, etc. ces sont les différents événements. Plus loin, je donnerai une liste plus
complète. Un de ces boutons est en gris foncé, c’est l’événement que nous sonne en train de
programmer (Ci-dessous : Create). A droite, toutes les actions disponibles sont affichées, elles
sont groupées par thèmes (les onglets). Dans le prochain chapitre, je décrirai ces actions.
Entre les actions et les événements, s’affiche la liste des actions prévues pour l’événement
sélectionné. Pour ajouter une action, sélectionnez-la dans la partie droite et jetez-la dans la
liste. Une courte description s’affiche. Une fois l’action jetée, souvent une boîte de dialogue
s’ouvre afin que vous modifiiez différents paramètres relatifs à l’action. Ceux-ci seront aussi
décrits au chapitre suivant.

Remarquez que le mot Create est en gras, cela signifie qu’il y a des actions qui ont été
« programmées » pour cet événement. Tout événement qui contient au moins une action est
écrit en gras. Vous pouvez maintenant ajouter d’autres actions dans un autre événement.
Cliquez sur le bouton désiré, il deviendra gris foncé et jetez dedans les actions voulues.

Vous pouvez changer l’ordre des actions par un simple Cliquer/Glisser. Si vous appuyez sur
la touche <Ctrl> pendant le Cliquer/Glisser, vous effectuez une copie de l’action. Vous
pouvez même faire un Cliquer/Glisser entre différentes fenêtres d’objets. Quand vous cliquez
sur une action avec le bouton droit de la souris, une menu affiche différentes options comme
Copier, Coller ou Supprimer (disponible aussi avec la touche <Del> ou <Suppr>).
Quand vous survolez longtemps une action, un court descriptif apparaît.

21
Il existe un bon nombre d’événements. Certains boutons ont un petit symbole de liste sur leur
droite. Ce sont des boutons de collections d’événements (Ex : le bouton des alarmes). Quand
vous cliquez sur un tel bouton ou que vous cliquez droit sur un tel événement, un menu
apparaît listant les autres événements du même type.

Voici la liste des événements :

Create event
Cet événement se déclenche à chaque fois qu’une instance est créée. C’est normalement
utilisé pour initialiser cette instance et/ou diverses variables de celle-ci.

Destroy event
Cet événement se déclenche à chaque fois qu’une instance est détruite. Pour être plus précis,
cet événement survient juste avant la destruction effective de l’instance. La plupart du temps,
cet événement n’est pas utilisé sauf éventuellement dans le changement d’un score ou pour
créer un autre objets.

Alarm events
Chaque instance a 8 chronomètres, 8 alarmes. On impose un nombre à l’une des alarmes. Le
chronomètre décompte ce nombre jusqu’à 0 puis l’événement est activé. Durant le temps du
décompte, l’objet et les autres objets continuent à vivre leur vie. Les alarmes sont très utiles.
Exemple : faire qu’un monstre change de direction tous les 20 pas (cycles). Un événement
Alarm peut lancer à son tour un autre chronomètre ou alarme ou relancer le sien.

Step event
L’événement Cycle survient à chaque tour de boucle du jeu. Vous y mettez les actions qui
doivent continuellement se faire. Par exemple, si un objet doit suivre un autre, c’est ici que
vous adapter sa direction en fonction de la position du meneur. Faite attention avec cet
événement. Comme il est lancé plusieurs fois par secondes, évitez des programmations
complexes ou d’en mettre à trop d’objets. Cà ralentira le jeu d’une façon très nette. Pour être
plus précis, il y a 3 types d’événement Cycle.
 Begin Cycle-Début est exécuté au commencement de chaque cycle.
 Step Cycle-Normal juste après que les instances aient pris leur nouvelle position.
 End Cycle-Fin s’exécute en fin de boucle, juste avant l’affichage, ce qui est souvent
utilisé pour changer de sprite en fonction de la direction.

Collision events
Quand 2 objets se rentrent en collision, cet événement survient. Pour être plus précis, 2
événements surviennent, un pour chaque objet. Choisissez dans le menu, l’objet avec lequel
vous souhaitez une réaction.

Il y a une différence entre le fait qu’une instance se télescope avec une autre instance solide
ou non solides. D’abord, quand aucune action n’a été prévue, rien ne se passe. L’instance en
cours conserve son mouvement, même si l’autre objet est solide.

S’il y a des actions de prévu alors les comportements sont les suivants:
 Quand l’autre objet est solide, l’instance revient à sa place d’avant la collision. Ensuite
l’événement est activé. Enfin l’instance est déplacée vers sa nouvelle position. Ainsi si
l’événement renverse la direction du mouvement, l’instance rebondit contre le mur
sans s’arrêter. S’il y a encore une nouvelle collision, l’instance repart à sa précédente
position et le mouvement est stoppé.

22
  Quand l’autre objet n’est pas solide, l’instance ne revient pas à sa position d’avant.
L’événement est exécuté à sa position en cours. Ainsi il n’y a pas de second test de
collision. Quand vous y réfléchissez, c’est normal. Comme l’objet n’est pas solide,
nous pouvons passer par-dessus. C’est l’événement qui précise la conduite à tenir.

Il y a plusieurs utilisations de la collision. Les instances peuvent rebondir, se détruire, détruire

l’autre etc…

Keyboard events
Quand le joueur appuie sur une touche du clavier, un événement clavier survient. Il y a
différents événements pour chaque touche. Dans le menu, choisissez la touche voulue. En
réalité, peu d’objets ont besoin de ces événements clavier. De plus, peu de touches sont
concernées.
Il y a 2 façons de gérer les touches :
 En continu, tant que la touche est enfoncée, à chaque événement Cycle (voir plus bas).
 En discontinu, quant la touche s’enfonce ou à chaque ré enfoncement.

Pour plus de détail, voir le chapitre 21. Il y a 2 événements spéciaux :

 <No key> à chaque fois qu’aucun touche n’est enfoncé (se déclenche à chaque tour de
boucle du jeu)
 <Any key> : toutes les fois qu’une touche est enfoncée, peut importe laquelle.

Si le joueur appuie sur 3 touches à la fois, il génère 3 événements clavier. Notez que les
touches du pavé numérique sont liées à l’état de Num Lock.

Mouse events
Les événements de la souris surviennent si le curseur de la souris est positionné sur l’objet. En
fonction du bouton enfoncé (gauche, droite, milieu ou aucun bouton enfoncé), une suite
d’actions est programmable. Si la souris ne survole aucun objet, aucun événement n’est
généré. Il est néanmoins possible de créer un objet invisible qui sera de la taille de la salle afin
d’intercepter les clics dans le vide. On peut bien sur utiliser ce truc pour rendre sensible une
zone quelconque de la salle.

Other events
Il y a un certain nombre d’autres événements qui peuvent être utiles pour certains jeux. Ils se
trouvent dans ce menu. Les voici :
 Outside: Cet événement survient quand une instance sort complètement de la salle.
C’est le bon moyen de la détruire.
 Boundary: Cet événement survient quand une instance bute sur les bords de la salle
 Game start: Cet événement survient pour toutes les instances quand le jeu démarre
dans la 1ère salle. Cela arrive avant le Room Start. Pratique pour initialiser la totalité
des objets et variables te pour lancer une musique de fond ou de charger des données
d’un fichier.
 Game end: Survient à la fin du jeu, quand celui-ci s’achève.
 Room start: Survient à chaque fois qu’on arrive dans une salle. Il survient avant
l’événement Créate.
 Room end: Cet événement s’applique à toutes les instances d’une salle qu’on quitte.
 No more lives: Game Maker possède un gestionnaire interne de vie. Il existe une
action qui s’occupe de la gestion des vies. Quand le nombre de vies descend à 0 ou en
dessous, cet événement s’applique. C’est pratique pour finir ou redémarrer un jeu.
 End of animation: Une animation (d’un sprite) consiste en une suite d’images
affichées les unes après les autres. Puis la dernière image affichée, on réaffiche la
23
 première. L’événement survient de ce retour à la 1 ère image. Ce qui peut être utile pour
changer d’animation ou détruire un objet.
 End of path: Cet événement survient quand l’instance a fini de parcourir son chemin.
Voir le chapitre 18 pour plus d’informations sur les chemins.
 User defined: Il y a 8 événements de ce type. Il sont réservés à votre usage personnel
et ne surviennent que si vous les appelez expressément par une ligne de code.

Drawing event
Les instances quand elles sont visibles, affichent elles-mêmes leurs sprites à chaque cycle
(boucle de jeu). Si vous spécifiez des actions dans l’événement Draw, le sprite n’est plus
dessiné automatiquement mais seulement sur ordre de votre part. Ce qui peut être utilisé pour
dessiner autre chose que le sprite ou pour changer des paramètres dans le sprite.
Il y a une série d’actions lié au dessin et qui sont très souvent présentes dans la
programmation de l’événement Draw. Notez cependant que cet événement est exécuté que si
l’instance est visible. Notez aussi que la gestion des collisions se base sur le sprite qui est
associé avec l’objet (et non ce que vous auriez programmé avec les actions de dessin).

24
Chap. 11 Actions
Les actions sont les choses font tourner le jeu dans Game Maker. Les actions sont placées
dans les événements. Il existe un grand nombre d’actions différentes disponibles et il est
important pour vous de les comprendre. Dans ce chapitre, je vais toutes vous les décrire.

Toutes les actions sont disponibles dans divers onglets situés à l’extrême droite de la fenêtre
des propriétés de l’objet. Cliquez sur un onglet pour en voir les diverses actions. Quand vous
maintenez la souris sur une action, une courte description s’affiche alors pour vous montrer
son utilité.

Je me répète : pour placer une action dans un événement, sélectionnez le bon onglet, cliquez
sur la bonne action et jetez-la dans la liste des actions de l’événement en cours. Par ce même
Cliquer/Glisser, vous modifier l’ordre des actions dans la liste. Par la touche <<Ctrl>>, vous
effectuez une copie de l’action déplacée. Vous pouvez aussi déplacer une action ou la copier
d’une liste à une autre liste située dans une autre fenêtre d’objet. Utilisez le clic droit ou la
touche <Del> ou <Suppr> pour supprimer l’action sélectionnée.

Quand vous lâchez une action dans la liste, une boîte de dialogue s’ouvre dans laque vous
remplissez certains paramètres. 2 types de paramètres reviennent souvent. En haut, vous
indiquez sur quelle instance l’action s’applique. Par défaut, il s’agit de Self (soi-même), càd
l’instance qui subit l’événement. Dans la cas d’une collision, vous pouvez aussi appliquer
l’action à l’autre instance concernée. Par ce biais, vous pouvez détruire l’autre instance. Ou
d’appliquer l’action à d’autres objets comme changer toutes les balles rouges en balles bleues.
Le second paramètre est la zone de saisie Relative. En cochant cette case, les valeurs que
vous entrez sont relatives. Exemple : vous écrivez 10 pour un score, si la case est cochée, le
score augmente de 10, si la case n’est pas cochée, le score passe à 10.
Vous pourrez par la suite venir modifier à nouveau les paramètres d’une action en double-
cliquant dessus.

11.1 Actions de Mouvement

Le 1er onglet concerne tout ce qui a trait au mouvement :

Start moving in a direction

Démarrer le mouvement dans une direction. Cliquez sur les flèches pour indiquer la ou les
directions de départ. Le bouton central immobilise l’objet. Plus bas, spécifiez la vitesse
(Speed) de l’objet qui est exprimée en pixel par cycle. La valeur par défaut est 8. N’utilisez
pas de valeur négative même si c’est possible. Si vous choisissez plusieurs directions, l’une
d’elles sera choisie au hasard.

Set direction and speed of motion

Choisir une direction et une vitesse. C’est l’autre moyen de spécifier un mouvement. Ici, vous
indiquez une direction précise (de 0 à 360°), le 0 allant vers la droite. La rotation se fait en
sens trigonométrique, 90° allant vers le haut de l’écran. Pour une direction arbitraire, écrivez
random(360). La fonction random donne un nombre entier au hasard, ici entre 0 et 359 . Une
case à cocher Relative permet d’ajouter l’angle écrit à l’angle déjà mis en place pour l’objet.
Exemple, si l’objet monte bien droit vers le haut (La Palisse) et que vous ajoutez une faible

25
valeur (comme 10 ou 20) alors l’objet montera toujours mais légèrement vers la gauche, si la
coche Relative est validée.

Set the horizontal speed

Vitesse horizontale. La vitesse d’un objet consiste en une vitesse horizontale et une autre
verticale. Une valeur positive dirige l’objet vers la droite, une négative vers la gauche. La
coche Relative est disponible.

Set the vertical speed

Vitesse verticale. Même logique que ci-dessus.

Move towards a point

Déplacer vers un point. Indiquez la position (x,y) et la vitesse et l’instance se dirigera vers le
point en question. Attention, L’instance ne se stoppera pas quand elle sera arrivée au point
mais continuera sa course dans la même direction ! Exemple si vous désirez qu’un missile se
dirige droit vers un vaisseau spatial (spaceship), écrivez spaceship.x, spaceship.y
(l’explication de ces variables viendra plus tard). Vous pouvez opter pour le mode Relative
qui indiquera un déplacement relative des coordonnées, plus loin en x et en y par rapport au
point actuel. Attention, la vitesse ne peut pas être négative.

Set the gravity

Vous pouvez appliquer une gravité à un objet. Indiquez un angle et une vitesse et elles seront
appliquées à chaque cycle sur l’objet. En général, on indique 270° (vers le bas) et une vitesse
très faible (comme 0.01). Le mode Relative S’applique ici aussi. Contrairement à la vie
réelle, il peut y avoir diverses gravités qui s’appliquent à divers objets.

Set the friction

La friction ralentit doucement mais sûrement un mouvement. A chaque cycle, la vitesse
diminue de la valeur de la friction jusqu’à ce qu’elle tombe à 0, l’objet devenant immobile. En
général, choisissez une valeur très petite comme 0.01.

Jump to a given position

Sauter à une position donnée. L’instance se déplace instantanément à la position x, y indiquée
(téléportation). Relative s’applique aussi.

Jump to the start position

Sauter à la position de départ. L’instance se replace à sa position initiale, celle de la création.

Jump to a random position

Sauter à une position aléatoire. L’instance se déplace vers une position quelconque qui ne
possède pas d’objet solide. Vous pouvez indiquer une valeur de placement magnétique
(snapping) ; exemple, une valeur de 10 alignera l’objet sur une grille virtuelle de petits
carreaux de 10 pixels. Une valeur de grille pour les x et une autre pour les y.

Reverse horizontal direction

Inverse la direction horizontale. Si l’objet se dirigeait vers la droite, il se dirige maintenant
vers la gauche. Pratique pour les rebonds contre un mur vertical.

26
 Reverse vertical direction
Inverse la direction verticale. Si l’objet se dirigeait vers le haut, il se dirige maintenant vers le
bas. Pratique pour les rebonds contre un mur horizontal

Bounce against objects

Rebondit contre les objets. Quand vous utilisez cette action dans l’événement Collision,
l’instance rebondit de façon naturelle. Si le paramètre Precise est faux (false), seul les
rebonds horizontaux et verticaux sont traités correctement. S’il est à vrai (true), le rebond est
traité correctement quelque soit l’angle d’attaque. Attention, le rebond dépend d’un tas de
paramètres mais dans l’écrasante majorité des cas, il sera jugé satisfaisant.

Snap to grid
Collé à la grille. Indiquez les valeurs horizontale et verticale et l’objet se plaque sur une grille
virtuelle comme si elle était magnétique. Exemple, une valeur de 10 (horiz et vert) obligera un
objet de coordonnées 18,24 à se plaque en 20,20.

Set a path for the instance

Appliquer un chemin à l’instance. L’instance suit alors un chemin prédéfini. Vous indiquez le
chemin (Path), la vitesse (Speed) et la Position (0=début, 1=fin) Voir le chapitre 18.

11.2 Object related actions (objets)

Cet onglet s’occupe d’actions comme créer, changer ou détruire les instances des objets.

Create an instance of an object

Créer une instance d’un objet. Vous créer une copie, une instance d’u objet quelconque et
vous indiquez sa position en x et y. La case à cocher Relative calcule une position relative par
rapport à l’instance en cours. Ceci est très pratique, un vaisseau spatial peut ainsi créer des
missiles qu’il tire, une bombe peut créer une explosion etc... Il arrive souvent que dans des
jeux certains objets créent des montes de temps en temps. Pour chaque objet créé,
l’événement Creation s’applique.

Change the instance

Chager une instance. Permet de transformer une instance en un autre objet comme changer
une bombe en une explosion. Tous les autres paramètres (x, y, vitesse…) restent identiques.
Vous pouvez spécifier si l’événement Destroy s’applique à l’objet d’avant et l’événement
Creation au nouvel objet.

Destroy the instance

Détruire une instance. L’événement Destroy s’applique.

Destroy instances at a position

Détruire une instance à une position. Avec cette action, vous détruisez tous les instances
incluses ou touchant une zone donnée. Ce qui est pratique dans le cas d’une bombe qui
explose. Relative indique une zone indiquée en coordonnées relative par rapport à l’instance
en cours.

27
 Change the sprite
Changer le sprite. Utilisez cette action pour changer le sprite d’une instance. Indiquez le
nouveau sprite qui prendra la place de l’ancien. Vous pouvez indiquer un facteur d’échelle, 1
signifiant qu’il n’y a pas de modification (échelle 100%). Le facteur doit être supérieur à 0.
Notez que redimensionner un sprite prend du temps et ralentit le jeu. Changer de sprite est
important. Si mon pacman qui allait vers le haut va maintenant vers la droite, pour faire beau,
il faut aussi changer l’orientation du pacman. On trouve souvent cette action avec les
événement du clavier.

11.3 Miscellaneous Actions (divers)

Actions diverses comme les aspects, le son, les salles etc...

Play a sound
Avec cette action, vous jouez un son tiré des ressources sonores. Indiquez le son choisi et si
vous voulez le jouer une seule fois (Once) ou en boucle (Loop). Divers sons Wav peuvent
être joués simultanément mais un seul son Midi à la fois. Donc si vous lancer un autre son
Midi, le précédent s’arrête. Comme ce n’est pas indiqué sur l’onglet Advanced (voir chapitre
14) une seule instance de chaque son peut être joué. Si le même son est déjà en train d’être
joué, il s’arrête et se relance.

Stop a sound
Arrêter un son. Toutes les instances qui jouent ce son deviennent muettes.

Set an alarm clock

Paramétrer une alarme. Indiquez le numéro et le nombre de cycles de l’alarme. Quand le
compteur sera à 0 (ou moins), l’instance recevra l’événement correspondant au n° de l’alarme.
Vous avez 8 alarmes à votre disposition. Si le nombre est 0 ou négatif, rien ne se passe.

Display a message
Afficher un message. Ecrivez un texte. Le symbole # sera interprété comme un passage à la
ligne. Si le texte commence par les symboles "  ou ‘, le texte se transforme en une expression,
voir le chapitre 21.

Set the score

Paramétrer le score. GM possède une gestion interne de score. Le score est affiché dans le
titre de la fenêtre du jeu. Ecrivez un nombre pour forcer le score à une valeur. La coche
Relative ajoute (ou retire) ce même nombre au score.

Display the highscore list

Afficher la liste des meilleurs scores. Pour chaque jeu, la liste des 10 meilleurs scores est
maintenue. Quand un score est digne d'y figurer, il s'y affiche. Pour le changement de
présentation, voir le chapitre 21 pour plus de détails (cette action ne fonctionne pas en mode
exclusif).

Set the number of lives

Pramétrer le nombre de vies. GM possède une gestion interne de vies Le nombre de vie
s'affiche dans le titre du jeu mais vous pouvez l'enlever. Normalement vous avez 3 vies. La

28
case à cocher Relative vous permet d'ajouter ou de retirer des vies. Quand le nombre de vies
est à 0 ou moins, un événement No more lives est généré.

Sleep for a while

Dormir quelque temps. Indiquez un temps exprimé en millisecondes qui gèlera le jeu
momentanément. C'est pratique au début ou à la fin d'un niveau ou quand il y a un message à
afficher. N'oubliez pas de redessiner l'écran dans certains cas.

Go to the previous room

Aller à la salle précédente. Replace le jeu dans la salle que vous venez de quitter avec un effet
de transition possible. Les événements d'initialisation s'activent alors. Si vous êtes déjà dans la
1ère salle, une erreur se produit.

Go to the next room

Aller à la salle suivante. Vous pouvez indiquer un effet de transition.

Restart the current room

Recommencer la salle en cours. Le jeu se relance au début de la salle en cours, l'effet de
transition peut être indiqué.

Go to a different room
Aller à une salle différente. Indiquez la salle et l'effet de transition.

Restart the game

Recommencer le jeu. Redémarrer tout le jeu à zéro.

End the game

Finir le jeu. Le jeu s'arrête. Game Over !

Save the game

Sauver le jeu. Vous pouvez enregistrer le statut en cours, un fichier est alors créé dans le
dossier du jeu.

Load the game

Charger le jeu. Recharger un jeu enregistré. Faites attention que le jeu chargé soit de la même
version que GM. Ceci fait, les actions qui suivaient le Load the game s'exécutent quand
même !

Show the game information

Montrer les informations du jeu. Cette action affiche une fenêtre avec un texte. Voir le
chapitre 20.

Switch fullscreen mode

Basculer en plein écran. Indiquez si vous passer en mode plein écran (Full Screen) ou en
mode fenêtre Windows. Cette action ne fonctionne pas en mode exclusif.

29
11.4 Questions

Il existe un certain nombre d'actions qui pose une question, par exemple si telle position est
vide. Si la réponse est oui (vrai, true) la prochaine action (celle qui suit dans la liste) est
exécuté sinon elle est sautée. Si vous voulez que plusieurs actions soient exécutées ou sautées,
vous pouvez les mettre dans un bloc en les encadrant par un Start Block et End Block. Il
peut aussi y avoir un bloc Sinon (Else).
Une question peut avoir la forme suivante :

Ici la question demande si l'instance en cours ne télescope personne d'autre. Si oui, l'instance
part dans une direction donnée. Si non, l'instance saute à une position donnée.

Pour toutes les questions, il y a une case à cocher NOT. Si vous la cochez, le résultat de la
question est inversé. Si le résultat était vrai, il devient faux et vis versa. Ce qui permet
d'exécuter certaines actions quand la question n'est pas vraie.

Pour beaucoup de question, vous pouvez indiquer si la question s'applique à toutes les
instances d'un objet particulier. Dans ce cas, le résultat est vrai que si et seulement si c'est vrai
pour toutes les instances..

Les questions suivantes et leurs actions associées sont disponibles. Vous remarquerez que ces
icônes possèdent une forme particulière qui les distingue des actions déjà vues.

If a position is collision free

Si une position est libre. Cette question retourne vrai si l'instance n'est pas en collision avec
une autre. Cette position peut être Relative. Vous pouvez indiquez si seule l'instance en cours
est concernée ou toutes les instances de ce même objet. Cette action est utilisée en général
pour vérifier si l'instance peut se rendre à une position particulière.

If there is a collision at a position

S'il y a une collision à une position. Cette question est l'inverse de la précédente. Retourne
vrai s'il y a collision.

30
 If there is an object at a position
S'il y a un objet à une position. Retourne vrai si l'instance placée à cette position rencontre une
instance de l'objet indiqué.

If the number of instances is a value

Si le nombre d'instance est une valeur. Vous spécifiez un objet et un nombre. Si le nombre
d'instances est égal au nombre alors la question retourne vrai. Vous pouvez aussi spécifier si
la valeur est inférieure ou plus grande. Pratique pour indiquer la fin d'un niveau ou d'un jeu.

If a dice lands on one

Si un dé affiche un. Vous spécifiez le nombre de face du dé. Si le dé lancé tombe sur 1, le
resultat est vrai. Ce qui introduit une part de hasard dans le jeu. Par exemple, pour chaque
cycle, vous pouvez générer la probabilité qu'une bombe explose plus tôt ou un changement de
direction du monstre qui se ballade. Le nombre de face peut être un nombre réel. Ainsi, si le
nombre de faces vaut 1.5, vous avez 2 chances sur trois que ce soit vrai. Un nombre inférieur
à 1 n'a pas de sens.

If a sound is playing
Si un son est en train d'être joué. Répond vrai si le son indiqué est toujours en cours
d'exécution.

If the user answers yes to a question

Si le joueur répond oui à une question. Une boîte de dialogue avec un bouton Oui et un
bouton Non s'affiche. Le résultat est vrai si le joueur clique sur Oui.

If an expression is true
Si une expression est vraie. Si l'expression (un calcul, un test) est évaluée à vrai ou que la
valeur est >= 0.5 alors le résultat est vrai. Voir plus loin pour plus d'information sur les
expressions.

If a mouse button is pressed

Si un bouton de souris est enfoncé. Retourne vrai si le bouton indiqué est enfoncé. Une
utilisation standard se fait dans l'événement Cycle.

If instance is aligned with grid

Si l'instance est alignée sur la grille. Si la position de l'instance coïncide avec les mailles de la
grille alors le résultat est vrai.

Else
Sinon. Après cette action se trouve le bloc des actions à exécuter si le résultat de la question
est faux.

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

End of block
Fin de bloc.

31
 Repeat next action
Répéter la prochaine action. Indiquez le nombre de fois que l'action qui suit ou le bloc qui suit
doit être répété.

Exit the current event

Sortir de l'événément en cours. Permet de quitter la suite d'actions d'un événement. S'il n'y a
pas de position libre alors quitter le programme (pas le jeu).

11.5 Actions de Dessin

Les actions de dessin n'ont de sens qu'avec l'événement Drawing. Dans les autres cas, ces
actions sont ignorées. N'oubliez pas que ces actions sont très lentes. Aussi, limitez-vous au
strict nécessaire.

Draw a sprite image

Dessiner un sprite. Indiquez le sprite, sa position (relative ou absolue) et le n° d'image à
afficher (à partir de 0). Pour dessiner l'image en cours, utilisez -1.

Draw a background image

Dessiner une image d'arrière-plan. Indiquez une image, sa position (relative ou absolue) et si
cette image doit être répétée sur toute la surface de la salle (papier peint).

Draw a text
Dessiner u texte. Indiquez le texte et sa position. Si le texte commence par " ou par ' alors ce
texte est évalué comme une expression. Exemple :

'Score: ' + string(score)

Pour afficher la valeur du score. La variable score stocke le score courrant. La fonction
string() convertit ce nombre en une chaîne et le + concatène (soude) les 2 chaînes.

Set the font for drawing text

Choisir la police du texte.

Draw a rectangle
Dessiner un rectangle. Indiquez les coordonnées des 2 coins opposés, soit en absolu ou en
relatif par rapport à la position en cours de l'instance.

Draw an ellipse
Dessiner une ellipse. Comme pour le rectangle, indiquez les 2 coins opposés.

Draw a line
Dessiner une ligne. Indiquez les 2 points d'extrémité (abs ou rel).

Set the fill color

Choisir la couleur de remplissage. Pour les rectangles et les ellipses.

32
 Set the line color
Choisir la couleur de trait. Pour le contour des rectangles et des ellipse ainsi que pour les
lignes.

11.6 Actions de Code

Enfin, il y a une série d'actions liées au code, à la programmation.

Execute a script
Exécuter un script. Le script (qui est un morceau de programme indépendant) possède au
maximum 3 arguments. Voir le Chap. 18.

Set the value of a variable

Affecter une valeur à une variable. Il existe un tas de variables internes à GM. Vous pouvez
modifier la valeur de ces dernières. Vous pouvez aussi créer vos variables. Indiquez le nom de
la variable et sa valeur. La coche Relative permet comme toujours d'ajouter la valeur à la
valeur actuelle de la variable. Attention, çà ne fonctionne que si la variable a déjà une valeur !
Voir plus loin pour les variables.

Execute a piece of code

Exécuter un morceau de code. Une boîte de dialogue vous affiche un mimi éditeur de code
dans lequel vous tappez le code voulu (çà fonctionne comme un script, voir le Chap. 18).
Pratique pour les petits codes. Pour les plus grands, choisissez plutôt un script.

Call the inherited event

Appeler l'événement hérité. Cette action est utile que si l'objet a un parent (voir le Chap. 16).
C'est un concept typique de la programmation orientée objet, POO.

Comment
Commentaire. Pour écrire un commentaire, une description. Le texte est écrit en italique.
Pratique quand on revient au bout de 3 mois dans un code auquel on ne comprend plus rien !.

11.7 Utilisation des expressions et des variables

Dans beaucoup d'actions, vous aurez besoin de modifier ou d'imposer des valeurs à des
paramètres. Plutôt que d'écrire un nombre, vous pouvez taper une formule 32*12. Mais vous
pouvez aussi taper des formules plus compliquées. Par exemple, pour obtenir le double de la
vitesse horizontale, vous pouvez taper dans la case de la vitesse la formule 2*hspeed. Ici
hspeed est une variable qui indique la vitesse horizontale en cours de l'instance.
Il existe d'autres variables :

x la coordonnée x de l'instance
y la coordonnée y de l'instance
hspeed la vitesse horizontale (en pixel par cycle)
vspeed la vitesse verticale (en pixel par cycle)
direction la direction courante (0° à 360°)
speed la vitesse dans cette direction
visible si l'objet est visible (1) ou invisible (0)

33
 image_scale l'échele de l'image (1= échelle de 100%)
image_single indique le n° d'image du sprite à afficher de façon permanente (de 0
à nbr-1). La valeur -1 (valeur par défaut) indique que les images
bouclent en animation.
score la valeur en cours du score
lives le nombre de vie
mouse_x la position en x de la souris
mouse_y la position en y de la souris

Vous pouvez changer la valeur de beaucoup de ces variables par l'action Set variable. Vous
pouvez aussi définir vos propre variables en leur donnant une valeur (n'utilisez pas alors
l'option Relative car elles n'existaient pas encore). Puis vous pouvez utiliser ces variables
dans des formes ou des expressions. Ces variables créées sont locales à l'instance en cours et
chaque objet a sa copie personnelle. Pour créer une variable globale, mettez devant le nom de
la variable le mot Global.

Vous pouvez faire référence à la valeur des variables d'autres objets en préfixant le nom de
ceux-ci séparés par un point. You can also refer to the values of variables for other objects by
putting the object name and a dot in front of them. Si vous voulez connaître la position d'un
monstre nommé Casimir, utilisez alors casimir.x et casimir.y pour y accéder.

Dans vos expressions, vous pouvez utiliser des fonctions. Exemple, la fonction random(10)
donne un nombre au hasard de 0 à 9. Cette fonction peut être attribué à la vitesse. Beaucoup
de fonction existent, retrouvez-les dans le Chap. 24 et suivants.

34
Chap. 12 Création de salles
Maintenant que vous avez défini les objets avec leurs comportements (événements et actions),
il est temps de créer les salles ou niveaux dans lesquels le jeu prendra place. Tout jeu a besoin
d'au moins une salle. C'est dans une salle que nous plaçons les instances des objets. Une fois
que le jeu démarre, la 1ère salle est affichée et les instances commencent à vivre leur vie à
cause des actions programmées dans l'événement Create.

Il y a un grand nombre de possibilités pour créer des salles que nous détaillerons peu après.
Pour certaines options, voir le chapitre 17. Dans ce chapitre, nous allons seulement discuter
des options basiques comme insérer des instances dans une salle et le paramétrage des arrière-
plans.

Pour créer une salle (room en anglais), choisissez Add Room dans le menu Add et la fenêtre
suivante apparaîtra :

En haut à gauche, vous voyez 5 onglets :

 Objects (objets) là où vous placez les instances de vos objets.
 Settings (paramètres) pour configurer la salle.
 Backgrounds (arrière-plans) pour choisir une image de fond à votre salle.
 Views (vues) pour définir les morceaux de vues d'une salle.
 Tiles (tuiles) pour ajouter des tuiles à la salle.

35
12.1 Ajout d'instances

A droite, vous voyez la salle divisée en petits carreaux. Au départ, la salle est vide avec un
fond gris.

Pour ajouter une instance dans la salle, sélectionnez d'abord l'objet désiré dans le combo ou en
cliquant dans la zone d'images. L'image de l'objet apparaît à gauche (notez qu'il y a une croix,
un repère sur l'image, ce qui indique que l'image est alignée sur la gille). Maintenant cliquez
sur quelque part sur la salle et une instance s'y affichera tout en se collant sur la grille. La
grille est paramétrable dans Setting. Si vous cliquez dans la salle tout en appuyant sur la
touche Alt, l'instance ne sera pas collée à la grille. Avec le bouton droit de la souris, vous
pouvez enlever une instance de la grille. Si vous continuez d'appuyer sur le bouton gauche de
la souris tout en vous déplaçant, des copies d'instances sont ajoutées dans la salle.

Si vous placez une instance sur une autre instance déjà existante, l'ancienne s'efface au profit
de la nouvelle. Pour empêcher cet implicite, cochez sur Delete underlying.

Il y a 3 actions spéciales disponibles avec le bouton droit de la souris :

 La touche <<Ctrl>> fait passer l'instance du dernier plan au 1er plan.
 La touche <Alt> fais passer l'instance du 1er plan au dernier plan.
 La touche <Shift> détruit toutes les instances (et non pas que celle du 1er plan)

Il y a 4 boutons :
 Clear pour effacer toutes les instances de la salle.
 Shift pour déplacer toutes les instances de quelques pixels.
 Sort by X et Sort by Y pour dégager les instances qui se chevauchent..

12.2 Paramètres de Salle

Chaque salle a ses propres paramètres qui sont disponibles dans

l'onglet Settings. Voyons les plus importantes :

 Chaque salle a un nom (Name, interne de programmation).

Chaque salle a un titre (Caption) qui s'affichera dans le
titre de la fenêtre Windows du jeu.
 La largeur et la hauteur de la salle sont modifiables
(Width et Height).
 Puis vous pouvez régler la vitesse du jeu (Speed) en cycle
par seconde. Plus le chiffre est élevé, plus le jeu est fluide
mais plus l'ordinateur doit être puissant.
 En bas de l'onglet Settings, indiquez la taille de la grille
utilisée pour aligner les objets (Snap X et Snap Y).
 Show permet d'afficher ou non la grille. La grille est
invisible quand le jeu se lance.
 Pour Persistent et Creation code, voir plus tard.

36
12.3 Paramètres d'Arrière-Plans

En cliquant sur l'onglet Backgrounds, vous paramétrez le fond de

la salle.

En haut, vous voyez un rectangle background color. Cliquez

dessus pour changer la couleur de fond de la salle. Attention, si une
image couvre le fond de la salle, cette couleur n'est pas visible.
Dans ce cas, décochez Draw background color car afficher une
couleur et une image de fond prend du temps.

En dessous, vous voyez une liste de 8 arrière-plans (background 0

à background 7). Vous pouvez définir chacun d'entre eux mais
souvent 1 ou 2 suffiront. Pour en définir un, sélectionne-le dans la
liste puis cliquez sur Visible when room starts sinon vous ne le
verrez pas. Le nom de l'arrière-plan devient gras. Maintenant,
choisissez une image dans la zone (où il est actuellement écrit <no
image>).

D'autres paramétrages sont possibles :

Tile permet de répéter l'image afin qu'elle couvre la salle, comme

le papier peint que vous avez sur le bureau de Windows.
Vous avez 2 variantes Tile Hor et Tile Vert (un pour l'horizontale et l'autre pour la verticale).
Vous pouvez aussi indiquer une position de placement de l'image de fond (X et Y).
Enfin, il est possible d'indiquer une vitesse de déplacement pour le fond afin de générer un
scrolling (Hor. Speed et Vert Speed), cette vitesse est exprimée en pixels par cycle.

Vous avez aussi, au milieu, une coche Foreground image. Quand vous la cochez, l'arrière-
plan sera alors un avant-plan qui se dessinera au dessus de la salle et de tous les objets.
Veuillez à ce que cette image soit partiellement transparente sinon vous ne verrez pas ce qui
se passe en dessous !

37
Chap. 13 Un peu plus sur les Sprites
Soit vous chargez un sprite déjà dessiné ou soit vous le créez avec Game Maker. Pour ce faire,
double-cliquez sur l'un de votre sprites (ou créez-le) dans la fenêtre des sprites. Cliquez
maintenant sur le bouton Edit Sprite. Une nouvelle fenêtre apparaît avec toutes les sous
images qui composent le sprite.

13.1 Editez vos sprites

La fenêtre d'édition des sprites ressemble à ceci :

A droite, vous voyez les différents images qui composent le sprite. Notez que dans Game
Maker, toutes les images ont la même taille.
A gauche, une animation du sprite (si vous ne la voyez pas, cochez sur Show Preview). Vous
pouvez changer la couleur de fond (Background Color) ainsi que la vitesse de l'animation
(Speed).

L'éditeur de sprites contient beaucoup de commandes pour créer et modifier un sprite. Elles
sont toutes disponibles par les menus et parfois par des icônes dans la barre d'outils. Certaines
commandes fonctionnent que sur une image donnée, il faut dans ce cas sélectionner l'image
concernée.

13.1.1 Menu File

Ce menu contient tout ce qu'il faut pour charger et sauver un sprite et ses images :

 New. Pour créer un sprite. Indiquez la taille du sprite (souvenez-vous,

toutes les images doivent avoir la même dimension).
 Create from file. Créer à partir d'un fichier. Différents types de fichier image
peuvent être utilisés. Ils contiennent tous une seule image sauf les
Gif animés qui peuvent en avoir beaucoup. Notez que Game
Maker ne sait pas optimiser ces Gif animés. Notez aussi que la

38
 couleur transparente est celle du pixel en bas à gauche et non celle
du Gif.
 Add from file. Ajouter une image à partir d'un fichier (ou des images dans le cas
d'un Gif animé). Si l'image n'a pas la bonne dimension, retaillez-
les.
 Save as GIF. Sauver les images sous forme d'un Gif (animé ou non).
 Save as strip. Sauver le sprite comme une image bitmap, chaque image étant
l'une à côté de l'autre en une longue bandelette.
 Create from strip. Créer un sprite à partir d'une image bitmap (l'inverse de la
commande précédente). Voir plus loin.
 Add from strip. Ajouter des images au sprite à partir d'une image bitmap. Voir
plus loin.
 Close Fermer l'éditeur en sauvegardant le sprite. Si vous ne voulez pas
sauvegarder, cliquez sur le bouton de fermeture () de la fenêtre.

13.1.2 Menu Edit

Ce menu contient les actions classiques du menu Edition, genre Couper, Copier et Coller des
images dans la séquence d'animation. Il y a aussi une commande pour éditer une image
particulière de l'animation.

13.1.3 Menu Transform

Dans ce menu, vous avez un certain nombre de transformations sur les images.

 Mirror horizontal. Symétrie horizontale.

 Flip vertical. Symétrie verticale.
 Shift. Décaler les images de n pixels horizontalement et verticalement.
 Rotate. Pivoter les images de 90°, 180° ou d'un angle quelconque.
Un facteur de qualité est aussi disponible. A expérimenter.
 Resize Canvas. Retailler l'image, changer le cadrage de l'image.
 Stretch. Déformer l'image, changer ses dimensions et sa qualité.
 Scale. Changer l'échelle de l'image mais pas ses dimensions.
Faire une sorte de zoom sur l'image.

13.1.4 Menu Images

Dans ce menu, vous pouvez exécuter une série d'opérations sur les images :

 Cycle left. Décaler toutes les images d'une place vers la gauche.
 Cycle right. Décaler toutes les images d'une place vers la droite.
 Black and white. Convertir l'image en noir et blancs
(N'affecte pas la transparence)
 Colorize. Changer la dominante colorimétrique générale de l'image.
 Intensity. Changer l'intensité de l'image (Saturation et Luminosité).
 Fade. Affadir une image (la grise).
 Transparency. Indiquer un niveau de transparence.
 Blur. Brouiller (plus la valeur est grande, plus l'image est floue).
 Crop. Couper l'image au plus petit.

Il sera bon d'expérimenter ces commandes sur les images d'un sprites afin de s'en faire une
idée plus nette.

39
13.1.5 Menu Animation
Dans ce menu, vous pouvez créer des nouvelles animations. Il y a différentes options à
exploiter et à tester. N'oubliez pas que vous pouvez enregistrer une animation et lui ajouter
par la suite d'autres images. Voici les différentes possibilités :

 Set Length. Changer la longueur de l'animation. L'animation est répétée autant

de fois que nécessaire pour créer le nombre d'images désirées. Ce
nombre doit être logiquement un multiple du nombre d'images
actuelle de l'animation.
 Stretch. Cette commande change aussi la longueur de l'animation. Mais
cette fois, les images sont dupliquées ou détruites jusqu'à obtenir
le bon nombre. Plus les nombres augments plus l'animation
devient lente (nombre d'images à la seconde).
 Reverse. Renverser. L'animation se joue alors de la dernière image à la
première.
 Add Reverse. La séquence retournée, inversée est ajoutée à la suite de
l'animation en cours. Si un sprite allait de gauche à droite, vous
créez son retour vers la gauche et vous obtenez un va-et-vient.
 Translation sequ. Vous créez une animation dont l'image est légèrement décalée à
chaque pas. Indiquez le décalage vertical et horizontal.
 Rotation sequ. Vous créez une animation qui fait pivoter l'image. Indiquez le
nombre d'images à créer, l'angle et son sens de rotation.
 Colorize. Créer une animation qui change la colorimétrie du sprite.
 Fade to color. Affadir le sprite.
 Disappear. Rendre transparent le sprite.
 Shrink. Rétrécir le sprite à rien du tout.
 Grow. Agrandir l'image à partir de rien du tout, du néant.
 Flatten. Aplatir l'image à rien dans une direction donnée.
 Raise. Agrandir l'image à partir d'une direction donnée.
 Overlay. Fondu enchaîné entre 2 images ou animations.
 Morph. Générer un morphing entre 2 images (transforme un image en une
autre). Dans certains cas, des pixels apparaissent soudainement
tandis que d'autres disparaissent.

Les 2 dernières commandes sont particulièrement puissantes. Par exemple, pour éclater un
objet, faites-en une série de copies puis ajoutez les images vides. Ensuite faites une
superposition, un fondu enchaîne entre ces images et celles d'une explosion. Arrangez-vous
pour qu'il y ait le même nombre d'images dans les 2 animations.

13.1.6 Strips
Comme ce fut déjà indiqué, les sprites sont stockés soit sous forme de Gif animés
ou d'images Bitmap (Strip). Un strip est une grosse image qui stocke en elle les
différentes images du sprite, comme sur une planche contact en photo. Le seul
problème est que la taille de chaque image n'est pas mémorisée.

Ci-contre un exemple de strip. Vous en trouverez beaucoup sur Internet

40
Pour exploiter un strip, utilisez Create from Strip ou Add from Strip du menu File. Après
avoir indiquer le strip ou l'image bitmap désirée, la fenêtre suivante s'ouvre :

A droite, vous voyez le strip choisi.

A gauche, une série de paramètres pour découper le strip. Le rectangle indique la sous-image
qui vous interesse. Voici les différents paramètres à configurer pour ce faire :

 Number of images. Nombre d'images que vous voulez prendre dans le strip.
 Images per row. Combien de rangées d'images dans le strip. Signifie une
frise verticale d'images.
 Image width. Largeur de chaque image individuelle.
 Image height. Hauteur de chaque image individuelle.
 Horizontal cell offset. Si vous ne voulez pas sélectionner les images à partir du
coin supérieur gauche du strip, vous pouvez indiquer ici
combien d'images doivent être sautées horizontalement..
 Vertical cell offset. Idem mais verticalement.
 Horizontal pixel offset. Parfois, il y a une petite marge entre le bord du strip et les
sous images. Indiquez la marge la marge de gauche en pixel.
 Vertical pixel offset. Marge haute en pixels.
 Horizontal separation. Parfois les sous images sont séparées entre elles. Indiquez
cet espace verticale en pixels.
 Vertical separation. Marge verticale entre chaque sous images.

Une fois que vous avez paramétrer correctement les valeurs, cliquez sur OK pour créer votre
sprite. Faites attention cependant aux copyrights quoi pourraient être liés aux images que vous
découpez.. Choisissez donc plutôt des images freewares (libres de droit).

41
13.2 Edition des sous images individuelles

Vous pouvez aussi éditeur les images d'un sprite. A cette fin, sélectionnez une sous image et
choisissez Edit Image du menu Image. Cela ouvrira une fenêtre d'édition d'image dans
laquelle vous pourrez dessiner et peindre votre image. Réalisez cependant qu'il s'agit d'un
petit éditeur. Si vous cherchez mieux, procurez-vous un logiciel de dessin comme Photoshop,
Photopaint ou Paint Shop Pro, sans parler de The Gimp (puissant et gratuit) et importez
l'image créée dans Game Maker.

La fenêtre vous montre l'image au milieu et une série de boutons basiques à gauche. Vous y
trouverez ce qu'il faut pour zoomer, dessiner des pixels, des lignes, des rectangles, des textes
etc… Pour différentes commandes, vous aurez une liste de propriétés qui s'afficheront en
dessous des boutons de la barre d'outil verticale. Il ay a aussi un bouton spécial qui change
tous les pixels d'une couleur en une autre. Ce qui est particulièrement pratique pour changer
un fond. Notez que la couleur change selon que vous cliquez dessus avec le bouton gauche ou
le bouton droit de la souris. Il y a aussi des commandes pour déplacer, décaler etc… les pixels
d'un dessin.

A droite, une palette des couleurs est disponible. Vous sélectionnez une couleur soit par le clic
gauche (trait) ou par le clic droit (remplissage). Ce sont les couleurs qui s'affichent sous les
étiquettes Left et Right. En dessous, vous avez la couleur du coin inférieur gauche, celle qui
est utilisée pour la transparence du sprite. Encore en dessous 16 couleurs de base. Enfin en
dernier, une palette chromatique avec un nombre non négligeable de couleurs..

Dans les menus, vous retrouvez les mêmes commandes de transformation et de modification
de l'image. Quoiqu'il arrive, ces commandes n'agissent que sur l'image affichée et non pas sur
les autres images qui composent l'animation du sprite. L'image en cours peut être sauvegardée
dans un fichier bitmap.
42
Il y a 2 commandes en plus dans le menu Image :

 Clear. Effacer l'image dans la couleur Left, qui devient alors la couleur
transparente.
 Gradient fill. Remplir l'image avec un dégradé de couleur. Pas très utile pour un
sprite mais beaucoup plus pour une arrière-plan qui utilise le même
logiciel de dessin..

Notez qu'il n'y a pas de mécanisme de sélection de morceau d'image. Beaucoup de

commandes amusantes ou fantaisistes manquent à l'appel. Pour combler ce vide, passez par
un logiciel plus perfectionné. Importez l'image obtenue ou passez par le Copie Coller.

13.3 Options avancées sur les Sprites

Dans la fenêtre des Sprites, vous avez un ongle nommé

Advanced dans lequel vous trouvez un certain nombre d'options
avancées :

La première concerne la gestion des collisions. Quand 2

instances se rencontrent, un événement Collision est généré.
Chaque sprite possède une boîte de détourage (des limites), en
clair, chaque sprite est enfermé dans un rectangle. Quand les 2
rectangles (un pour chaque sprite) se chevauchent, il y a
collision. Mais il n'est pas évident que réellement les dessins des
2 sprites se chevauchent puisqu'il se peut que les pixels qui se
télescopent soient de couleur transparente. Si vous tenez
vraiment à ce que les pixels visibles déclenchent la collision,
cochez sur Precise collision checking. Cela paraîtra plus réaliste
mais cette option consomme beaucoup de temps machine. Donc
à manipuler avec précaution.

Les sprites peuvent être stockés dans 2 endroits : la mémoire vidéo et la mémoire vive.
 La mémoire vidéo est plus rapide et efficace mais sa place est limitée.
 La mémoire vive est plus vaste mais plus lente.
Donc les sprites usuels et/ou petits peuvent aller en mémoire vidéo (Use video memory). Les
autres (les peu utilisés ou les gros) en mémoire vive.

Certains sprites ne sont utilisés que dans 1 ou 2 niveaux (salles) de votre jeu. C'est du
gaspillage de les avoir toujours en mémoire tout le temps. Si vous cochez sur Load only on
use, ces sprites ne seront chargés du disque dur vers la mémoire que si on en a besoin. Pour
les jeux qui utilisent énormément de sprites, il est judicieux de passer par cette option afin de
ne pas saturer trop vite la mémoire de l'ordinateur (NDT : la mémoire actuelle des ordinateurs
dispense souvent d'avoir recourt à cette option).

Enfin, vous pouvez indiquer l'origine (Origin X Y) du sprite. C'est le point, le pixel qui
correspond à sa position. Par défaut, il s'agit du coin supérieur gauche. Mais il est souvent
utile de piloter le sprite par son centre. Il est même possible d'indiquer une origine en dehors
du sprite.

43
Chap. 14 Plus sur les Sons et les Musiques
Dans l'onglet Advanced vous trouverez des options
supplémentaires à la gestion des sons dans la fenêtre Sounds.

Pour tous les sons, vous pouvez indiquer si ceux-ci sont chargés
en mémoire que si on les utilise (Load only on use). C'est l'option
par défaut pour les fichiers Midi mais pas pour les fichiers Wav.
Si vous cochez cette option, le son n'est pas chargé en mémoire
quand le jeu commence. C'est seulement quand on aura besoin de
lui, qu'il se chargera. Il y a un risque de désynchronisation entre le
son et l'action relative à celui-ci mais vous gagnez de la place en
mémoire. Evitez donc de le faire pour de petits sons qui
reviennent souvent et réservez cette option de chargement qu'aux sons volumineux ou très
occasionnels.

Pour les fichiers Wav, vous pouvez indiquer le nombre de mémoires tampons (Buffers). Cette
valeur indique le nombre de sons joués simultanément. Par exemple, vous pouvez entendre
plusieurs explosions en même temps. Attention, les tampons consomment de la mémoire et
dépendent aussi de la carte son de l'ordinateur sur lequel s'exécute le jeu.

Vous pouvez aussi indiquer si le son doit être préparé pour les effets sonores comme changer
le volume ou la résonance (Allow for sound effects). Cela sera réalisable que par du code, de
la programmation. Bien sur, cela prend du temps machine…

Il y a aussi un bouton pour sauvegarder le son afin de l'exploiter ailleurs (Save sound).

En plus des fichiers Wav et Midi, il y a les fichiers Mp3 qui sont fortement compressés. Bien
que vous ne les voyiez pas lors de la sélection du fichier quand vous le chargez, ils sont
utilisables dans Game Maker. Pour ce faire, choisissez de montrer monter tous les fichiers par
l'option All files en bas de la boîte de dialogue File Open. Puis choisissez un fichier Mp3. Il y
a des inconvénients : il faut décompresser un tel fichier et çà prend du temps et donc çà
ralentit le jeu. Quand vous décompressez un fichier qui prend peu de place sur le disque dur, il
prend beaucoup plus de place en mémoire (NDT : au bas mot, un facteur de 20). Donc évitez-
les ou convertissez-les.

44
Chap. 15 Plus sur les Arrière-Plans
En plus de charger ses arrière-plans à partir de fichiers, vous
pouvez les créer vous-même. A cette fin, cliquez sur le bouton
Edit Background. Un petit programme interne de dessin
s'affiche, le même déjà décrit en section 13.2.

Dans le menu Image, vous trouvez la commande Gradient Fill.

Cela permet de créer de jolis arrière-plans dégradés.

Vous trouvez aussi un onglet Advanced dans lequel se trouvent

d'autres options spécifiques aux arrière-plans.

Normalement, les arrière-plans sont stockés en mémoire vidéo.

C'est rapide, efficace mais cette mémoire vidéo est limitée en
place et est aussi conditionnée par votre carte vidéo. Donc quand
un arrière-plan est particulièrement volumineux ou peu utilisé, il
est préférable de mettre en mémoire vive. Pour ce faire, enlevez la
coche à Use video memory.

La coche Load only on use (charger seulement sur utilisation) ne charge du disque dur vers la
mémoire qui si on entre dans la salle. Cà permet d'économiser de la mémoire mais çà ralentit
l'ouverture de la salle.

45
Chap. 16 Plus sur les objets
Quand vous êtes dans la fenêtre des objets afin d'en créer un ou de le
modifier, vous avez un onglet Advanced :

16.1 Profondeur (Depth)

Les instances sont dessinées dans un certain ordre. Les instances

ayant une grande profondeur (Depth) sont dessinées en 1er. Les
instance ayant une petite profondeur son dessinées en dernier et donc
sont plutôt en avant-plan. Quand 2 instances ont la même
profondeur, elles sont dessinées dans l'ordre de création, la plus
ancienne en dessous de la plus récente. Si vous voulez qu'un objet
soit au dessus de tous les autres, donnez-lui une profondeur négative.
Si vous voulez qu'un objet soit en dessous de tous les autres, donnez-
lui une profondeur très très grande. Il est possible de changer la profondeur d'une instance par
programmation par la variable depth.

16.2 Objets persistants (Persistent objects)

Un objet persistant continue à exister quand vous changer de salle. Il n'est détruit que si vous
le demandez par programmation. C'est pratique quand il faut que le personnage principal aille
de salle en salle. L'utilisation de la persistance est un mécanisme fantastique mais qui peut
entraîner des erreurs.

16.3 Parents

Chaque objet peut avoir un objet parent dont il hérite les différents comportements. Par
exemple : si vous avez 4 balles différentes nommées Balle1, Balle2, Balle3 et Balle4, vous
pouvez créer et programmer la Balle1 et la transformer en parent des 3 autres. Ainsi il n'y aura
que l'objet Balle1 qui aura des comportements, les autres balles (2, 3 et 4) récupéreront ces
derniers automatiquement. Bref une sorte de Copier Coller des caractéristiques de Balle1. De
plus, la moindre modification d'actions dans un comportement de Balle1 se répercute aux 3
autres objets qui sont ses enfants. Cela permet une économie de temps non négligeable.

Souvent les objets auront des comportements presque identiques mais avec des petites
différences. Un monstre ira de haut en bas tandis qu'un autre ira de droite à gauche. Pour le
reste, ils agiront de la même façon et auront les mêmes comportements. Il est possible de
reprogrammer un comportement pour un objet enfant (override). Néanmoins, vous pouvez
appeler le comportement hérité (inherited) avec l'action adéquate.

Les objets parents peuvent aussi avoir des parents etc… Il n'est pas permis de créer des
boucles (obj1  obj2  obj3  obj1). Il est donc possible de créer un "super" objet dont
dériveront les autres, un hiérarchie plus ou moins complexe. Quand on utilise bien cette
notion, ce mécanisme, le travail se simplifie considérablement.

Il y a un autre usage des parents objets. Il y a aussi héritage des collisions venant des autres
objets. Laissez-moi vous expliquer par un exemple : Imaginons que vous ayez 4 objet de sol,
de terrain. Quand la balle touche le sol, elle change de direction. Cela est spécifié dans
l'événement Collision de la balle avec le sol. Parce que nous avons 4 différents sols, nous

46
avons besoin de créer le code de 4 événements Collision. Mais si vous déclarerez que le 1 er sol
est le parent des 4 autres, il suffit de créer le code Collision du 1 er pour que les 3 autres sols
réagissent de la même façon. Les autres collisions réagiront de façon identique.

Un problème néanmoins. Uniquement, les parents s'activent quand ils subissent leurs
événements. Quand vous trafiquez par programmation les instance d'un objet, seules les
instances de cet objet sont affectées. Exemple : Dans notre 1er exemple, si vous appliquez une
certaine action à toutes les instances de l'objet Balle1, çà ne change en rien les instances de
l'objet Balle2, même si Balle1 est le parent de Balle2. La même chose se produit pour le code.

16.4 Masques (Masks)

Quand 2 instances se télescopent, un événement Collision survient. Pour décider si les 2

instances rentrent en collision, on utilise les caractéristiques des sprites. Cà suffit dans la
plupart des cas mais vous pouvez baser la collision sur d'autres sprites que ceux de l'objet. Un
exemple typique : dans les jeux isométriques, les objets ont une hauteur (pour simuler une vue
en 3D). mais les collisions sont basées sur la partie au sol de l'objet. Pour ce faire, il faut créer
un sprite à part représentant la base du sprite en pseudo-3D et l'utiliser comme masque.

47
Chap. 17 Plus sur les Salles
Les salles dans Game Maker ont beaucoup d'options. Dans le chapitre 12, nous avons vu les
principales. Nous discuterons ici des autres.

17.1 Onglet Settings (Paramètres)

Il y a 2 aspects que nous n'avons discuté dans l'onglet Settings.

D'abord, une coche nommé Persistent. Normalement quand vous
quittez une salle et que vous y retournez plus tard, cette salle est
réinitialisée à zéro. C'est ce qui se passe en général mais si vous
jouez à un RPG (jeu de rôle ou d'aventure), çà ne va plus car vous
devez retrouver cette salle dans le même état que vous l'avez
quitté. L'option Persistent , si elle est cochée, s'occupe justement
de conserver l'état des lieux. Bien sur, si vous redémarrez le jeu, la
salle est bien initialisée à zéro. Actuellement, il y a une exception :
si vous marquez des objets comme étant persistant (voir Chap.
16), les instances de ces objets ne resteront pas dans la salle qu'on
quitte mais iront dans la prochaine salle qu'on visite.

Deuxièmement, il y a un bouton nommé Creation code. C'est ici

que vous pouvez éventuellement écrire un code en GML (voir plus
loin) qui sera exécuté lors de l'initialisation de la salle. C'est
pratique pour initialiser certaines variables, bien qu'on puisse le
faire par le mécanisme des événements et des actions. Comprenez
bien néanmoins la séquence suivante quand vous arrivez dans une
salle : Premièrement, la salle est ses instances sont générées
(quand la salle n'est pas persistante et n'a jamais été visitée).
Deuxièmement : Quand c'est la 1ère salle, l'événement Start Game
est exécuté pour toutes les instances. Troisièmement : Quand la salle n'est pas persistante et
n'a jamais été visitée, l'événement Room Creation est activé. Quatrièmement : l'événement
Start room est exécuté pour toutes les instances. Cinquièmement : pour toutes les instances,
l'événement Creation est activé. Par exemple, les événements Creation peuvent utiliser des
variables initialisées dans le bouton Creation code et dans ce code, vous pouvez faire
référence aux instances dans la salle.

17.2 Onglet Tiles (Tuiles)

Vous pouvez des arrière-plans composés de tuiles (Tiles). La

raison en est simple : dans beaucoup de jeux, vous aimez à avoir
une bal arrière-plan. Par exemple, dans un labyrinthe, les murs
sont mieux assortis et dans les jeux de plateforme, vous voyez des
décors tout mignons.
Vous pouvez faire de même avec Game Maker en définissant des
objets et en composant votre salle de ces objets. Le problème, c'est
que çà prendra du temps et de tas de ressources et ralentit
sérieusement le jeu à cause de tous les objets à gérer. Par exemple,
pour créer les jolis murs d'un labyrinthe, il faut 15 différentes
formes.

48
Une façon standard de pratiquer est de dessiner les murs et les objets statiques directement
dans l'arrière-plan sous la forme d'une image. Mais dans ce cas, comment gérer les collisions
entre les objets qui bougent et ces éléments du décor ? Le truc est simple : vous ne créez qu'un
seul objet de mur, si possible de la bonne taille. Quand vous dessinez une salle, placez lette
objet mur là où vous en avez besoin. L'astuce consiste à rendre cet objet Mur invisible. Ainsi
vous ne voyez pas l'objet mais seulement le décor de fond. Bien sur, il faut que le décor et le
mur invisible coïncident ! Vos objets dynamiques (personnage, monstres etc…) continuent de
réagir avec les événements appropriés.

Vous pouvez utiliser cette technique avec les objets statiques qui ne changent pas de forme ou
de position. Pour les jeux de plateforme, vous avez juste besoin d'un objet Mur et d'un objet
Sol mais par derrière, vous pouvez dessiner tous les magnifiques décors que vous désirez sur
lequels vous verrez que vous marchez dans l'herbe, les branches d'arbres etc…

Pour ajouter des tuiles à votre salle, vous avez besoin d'une image bitmap qui contient les
tuiles. Quelques unes sont fournis avec Game Maker. Si vous avez besoin de tuiles
partiellement transparentes, soyez sur que l'image bitmap le soit aussi. Maintenant pour
définir la salle, cliquez sur l'onglet Tiles. La fenêtre suivant s'affiche alors (ici, nous sommes
déjà prêts à ajouter des tuiles dans la salle).

En haut à gauche, l'image bitmap qui contient les tuiles. Pour choisir un jeu de tuiles, cliquez
sur le mouton de menu (à côté de l'endroit où est écrit "background0") et choisissez la bonne
image. Plus bas, vous pouvez changer un certain nombre de paramètres comme la largeur et la
hauteur des tuiles (Width et Height) ainsi que la séparation entre chaque tuile (Hsep et
Vsep), en général 0 ou 1.

49
Maintenant pour ajouter une tuile, cliquez dessus puis cliquez dans la salle à l'emplacement
approprié. Cà fonctionne exactement comme pour ajouter des instances d'objets. Les
anciennes tuiles déjà posées sont supprimées et remplacées par les nouvelles qu'on place
dessus. Sauf si ne cochez pas sur Delete underlying. Vous pouvez aussi utiliser le bouton
droit de la souris pour détruire les tuiles etc....

Notez qu'il y a aussi une coche Foreground tiles. Si vous cochez dessus, les tuiles seront
dessinées devant les objets qui passeront alors en dessous. Ainsi un objet peut se cacher
derrière un élément du décor.

L'utilisation de tuiles est une fonction très puissante à utiliser le plus possible. C'est plus
rapide que d'utiliser des objets et les tuiles ne sont stockés qu'une seule fois. Ainsi vous
pouvez construire de très vastes salles avec peu d'exigence en mémoire.

17.3 Onglet Views (Vues)

Enfin, un onglet Views est disponible. Cela offre un mécanisme qui permet de dessiner
différentes parties de votre salle à différents endroits de votre écran. Il y a plusieurs
utilisations des vues. Dans beaucoup de jeux, vous ne voyez qu'un seul morceau de l'univers
dans lequel se déplace le personnage principal. Par exemple, dans un jeu de plateforme, la vue
montre le personnage avec une partie du décor. Dans certain cas, le fond change quand on
atteint un bord. Dans les jeux à 2 joueurs, l'écran est divisé en 2 parties, une pour chaque
joueur. Dans certains jeux, le décor scrolle, bouge avec le joueur tandis que la parie contenant
les vies, le score ne bouge pas. C'est facile à faire avec Game Maker.

Quand vous cliquez sur l'onglet View, les informations suivantes s'affichent :

En haut, une coche nommée Enable the use of Views. Il faut

cocher dessus pour activer les vues. En dessous une liste des 8
vues que vous pouvez définir. En dessous, les paramètres de
définition de la vue sélectionnée. Les vues programmées sont en
gras.
D'abord, indiquez les positions gauche et haute la vue (Left et
Top) puis la largeur et la hauteur (W et H). Puis la position X et Y
de la vue à l'écran.

Souvent vous aurez besoin que la vue suive un certain objet. Cet
objet est à indiquer en bas (Object to follow). S'il y a plusieurs
instances de cet objet, seul le 1er est suivi par la vue. Normalement
le personnage principal doit être capable de se déplacer dans la
salle sans forcément faire bouger la vue. Vous pouvez spécifier la
taille de la bordure (HBor et VBor) qui doit rester visible autour
de l'objet. Enfin vous pouvez restreindre la vitesse de déplacement
(HSp et VSp) de l'objet quand la vue doit le suivre. Cà ralentit le
mouvement du personnage mais le jeu y gagne en souplesse de
scrolling. Utilisez –1 si vous voulez que la vue se change
instantanément.

50
Chap. 18 Chemins (Paths)
Dans beaucoup de jeux perfectionnés, vous aurez besoin que certaines instances suivent un
chemin bien déterminé. C'est faisable par programmation ou en jouant avec les événements de
temps (Timers) mais c'est pénible et un tantinet compliqué. Les ressources de type Path
offrent un mécanisme facile pour ce faire. L'idée de base est simple. Vous définissez un
chemin en le dessinant. Puis vous placez une action dans un événement (ex Creation) pour
demander à l'objet de suivre le chemin. Ce chapitre explique ceci en détail. Cette version de
GM possède encore quelques limitations mais d'autres possibilités seront offertes dans les
versions futures (et compatibles avec cette version).

18.1 Définir des Chemins

Pour ajouter un chemin à votre jeu, choisissez Add Path dans le menu Add. La fenêtre
suivante affichera (Ici, nous avons déjà ajouté un chemin).

En haut à gauche, le nom du chemin, puis les points qui définissent la trajectoire. Chaque
ligne contient les coordonnées X et Y ainsi que la vitesse (sp). La position n'est pas absolue
mais relative par rapport au point précédent. L'instance commencera toujours de la 1 ère
position et suivra les indications. Pour la vitesse, une valeur de 100 signifie la vitesse
originale de l'instance (100%). Une plus grande valeur augmente la vitesse et une plus petite
la diminue. La vitesse sera extrapolée entre 2 points, ainsi elle change graduellement.

Pour ajouter un point; cliquez sur le bouton Add puis indiquez la position et la vitesse.
Chaque fois que vous sélectionnez un point dans la liste, vous pouvez changer ses
caractéristiques. Cliquez sur Insert pour insérer un nouveau point à partir du point en cours et

51
sur Delete pour détruire le point en cours. Utilisez Clear pour effacer complètement le
chemin.

A droite, vous voyez le chemin. Vous pouvez aussi changer un point avec la souris. Cliquez
n'importe où dans l'image pour ajouter un point. Cliquez sur u point existant pour lui changer
a position. Quand vous cliquez sur un point tout en appuyant sur Shift, vous insérez un
nouveau point. Enfin, vous supprimez un point avec le clic droit de la souris. Attention, il
n'est pas possible de changer la vitesse avec la souris.

Vous pouvez influencer la forme du chemin de 2 façons :

Premièrement, vous pouvez changer le type de connexion :

 Staight lines En ligne droite
 Smooth curves En courbe

Deuxièmement, vous pouvez indiquer ce qui arrive quand le dernier point est atteint. Il existe
une série d'options :
 Stop moving arrêter le mouvement
 Jump to start sauter au point de départ
 Move to start se déplacer jusqu'au point de départ
 Reverse Rebrousser chemin vers le départ
 Continue Continuer dans la dernière direction

La plus classique est de continuer vers le 1er point, ce qui referme le chemin. Vous pouvez
stopper, vous déplacer ou sauter au 1er point ou de rebrousser chemin vers le début. Cette
dernière option, recommence ensuite le chemin à partir de sa position courante. Seules les 5
1ères itérations (boucles) sont montrées mais le chemin continuera sa course au-delà de ces 5
1ères boucles.

18.2 Affecter un chemin à un objet

Pour affecter un chemin à un objet, vous devez utiliser l'action Path dans un événement
comme par exemple, Create. Dans cette action, vous devez indiquer le nom du chemin et
aussi 2 autres valeurs. La 1ère est la vitesse initiale avec laquelle l'objet suivra le chemin. La
2ème indique comment l'objet commence sa trajectoire. Une valeur de 0 indique le début du
chemin, une valeur de 1 la fin du chemin. Une valeur de 0.5 indique dans le cas d'un chemin
aller-retour le moment où l'objet fait demi-tour.

Si vous utilisez un scripte (du code), vous avez plus de contrôle sur la façon dont le chemin
sera exécuté. Il y a 4 variables. La variable path_index indique l'index du chemin. La variable
path_position indique la position courante entre 0 (début) et 1 (fin). Elle change tant que
l'instance suit le chemin. La vitesse est contrôlée par la variable speed. La variable direction
est mise à jour à chaque étape du chemin. Vous pouvez les modifiez en cours de route. La
variable path_scale peut être utilisé pour changer l'échelle du chemin. 1 signifie l'échelle

52
originale (100%), une grande valeur signifie que le chemin se plus grand et vis versa. La
variable path_orientation indique la direction dans laquelle le chemin est exécuté (en degré).

Vous serez particulièrement content de savoir qu'une instance qui suit un chemin peut rentrer
en collision avec une autre. D'abord l'événement Collision est exécuté. Si l'autre instance est
solide, l'instance s'arrête. La variable path_position continuera à suivre le chemin. A tout
moment, l'instance pourra reprendre son chemin dans n'importe quelle direction.

18.3 Evénement Path

Comme décrit ci-dessus, vous pouvez indiquer ce qui arrive quand une instance arrive en fin
de chemin. A ce moment précis, l'événement End of Path survient. Vous le trouverez dans la
section Other (autres). Vous pouvez indiquer quelles actions surviennent alors comme
détruire l'instance ou la lancer sur un autre (nouveau) chemin.

53
Chap. 19 Scripts
Game Maker possède un langage interne de programmation. Une fois que vous serez familier
avec Game Maker et que vous voudrez l'utiliser dans sa pleine puissance, il sera bon de
commencer à apprendre ce langage. Pour une description complète, voir le chapitre 24.

Il y a 2 façons d'utiliser ce langage :

 Premièrement, vous pouvez créer des scripts, des morceaux de code (ils sont visibles
dans l'arborescence des ressources), vous pouvez les sauver puis les charger à volonté.
On peut les utiliser comme une bibliothèque qui étend les possibilités de GM.
 Deuxièmement, vous pouvez écrire du code dans certaines actions ou événements. Ces
codes n'ont pas de nom et n'utilisent pas d'arguments et donc sont moins puissants
mais suffisent dans pas mal de cas. Mise à part çà, il s'agit du même langage.

Un script peut avoir 10 arguments et peut retourner une valeur. En un plus imagé, un script est
une sorte de boîte noire dans laquelle peut entrer 10 tuyaux et de laquelle ne peut sortir qu'un
seul tuyau. On introduit des valeurs dans les tuyaux d'entrée et on récupère le résultat par le
tuyau de sortie. Bien sur, c'est à vous d'écrire le programme qui explique ce qui arrivent aux
valeur en entrée et comment on le triture pour avoir une seule valeur en sortie.

Pour ajouter un script, choisissez Add Script dans le menu Add.

En haut à droite, le nom du script (Name). Dans l'éditeur, vous écrivez le programme. En haut
des boutons pour Couper, Copier, Coller, Enregistrer, Ouvrir, Imprimer. Et aussi un bouton
pour tester si le script est correct. Pour être précis, si la syntaxe du script est correcte.
D'ailleurs les mots changent de couleur selon leur usage. Cette colorisation est modifiable
dans Preferences du menu et même déconnectable car elle ralentit parfois la saisie. Les
scripts sont importables par Import scripts et exportables par Export scripts du menu File.

NdT : J'ai raccourci les 2 pages initiales en 1 seule tout en gardant le sens général.
Le chapitre 24 est entièrement consacré aux scripts et au langage de programmation.

54
Chap. 20 Informations sur le Jeu (Game information)
Un bon jeu fournit au joueur diverses informations, comme comment jouer. Cette information
est affichée quand le joueur appuie sur la touche F1 (comme l'aide). Pour créer cette
information, double-cliquez sur la ressource Game Information dans la fenêtre principale.
Une fenêtre s'ouvrira sur un petit éditeur textuel. Vous pouvez utiliser différentes polices,
tailles, couleurs et styles. Un bon conseil : rédigez une information courte mais précise. Bien
sur, vous pouvez ajouter votre nom parce que vous en être le créateur. Quasiment tous les
jeux affichent une mini information sur le jeu lui-même et comment et par qui il a été créé.

Si vous voulez faire une aide un peu plus fantaisiste, utilisez par exemple Word. Puis passez
par le Copier Coller pour placer le texte voulu dans l'éditeur.

55
Chap. 21 Options de Jeu (Game options)
Il y a un certain nombre d'options que vous pouvez changer dans votre jeu. Double-cliquez
sur Game Options qui est dans la liste des ressources de la fenêtre principale. Elles sont
divisées en plusieurs onglets.

21.1 Options graphiques (Graphics)

Dans cet onglet, il y a une série d'options qui

font référence à l'apparence graphique de
votre jeu. Il faut faire attention aux options
choisies. En général, on enlève toutes les
coches afin d'avoir (en théorie) le plus forte
optimisation. N'oubliez pas cependant que
les joueurs ont des machines différentes de
la votre et certainement plus faibles. Faites
de multiples tests avant la diffusion si vous
le pouvez.

Start in fullscreen mode

Démarre le jeu en plein écran.

Scale percentage in windowed mode

Facteur d'échelle pour l'affichage de
la fenêtre de jeu. 100 signifie 100%,
donc à l'échelle réelle. La mise à
l'échelle demande du temps machine
mais certaines cartes graphiques s'en
occupent efficacement. Evitez néanmoins les valeurs inférieures à 100.

Scale percentage in fullscreen mode

Indique le facteur d'échelle pour l'affichage en plein écran. 100 indique 100%, échelle
réelle. 0 signifie agrandissement maximum. Comme déjà dit, cela prend du temps.

Only scale when there is hardware support

Accepter la mise à l'échelle que si la carte vidéo l'accepte. Attention, certaines cartes
n'indiquent pas qu'elles savent gérer la mise à l'échelle.

Set the resolution of the screen

L'écran a une résolution particulière. 3 choses jouent un rôle : le nombre de pixels
(horizontal et vertical), le nombre de bits utilisés pour représenter les couleurs et la
fréquence de rafraîchissement de l'écran. Normalement, Game Maker n'a pas à
changer ces paramètres. Mais si le jeu s'exécute sur un écran de très grande résolution
et que la salle à afficher est très petite, le joueur verra alors à l'écran une fenêtre
Windows miniature. On peut palier ce problème en mettant le jeu en plein écran, ce
qui retaille le jeu et ralentit fatalement la vitesse. La meilleure solution est de
demander à Game Maker de changer la résolution de l'écran. Pour cela, cochez cette
option. D'autres options s'affichent alors :
 la profondeur de couleurs (Color depth setting) (16 ou 32 bits; normalement 16
bits est le meilleur choix),

56
  la taille de l'écran (Screen size) (640x480, 800x600, 1024x768, ou 1280x1024;
attention, tous les ordinateurs ne supportent pas des résolutions élevées), et
 la fréquence (Frequency) (60, 70, 85, 100; si la fréquence est trop élevée, la
fréquence par défaut est choisie).

Use exclusive graphics mode

En mode exclusif, le jeu a le plein contrôle de l'écran. Donc aucune autre application
ne s'affiche. Cela accélère le jeu et les effets spéciaux (comme le Gamma). Si vous
êtes sur que l'ordinateur du joueur est dans la bonne résolution, choisissez cette option
pour un meilleur rendu final. N'oubliez pas cependant qu'aucune autre fenêtre
Windows ne s'affiche. Donc vous ne pouvez pas utiliser des actions qui affichent un
message, qui posent une question, ou affichent le score etc… Aucune erreur ne peut
aussi s'afficher donc soyez sur de votre coup ! Le mode Debug est aussi inactif.

Wait for vertical blank before drawing

L'écran est rafraîchi un certain nombre de fois par seconde (entre 50 et 100, la
fréquence). Après le rafraîchissement, il y a un "blanc" vertical (blanc de
synchronisation) durant lequel rien ne se passe à l'écran. Si vous dessinez l'écran en
continu, une partie de l'image et une partie de la prochaine image peuvent se retrouver
ensembles à l'écran, ce qui n'est pas du meilleur effet. Il est donc bon d'attendre la fin
de cette synchronisation verticale pour afficher l'image suivante. Inconvénient,
attendre la synchronisation verticale prend bien sur du temps et ralentit le jeu….

Display the cursor

Afficher le curseur de la souris. Ne pas mettre de coche permet d'aller plus vite. Vous
pouvez facilement créer votre propre curseur avec Game Maker.

Display the caption in fullscreen mode

Affiche en mode Plein écran une petite boîte (en haut à gauche) qui affiche le nom de
la salle, le score et le nombre de vie. Il est néanmoins plus esthétique de vous charger
vous-même de la visualisation de ces informations.

21.2 Options de Clavier (Key)

Let <Esc> end the game

Si cette option est cochée, la touche Esc/Echap quitte le jeu sans le sauvegarder. Cette
option vous éjecte donc du jeu sans aucune autre forme de procès (sans événement et
action). Cliquer sur la case de fermeture de la fenêtre Windows provoque aussi un
Echap.

Let <F1> show the game information

Si on coche, la touche F1 affichera une fenêtre qui présentera les informations du jeu
(si on n'est pas en mode exclusif).

Let <F4> switch between screen modes

Si on coche, la touche F4 permet de basculer du mode Plein écran au mode Fenêtre (si
on n'est pas en mode exclusif).

Let <F5> and <F6> load and save the game

Si on coche, la touche F5 sauvegarde le jeu en cours et la touche F6 recharge le
dernier jeu sauvegardé.

57
21.3 Options d'Interaction

Generate continuous keyboard events

Si cette option est cochée, des événements Clavier sont générés à chaque cycle tant
qu'une touche est appuyée. Si cette option n'est pas cochée, un événement clavier n'est
généré que lorsque la touche est enfoncée et pour chaque répétition de la touche.

Generate continuous mouse events

Si cette option est cochée, des événements Souris sont générés à chaque cycle tant
qu'un bouton est enfoncé. Si cette option n'est pas cochée, un événement Souris n'est
généré que lorsque l'on appuie sur un bouton.

Freeze the game when the form looses focus

Geler le jeu quand la fenêtre perd la main. Si une autre fenêtre Windows passe au 1 er
plan, le jeu s'arrête momentanément.

21.4 Options de Score

Show the score

Si cette option est cochée, le score est affiché dans le titre de la fenêtre Windows du
jeu, idem pour le nombre de vies.

D'autres options s'occupent de l'apparence :

Vous pouvez mettre une image de fond à la liste des scores (background image)
(taille de 360x400 de préférence sinon l'image est déformée). Sinon vous définissez
une couleur de fond (Background color). Une couleur de texte est aussi possible pour
les scores (Text color for other places) ainsi que pour la nouvelle entrée (Text color
for new place). Idem pour la police (Change Font) et si la fenêtre a une bordure
(Highscore form has a border).

58
21.5 Options de Chargement (Loading)

Ici vous indiquez ce qui arrive lors du

chargement du jeu.

Show Image Cochez pour afficher une

image au chargement.
Choisissez-la avec le
bouton Change image.

No loading aucune barre de

chargement ne sera
visible.

Default loading barre de chargement par

défaut.

Own loading vous avez votre propre barre, 2 images à placer (une pour le fond et une
pour la barre elle-même)

Game Icon Icône de 32x32 pixels en 16 couleurs seulement ! Cliquez sur Change Icon
pour changer d'icône.

Game Id Identificateur unique de jeu afin que chaque jeu ait son fichier de score et
n'écrase pas celui du voisin !

21.6 Options d'Erreur (Error)

Vous avez ici certaines options utiles en cas d'erreurs ou de plantage de votre jeu.

Display error messages

Permet d'afficher les messages d'erreur sauf si vous êtes en mode exclusif..

Write error messages to file game_errors.log

Toutes les erreurs sont écrites dans le fichier errors.log qui sera situé dans
le même répertoire que le jeu.

Abort on all error messages

Certaines erreurs sont fatales tandis que d'autres peuvent être ignorées.
Avec cette option, toutes les erreurs sont considérées comme fatales. Dans
la version finale que vous distribuerez, cochez sur cette option..

Treat uninitialized variables as 0

Une erreur classique est d'utiliser une variable avant de l'initialiser. Si cette
option est cochée, les variables sont implicitement initialisées à 0 (zéro).
N'abusez pas cependant de cette facilité.

59
Chap. 22 Considérations sur la Vitesse
Si vous fabriquez des jeux complexes, vous aurez certainement des problèmes d'optimisation
de la vitesse du jeu. Game Maker fait de son mieux pour optimiser mais une bonne partie
dépend des options que vous avez choisies. Il est parfois plus rentable de consommer de la
mémoire pour gagner en vitesse. Voici quelques indications…

D'abord faits attention aux sprites et aux arrière-plans. Les sprites animés consomment
beaucoup de mémoire et dessiner beaucoup de sprites consomme encore plus. Donc
minimalisez la taille des sprites pour limiter les dégâts. Limitez aussi la transparence autours
du sprite. Décidez soigneusement des sprites chargés en mémoire vive de ceux chargés en
mémoire vidéo. Idem pour ceux qui ne sont chargés que si on les utilise. Ceci s'applique aussi
aux arrière-plans. Quand un arrière-plan est vaste, évitez de le mettre en mémoire vidéo. Si
vous avez un avant-plan, décochez l'utilisation d'une couleur d'arrière-plan.

Si vous utilisez le mode plein écran ou le mode exclusif, faites attention que la taille de la
salle ou de la fenêtre ne soit jamais plus grande que la taille de l'écran. Eviter d'utiliser des
graphiques agrandis, dont l'échelle n'est pas de 100%, cela consomme des ressources
machine. Dessinez plutôt des variantes (une à 100%, une autre à 200% etc…). Si possible
enlevez la flèche du curseur, çà ralentit l'affichage des graphiques.

Faites attention quant à l'utilisation de plusieurs vues à l'écran. Chaque vue doit être
redessinée.

En plus des graphiques, il y a d'autres aspects qui influencent la vitesse. Limitez le nombre
d'instances. Détruisez les instances quand vous n'en avez plus besoin (quand vous quittez la
salle). Limitez les actions dans l'événement Step (cycles). L'exécution ds actions est assez
rapide mais n'oubliez pas que c'est interprété donc lent et comme l'événement Step est appelé
plusieurs fois par seconde… Certaines actions et fonctions, consomment aussi beaucoup de
temps comme celles qui s'occupent de toutes les instances (l'action Bounce par exemple).

Songez aussi aux collisions et à leurs gestions. Les objets qui n'ont pas d'événement Collision
sont plus rapides que ceux qui en ont. Arrangez-vous pour traiter un maximum d'objets qui
ont peu d'instances.

Faits attention avec les sons. Ils prennent de la mémoire et du temps système. Réutilisez un
maximum de sons plutôt que de vouloir à tout prix avoir un son par objet.

Enfin, si vous voulez fabriquer un jeu utilisable par un maximum de gens, testez-le sur une
ancienne machine, une avec pas trop de mémoire, pas la toute dernière sortie.

60
Chap. 23 Distribuez votre Jeu
Une fois que vous aurez créé un bon petit jeu, vous voudrez probablement le rependre autour
de vous. Vous êtes libre de distribuer vos jeux de tous les moyens voulus. Vous pouvez même
les vendre. Allez jeter un coup d'œil sur la licence pour plus d'information.

Il y a 3 façons de distribuer un jeu :

 La façon la plus simple étant de donner le fichier Gmd qui contient le jeu. Dans ce cas
il faut que la personne ait Game Maker (Vous n'êtes pas autorisé à distribuer Game
Maker avec votre jeu mais on peut le télécharger gratuitement sur le site). Ainsi la
personne pourra changer le jeu.

 La deuxième façon est de créer une version exécutable du jeu (stand-alone). Il s'agira
alors d'un programme (Exe). Choisissez Create stand-alone dans le menu File. On
vous demandera le nom que vous voulez donner à l'exécutable. Puis cliquez sur OK et
vous avez votre jeu sous forme de programme. Il est possible de changer l'icône de
l'exécutable dans la fenêtre des Options. Si vos jeux utilisent d'autres fichiers externes,
n'oubliez pas de les copier dans le dossier de votre exécutable. Compressez-les en Zip.

 La troisième façon est de créer un programme d'installation à partir de l'exécutable de

votre jeu et d'éventuellement ses fichiers annexes. Il existe un certain nombre de
freewares disponibles gratuitement sur Internet. La façon de procéder dépendra bien
sur du programme d'installation.

61
Chap. 24 Le Langage de Game Maker (GML)
Comme vous l'avez déjà lu, Game Maker contient un langage de programmation. Ce langage
de programmation vous offre plus de flexibilité et de contrôle que les actions standard. Ce
langage est le GML (Game Maker Language). Il y a 3 emplacements pour écrire un
programme en GML :
 Quand vous définissez un script. Un script est un programme en GML.
 Quand vous ajoutez une action à un événement. Dans une action Code, vous pouvez
écrire un programme en GML.
 Quand vous spécifiez une valeur dans une action, vous pouvez utiliser une expression
(un calcul) en GML. Une expression n'est pas un programme en soi mais un morceau
de programme qui retourne une valeur.

Dans ce chapitre, je décrirai les structures de base en GML. Quand vous voudrez utiliser un
programme en GML, il y a diverses choses à savoir et à faire attention. D'abord, pour vos
ressources (sprites, objets, sons, etc.), vous devez utiliser des noms qui commencent par une
lettre et qui seront composés que de lettre, de chiffres et du symbole souligné ( _ ). N'utilisez
pas non plus de mots déjà réservés par le langage (NdT : utilisez donc des noms en français,
ainsi, il y a peu de risque qu'un nom français corresponde à un ordre anglais !).

24.1 Programme

Un programme est un bloc. Un bloc est composé d'une ou de plusieurs instructions qui sont
encadrées par les symboles ‘{’ et ‘}’. Les instructions doivent être séparées par le symbole ';' .
Donc la structure générale d'un programme est :

{
<instruction>;
< instruction >;
…
}

Une instruction peut est aussi un bloc d'instructions. Il existe différentes instructions dont
nous parlerons par la suite.

24.2 Variables

Comme l'écrasante majorité des langages de programmation, GML contient des variables. Les
variables peuvent contenir des nombres réels ou des chaînes de caractères. Les variables n'ont
pas besoin d'être déclarées. Il existe un grand nombre de variables internes préconstruites.
Certaines sont générales ou globales comme mouse_x et mouse_y qui indiquent la position
actuelle de la souris. D'autres sont locales à l'instance de l'objet comme x et y qui indiquent la
position courante de l'instance. Une variable possède un nom qui doit commencer par une
lettre, composée ensuite de lettres, de chiffres et du symbole ‘_’. (la longueur maximum du
nom est de 64 caractères). Quand vous utilisez une nouvelle variable, elle est locale à
l'instance et n'est pas connue dans le programme des autres instances (même du même objet).
Il est possible néanmoins de faire référence à une variable d'une autre instance, voir plus loin.

62
24.3 Affectations

Une affectation assigne la valeur d'une expression à une variable. Une affectation a la forme :

<variable> = <expression>;

Il est possible d'utiliser des abréviations du style opérateur= comme en C, Java, PHP etc…

Exemple : mavar = mavar + 10;

mavar += 10;

Les abréviations permises sont : += -= *= /=

Elles ne fonctionnent que sur les variables numériques et pas sur les chaînes de caractères.

24.4 Expressions

Les expressions ont soit des nombres réels (exemple : 3.4), soit des chaînes de caractères
encadrées par des apostrophes ou des guillemets (exemple : ‘hello’ or “hello”), soit des
expressions plus compliquées. Pour les expressions, les opérateurs binaires suivants existent
(listés par ordre de priorité croissante) :

 &&, || combinent des valeurs booléennes

(&& signifie ET et || signifie OU)
 <, <=, ==, !=, >, >= comparaisons, le résultat est VRAI (1) ou FAUX (0)
(!= signifie différent de, == signifie égal, équivalent à)
 +, - addition, soustraction
 *, /, div, mod multiplication, division, division entière
et modulo (reste de la division)

Les opérateurs unaires (monadiques) suivants existent aussi :

 ! Non, Pas convertit Vrai en Faux et Faux en Vrai

 - Négatif négative la valeur qui suit

Comme valeurs, vous pouvez utiliser des nombres, des variables ou des fonctions qui
retournent une valeur. Des sous expressions peuvent être placées entre parenthèses ( ). Tous
les opérateurs retournent une valeur réelle. Les opérateurs de comparaison fonctionnent aussi
sur les chaînes de caractères et l'opérateur + concatène (soude) des chaînes.

Voici un exemple qui utilise divers opérateurs :

{
x = 23;
str = 'salut tout le monde';
y += 5;
x *= y;
x = 23*((2+4) / sin(y));
str = 'salut' + " tout le monde";
b = (x < 5) && !(x==2 || x==4);
}

63
24.5 Variables Locales et Globales

Vous créez une variable en lui affectant une valeur (aucune déclaration n'est demandée). Si
vous utilisez une variable, celle-ci variable sera stockée dans l'instance de l'objet en cours, elle
est locale à cette instance. De ce fait, cette variable ne sera pas utilisable dans d'autres
instances du même objet ou d'autres objets. Vous pouvez accéder aux variables d'autres
instances en écrivant d'abord le nom de l'instance, un point, puis le nom de la variable (ex :
mavoiture.vitesse).

Pour créer des variables globales qui seront visibles par toutes les autres instances de tous les
objets, précédez-les par le mot global et un point. Vous pouvez ainsi écrire :

{
if (global.faireqqchose)
{
// Faire quelque chose
global.faireqqchose = false;
}
}

24.6 Adresser les variables d'autres instances

Comme ce le fut décrit peu avant, vous pouvez affecter des variables de l'instance en cours :

x = 3;

Mais dans un certain nombre de cas, vous aurez à affecter des variables situées dans d'autres
instances, comme changer la vitesse de déplacement des balles ou déplacer le personnage
principal à une position donnée. Dans ce cas, écrivez d'abord le nom de l'instance ou de
l'objet, un point puis le nom de la variable :

maBalleRouge.speed = 0;

Cela changera la vitesse de toutes les instances de l'objet maBalleRouge. Il y a un certain

nombre d'objets spéciaux :

 self l'instance dans laquelle s'exécute l'action

 other l'autre instance concernée par l'événement collision
 all toutes les instances
 noone aucune instance (çà peut paraître étrange, nous en verrons l'utilité plus tard)
 global pseudo objet qui stocke les variables globales

Ainsi, vous pouvez avoir les instructions suivantes :

other.sprite_index = sprite5;
all.speed = 0;
global.message = 'un bon résultat';
global.x = balle.x;

Vous pouvez éventuellement vous étonner sur ce que fait la dernière instruction quand il y a
plusieurs balles. Dans ce cas, la 1 ère instance est choisie et sa valeur x est affectée à la variable
globale. Mais si vous voulez récupérer la valeur d'une balle particulière, cela est plus difficile.
Chaque instance possède un identifiant (id) unique. Quand vous placez des instances dans une

64
salle, l'identifiant est affiché quand votre souris reste sur l'instance. C'est un nombre plus
grand ou égal à 100.000 (cent mille). Pour atteindre une variable d'instance, encadrez l'id par
des parenthèses. Exemple, si l'id de la balle est 100032, vous pouvez écrire :

(100032).speed = 0;

Quand vous créez une instance dans un programme, sa création retourne l'id. Exemple :

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

Cela crée une balle et lui attribut une vitesse. Permettez-moi une petite précision : le point (.)
est actuellement un opérateur, il demande la valeur comme argument de gauche et une adresse
ou variable comme argument de droite et retourne l'adresse de cette variable particulière de
cet objet ou instance désignée. Tous les noms d'objets et les objets spéciaux sont en réalité des
valeurs et peuvent être remplacés par leur valeur. Le programme suivant le démontre :

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

La dernière instruction doit être lue ainsi : nous prenons l'id du flag et pour l'instance visée par
l'id, nous mettons sa coordonnée x à 12.

Les noms d'objets, les objets spéciaux et les identifiants d'instances peuvent être aussi utilisés
dans un bon nombre de fonctions.

24.7 Tableaux

Vous pouvez utiliser des tableaux à 1 ou 2 dimensions dans GML. Mettez l'index entre
crochets. Pour les tableaux bidimensionnels, séparez les 2 index par une virgule. Quand vous
utilisez pour la 1ère fois un tableau, celui-ci est créé. Chaque index commence à 0. Faites
attention en utilisant des index trop grand, cela exige beaucoup de mémoire. N'utilisez jamais
d'index négatifs. Chaque index est limité à 32.000 éléments et à 1.000.000 pour la taille totale.

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

24.8 Instruction If

L'instruction If a la forme suivante :

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

65
L'instruction peut être aussi un bloc. L'expression est évaluée, si sa valeur (arrondie) est <= 0
(false faux), l'instruction après le else est exécutée. Sinon dans l'autre cas (true vrai),
l'instruction après l'expression est exécutée. C'est une bonne habitude d'encadrer les
instructions entre accolades.

if (<expression>)
{
<instruction(s)>
}
else
{
<instruction(s)>
}

Exemple
Le programme suivant déplace l'objet vers le milieu de l'écran :
if (x<200) {x += 4} else {x -= 4};

24.9 Instruction Repeat

L'instruction repeat a la forme suivante :

repeat (<expression>) <instruction>

L'instruction est répétée autant de fois qu'indiquée par la valeur arrondie de l'expression.

Exemple
Le programme suivant crée 5 instances de la balle à des coordonnées aléatoires :

repeat (5) instance_create(random(400),random(400),balle);

24.10 Instruction While

L'instruction while a la forme suivante :

while (<expression>) <instruction>

Tant que l'expression est vrai (true), l'instruction est exécutée (cette instruction peut être bien
sur un bloc). Faites attention : il est possible que par erreur de logique, la boucle devienne
infinie et dans ce cas, le programme ne réagira plus aux demandes de l'utilisateur.

Exemple
Le programme suivant tente de placer un objet à une position libre.

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

66
24.11 Instruction For

L'instruction for a la forme suivante :

for (<instruction1> ; <expression> ; <instruction2>) <instruction3>

Cela fonctionne ainsi : d'abord l'instruction1 exécutée. Puis l'expression est évaluée. Si elle est
vrai (true), l'instruction3 est exécutée puis l'instruction2 et l'expression est évaluée à noueau,
et ainsi de suite. Cela continue jusqu'à ce que l'expression soit fausse.

(Note du traducteur : la syntaxe du for est inspirée à 100% du langage C qui en interne
transforme la boucle for en un boucle while.

Boucle For Equivalence While

for (i = 1; i <= 10; i++ ) i = 1;
{ while(i<=10)
fairetruc; {
} fairetruc;
i++;
}
)

L'exemple le plus classique d'utilisation est un compteur.

Exemple
Le programme suivant initialise un tableau de 10 éléments avec les valeur de 1 à 10 :

for (i=0; i<9; i+=1) liste[i] = i+1;

24.12 Instruction Exit

L'instruction for a la forme suivante :

exit

Elle permet de quitter, d'arréter l'exécution du programme. Attention, cela ne met pas fai au
jeu lui-même. Pour ce faire, utilisez la fonction game_end(); Voir plus loin.).

24.13 Fonctions

Une fonction est un nom suivit de 0, 1 ou n arguments séparés par des virgules et encadrés par
des parenthèses :

<fonction>(<arg1>,<arg2>,…)

Il y a 2 types de fonction :

 Une large collection de fonctions préconstruites pour vous permettre de contrôler tous les
aspects de votre jeu.
 Tout script défini par vos soins peut être utilisé co mme fonction.

67
Notez que même pour une fonction sans argument, vous devez utiliser les parenthèses.
Beaucoup de fonctions retournent une valeur qui peut être utilisée dans une expression.
D'autres exécutent simplement une suite d'actions.

24.14 Scripts

Quand vous créez un script, vous voulez accéder aux arguments que vous lui passez. Ces
argument sont stockés dans les variables argument0, argument1, …, argument9.
Ainsi, vous pouvez passer jusqu'à 10 arguments. (Notez que vous n'avez droit à 3 arguments
pour un script appelé d'une action)

Les scripts peuvent aussi retourner une valeur utilisable dans une expression. Pour ce faire,
utilisez l'instruction suivante :

return <expression>

Le script s'arrête lors de l'instruction return.

Exemple
Ceci est un petit script qui retourne le carré de son argument :

{
return (argument0*argument0);
}

Pour appeler un script dans un programme GML, écrivez le nom de la fonction avec ses
arguments encadrés par des parenthèses.

24.15 Constructeur With

Comme déjà indiqué, il est possible de lire et de changer la valeur d'une variable d'une
instance. Mais dans certains cas, vous voudrez faire certaines actions sur plusieurs instances à
la fois. Imaginez que vous voulez déplacer de 8 pixels toutes les balles vers le bas. Vous
songerez alors à écrire le code suivant :

balle.y = balle.y + 8;

Mais ce n'est pas correct. La partie droite de l'affectation prend la valeur de la coordonnée y
de la 1ère balle et lui ajoute 8 et écrit le résultat dans la coordonnée y de toutes les balles. Du
coup, toutes les balles ont la même coordonnée y. L'instruction :

balle.y += 8;

fera la même chose puisqu'il s'agit d'une abréviation. Comment donc s'en sortir ? C'est là
qu'intervient le constructeur with. Sa syntaxe est :

with (<expression>) <instruction>

68
<expression> indicate une ou n. Vous pouvez utiliser l'id d'une instance, le nom d'un objet ou
une des objets spéciaux (all, self, other, noone). <instruction> est alors exécutée pour chaque
instance indiquée. Donc pour déplacer toutes les balles de 8 pixels vers le bas, écrivez :

with (balle) y += 8;

Si vous voulez exécuter plusieurs instructions, encadrez-les par des accolades. Exemple, pour
déplacer chacune des balles à une position aléatoire, écrivez :

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

Notez ceci :
 A l'intérieur des instructions, l'instance indiquée devient l'instance en cours (self).
 A l'intérieur des instructions, l'instance d'origine devient l'instance other .

Ainsi, pour déplacer toutes les balles à la position de l'instance en cours (celle où s'exécute le
programme), écrivez :

with (balle)
{
x = other.x; // self.x = other.x
y = other.y;
}

L'utilisation de with est extrêmement puissante. Laissez-moi vous donner d'autres exemples.
Pour détruire toutes les balles, écrivez :

with (balle) instance_destroy();

Si une bombe explose et que vous voulez détruire toutes les instances comprises dans un
rayon de 50 pixels, écrivez :

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

24.16 Commentaires //

Vous pouvez ajouter des commentaires à vos programmes. Tout ce qui est placé sur une ligne
après // n'est pas exécuté.

// voici un petit programme

// et son commentaire
// qui s'étale sur plusieurs lignes
balleverte.x = 10; // balle verte à gauche
ballerouge.x = 200; // balle rouge à droite

69
24.17 Style Pascal

L'interpréteur est assez permissif. Vous pouvez écrire vos programmes dans un style à la
Pascal en utilisant les mots begin, end pour délimiter un bloc et := pour l'affectation. Vous
pouvez aussi ajouter les mots then et do pour les instructions if et while. Le programme
suivant est valide :

begin
x := 10;
while x>0 do
begin
if x=5 then x:=x-5 else x:=x-1;
end;
end;

24.18 Fonctions et Variables en GML

GML contient un grand nombre de fonctions préconstruites ainsi que de variables. Avec
celles-ci, vous contrôlez toutes les parties de votre jeu. Pour toutes les actions, il existe une
fonction correspondante. Ainsi, si vous n'aimez pas utiliser les actions, vous pouvez écrire du
code à la place.
Mais il y a beaucoup de variables et de fonctions qui n'ont pas d'équivalences dans les actions.
Si vous désirez écrire des jeux avancées, il est conseillé d'écrire alors du code et donc de lire
les chapitres qui suivent. Souvenez-vous aussi que ces variables et ces fonctions peuvent être
utilisées dans des actions. Ainsi si vous n'avez pas envie de vous lancer à fond dans l'écriture
de scripts, vous pouvez tirer bénéfice de cette information.

Les conventions suivantes seront utilisées par la suite :

 Les noms de variables marqués d'une étoile * sont en lecture seulement.

Leur valeur ne peut être changée.

 Les noms de variables suivis de [0..n] sont des tableaux.

Le nombre maximum d'index est ainsi donné.

70
Chap. 25 Fonctions de Calcul
Game Maker contient un grand nombre de fonctions pour calculer diverses choses. En voici la
liste complète.

25.1 Constantes

Les constantes suivantes existent :

true équivaut à 1.
false équivaut à 0.
pi équivaut à 3.1415…

25.2 Fonctions Mathématiques

Les fonctions suivent existent et retournent un nombre réel :

random(x) retourne un nombre réel entre 0 et x, x non compris

abs(x) valeur absolue de x
sign(x) signe de x (-1 or 1)
round(x) x arrondi à l'entier le plus proche
floor(x) x converti à l'entier proche le plus petit
ceil(x) x converti à l'entier proche le plus grand
frac(x) partie factionnelle de x
sqrt(x) racine carrée de x avec x >= 0
sqr(x) carré de x, soit x*x.
power(x,n) x à la puissance n
exp(x) e à la puissance x
ln(x) logarithme népérien (naturel) de x
log2(x) log en base 2 de x
log10(x) log en base 10 de x
logn(n,x) log en base n de x
sin(x) sinus de x (x en radians)
cos(x) cosinus de x (x en radians)
tan(x) tangente de x (x en radians)
arcsin(x) sinus inverse de x
arccos(x) cosinus inverse de x
arctan(x) tangente inverse de x
degtorad(x) convertit les degrés en radians.
radtodeg(x) convertitt les radians en degrés.
min(x,y) minimum entre x et y
max(x,y) maximum entre x et y
min3(x,y,z) minimum entre x, y et z
max3(x,y,z) maximum entre x, y et z
mean(x,y) moyenne de x et y

71
 point_distance(x1,y1,x2,y2)
distance entre le point (x1,y1) et le point (x2,y2)
point_direction(x1,y1,x2,y2)
angle à partir du point (x1,y1) au point (x2,y2) in degrés.
is_real(x) x est-il un réel ? (true/false), l'opposé de is_string(x)
is_string(x) x est-il une chaîne de caractères ? (true/false)

25.3 Fonctions Alphanumériques

Les fonctions suivantes s'occupent des chaînes de caractères :

chr(val) retourne le caractère dont le code ascii est val

ord(texte) retourne le code ascii du 1er caractère
real(texte) convertit une chaîne en un réel. Str peut contenir le signe moins,
un point décimal et une partie exponantielle
string(val) convertit une valeur réelle en une chaîne (2 décimales maxi)
string_format(val,ncar,déc)
convertit val en une chaîne.
ncar : nombre de caractères. déc : nombre de décimales
string_length(texte)
nombre de caractères dans texte
string_pos(soustexte,texte)
position de soustexte dans texte (0 = pas trouvé)
string_copy(texte,début,ncar)
sous-chaîne de texte qui débute à la position début sur ncar caractères
string_delete(texte,début,ncar)
supprime ncar caractères à partir de la position début
string_insert(soustexte,texte,début)
insère soustexte dans texte à partir de la position début
string_lower(texte)
minuscule
string_upper(texte)
majuscule
string_repeat(texte,nfois)
repéte nfois le texte
string_letters(texte)
élimine tout ce qui n'est pas une lettre dans texte
string_digits(texte)
élimine tout ce qui n'est pas un chiffre dans texte
string_lettersdigits(texte)
élimine tout ce qui n'est pas une lettre ou un chiffre dans texte

NdT : comme il s'agit de fonctions, les arguments d'origine ne sont pas modifiés :

txt = 'ab1234cd' ;
res = string_delete(txt, 3, 4);

txt  'ab1234cd'
res  'abcd'

72
Chap. 26 GML: Déroulement du Jeu
Il y a u grand nombre de variables et de fonctions que vous pouvez utiliser pour définir le jeu.,
particulièrement en ce qui concerne le déplacement et la création d'instances, le temps et la
gestion des événements.

26.1 Concernant le Déplacement

Bien sur, l'un des aspects les plus importants du jeu concernent les déplacements d'instances
d'objet. Chaque instance possède 2 variables préconstruites x et y qui indiquent la position de
celle-ci (pour être plus précis, où se situe l'origine du sprite par rapport au point 0,0 de la
salle, repérée par le coin supérieur gauche). Vous pouvez changer l'emplacement de l'instance
en changeant les variables x et y. Si vous voulez que les objets fassent des déplacements
complexes, c'est par ce biais que vous y parviendrez. Il faudra mettre le code dans
l'événement Step.

Si l'objet se déplace dans une direction constante avec une vitesse constante, il y a un moyen
simple de s'en sortir. Chaque instance possède une vitesse horizontale (hspeed) et une vitesse
verticale (vspeed). Elles sont exprimées toutes les deus en pixels par cycle. Une vitesse
horizontale positive signifie que l'objet va vers la droite et une vitesse négative qu'il va vers la
gauche. Une vitesse verticale positive indique un déplacement vers le bas et une vitesse
verticale négative un déplacement vers le haut. Il suffit d'initialiser une seule fois ces 2
variables pour donner un mouvement constant à l'objet.

Il existe une autre méthode pour faire la même chose en utilisant une direction (en degrés 0-
359), et une vitesse (speed) qui doit être non négative. Vous pouvez lire ces variables et aussi
y écrire, ce qui change alors les hspeed et vspeed. Il existe aussi une friction et une force de
gravité et une direction de gravité. Enfin la fonction motion_add(dir,speed) ajoute au
déplacement en cours des paramètres.

Pour résumer, chaque instance possède les variables et fonctions suivantes :

x position en x
y position en y
xprevious ancienne position en x
yprevious ancienne position en y
xstart position de départ en x dans la salle
ystart position de départ en y dans la salle
hspeed vitesse horizontale en pixels par cycle
vspeed vitesse verticale en pixels par cycle
direction orientation (0-360, sens trigonométrique, inverse des
aiguilles d'une montre, 0 = à droite).
speed vitesse en pixels par cycle
friction friction en cours (pixels par cycle)
gravity gravité en cours (pixels par cycle)
gravity_direction direction de la gravité (270 vers le bas)
motion_set(dir,vit) impose une vitesse dans une direction donnée
motion_add(dir,vit) ajoute une vitesse et un direction

73
 path_index numéro du chemin que l'instance suit (-1 = pas de chemin)
path_position position dans le chemin en cours (0 : début, 1: fin)
path_orientation orientation (sens trigonométrique) (0: normal)
path_scale échelle du chemin. (1: 100%)

Un grand nombre de fonctions vous aident à définir vos mouvements :

place_free(x,y) indique si l'instance placée en position x,y ne

télescope rien. Utilisé typiquement pour s'assurer
qu'on peut se placer à telle position.
place_empty(x,y) indique si l'instance placée en x,y ne rencontre rien
Cette fonction s'occupe aussi des instances non
solides.
place_meeting(x,y,obj) indique si l'instance placée en x,y rencontre l'objet
obj. On peut aussi utiliser l'id d'une instance ou les
mots all et other.
place_snapped(hor,vert) indique si l'instance est alignée sur la grille dont les
carreaux sont de côté hor et vert (la résolution).

move_random(hor,vert) déplace l'instance à une position aléatoire tout en

move_snap(hsnap,vsnap)
move_towards_point(x,y,vit)
move_bounce_solid(adv)
move_bounce_all(adv)
move_contact(dir)
s'accrochant à la grille de résolution hor et vert.
accroche l'instance à la grille.
déplace l'instance à la vitesse vit vers la position x,y.
rebondit contre les instances solides comme l'action
correspondante.
rebondit sur toutes les instances (solides ou non).
déplace l'instance dans la direction dir jusqu'à ce
qu'il y ait un contact. L'instance est replacée alors à
sa position juste avant le contact. Tant qu'il y a
contact, l'instance est déplacée en arrière.

distance_to_point(x,y) retourne la distance de la zone de rebond de

l'instance en cours en position x,y.
distance_to_object(obj) retourne la distance entre l'instance en cours et la
plus proche instance de l'objet obj.

position_empty(x,y) indique s'il n'y a rien en position x,y.

position_meeting(x,y,obj)
indique si à la position x,y, il y a une instance de
l'objet obj. Obj peut être un objet, un id ou les mots
self, other, ou all.

74
26.2 Instances

Dans le jeu, les instances sont l'armature de celui-ci. Durant le jeu, un certain nombre
d'aspects de ces instances. Vous aurez à créer et détruire des instances, à en modifier la
vitesse, l'emplacement et bien d'autres…

object_index* N° d'instance de l'objet. Ne peut être modifié.

id* l'identifiant unique de l'objet (>= 100000). Notez que dans
l'éditeur de salles, vous obtenez cet id en survolant l'instance. Ne
peut être modifié.
mask_index Index du sprite utilisé comme masque lors d'une collision. Y
écrire -1 force le masque à être identique à la variable
sprite_index.
solid Indique si l'instance est solide ou non. Modifiable en cours de jeu.
persistent indique si l'instance est persistante et réapparaît quand on rentre à
nouveau dans la même salle.

Il y a un problème avec les instances. Il n'est pas facile d'identifier une instance en particulier
car elles n'ont pas de nom. Quand il n'y a qu'une seule instance d'un objet dans la salle, vous
pouvez utiliser le nom de l'objet, sinon, vous devez passer par son id. Il n'y a qu'un seul id par
instance. Pour manipuler les instances, vous pouvez passer par le with (voir chapitre 24.6).
Bien sur, il existe des fonctions et des variables qui vous aident pour repérer une instance :

instance_count* Nombre d'instances présentes dans la salle.

instance_id[0..n-1]* L'id d'une instance particulière. Ici, n est le nombre
d'instances.

Laissez-moi vous donner un exemple. Imaginez que chaque composant de votre jeu possède
des points de vie et que vous voulez repérer celui qui en a le plus. Vous pouvez alors écrire le
code suivant :

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

A la fin de la boucle, maxid contiendra l'identifiant du composant qui à le plus de points de

vie. Ps : ne pas détruire les instances lors d'une telle boucle car elles sont automatiquement
enlevées du tableau, ce qui fausserait la recherche.

75
Voici diverses fonctions qui s'occupent des instances :

instance_find(obj,n) Retourne l'id numéro n+1. La numérotation

commence à 0. Donc si n=0, on vise en réalité le
1er. Si aucune instance n'est présente, l'objet
spécial noone est retourné.
instance_exists(obj) indique si au moins une instance de l'objet existe.
Obj peut être un objet, un id ou l'objet spécial all.
instance_number(obj) compte le nombre d'instance de l'objet. Obj peut
être un objet ou all.
instance_position(x,y,obj) retourne l'id de l'instance de l'objet obj en
position x,y. Obj peut être un objet ou all. Si rien
n'existe, noone est retourné.
instance_nearest(x,y,obj) retourne l'id de l'instance de l'objet obj la plus
proche de la position x,y. Obj peut être un objet
ou all.
instance_furthest(x,y,obj) retourne l'id de l'instance de l'objet obj la plus
lointaine de la position x,y. Obj peut être un
objet ou all.
instance_place(x,y,obj) retourne l'id de l'instance de l'objet obj qui rentre
en collision avec l'instance en cours si cette
dernière est placée en x,y. Obj peut être un objet
ou all. Si rien n'existe, noone est retourné.

Les fonctions suivantes s'occupent de créer ou de détruire des instances :

instance_create(x,y,obj) crée une instance de l'objet obj aux

instance_copy(quelévént)
instance_destroy()
instance_change(obj,évn)
position_destroy(x,y)
position_change(x,y,obj,évn)
coordonnées x,y. La fonction retourne l'id de
la nouvelle instance.
crée une copie de l'instance en cours.
Quelévént indique quel événement doit être
exécuté lors de la copie. La fonction retourne
l'id de la nouvelle instance
détruit l'instance en cours.
change l'instance en cours en objet obj.
L'argument évn indique si les événements
Destroy et Creation sont activés.
détruit toutes les instances dont les sprites
sont sur la position x,y.
change toutes les instances en position x,y en
objet obj. L'argument évn indique si les
événements Destroy et Creation sont activés.

76
26.3 Le Temps

Les bons jeux réclament une gestion soigneuse du temps et de tout ce qui survient aux objets.
Fort heureusement, Game Maker s'en occupe fort bien pour vous. Il vous garantit que tout
survient selon un chronomètre régulier et constant. Cette cadence temporelle est définie pour
chaque salle quand vous la créez (cf éditeur de salle). Vous pouvez changer cette cadence
avec la variable room_speed. Il est possible de modifier tout doucement cette variable afin
d'augmenter la vitesse du jeu d'un facteur très petit (comme 0.001) à chaque cycle. Si votre
machine est trop lente, vous risquez d'avoir des "sauts de temps". La variable fps (frames par
seconde) est synchronisée avec les moniteurs (frame = image). Enfin, la variable
current_time donne le nombre de millisecondes écoulées depuis le démarrage de
l'ordinateur.
Suivent une série de varaibles disponibles (dont seule la 1ère est modifiable) :

room_speed vitesse du jeu en cycles par seconde

fps* nombre de frames/images dessinées par seconde
current_time* nombre de millisecondes écoulées depuis le boot
current_year* année en cours
current_month* mois en cours
current_day* jour en cours
current_weekday* jour de la semaine en cours (1=dimanche, 7=samedi)
current_hour* heure en cours
current_minute* minute en cours
current_second* seconde en cours

Parfois, vous aurez besoin de stopper le jeu pour un court instant :

sleep(millisec) gèle le jeu durant millisec millisecondes

Enfin, comme vous le savez, chaque instance possède 8 chronomètres, 8 alarmes différentes.
Pour changer la valeur de ces 8 chronomètres :

alarm[0..7] Value du chronomètre. Cette valeur n'est opérationnelle que si

le chronomètre contient des actions !

77
26.4 Salles et Scores

Les jeux fonctionnent dans des salles. Chaque salle a un index qui est indiqué par le nom de la
salle. La salle en cours est stocke dans la variable room. Vous n'êtes pas assuré que les salles
soient numérotées par ordre croissant et consécutif. Donc ne jamais soustraire ou additionner
un nombre d'une variable de salle.
Voici un code usuel pour une salle :

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

Les fonctions et variables suivantes existent pour la gestion des salles :

room index de la salle en cours

room_first* index de la 1ère salle du jeu
room_last* index de la dernière salle du jeu
room_goto(nsalle) aller en salle nsalle
room_goto_previous() aller à la salle précédente
room_goto_next() aller à la salle suivante
room_restart() recommencer la salle en
room_previous(ns) retourne l'index de la salle précédant la salle ns mais n'y
va pas (retourne -1 s'il n'y en a aucune)
room_next(ns) retourne l'index de la salle suivant la salle ns mais n'y va
pas (retourne -1 s'il n'y en a aucune)
game_end() fin du jeu
game_restart() recommence tout le jeu

Les salles ont un certain nombre de propriétés complémentaires :

room_width* largeur en pixels de la salle

room_height* hauteur en pixel de la salle
room_caption titre de la salle (affiché dans le titre de la fenêtre)
room_persistent indique si la salle est persistante.

Beaucoup de jeux proposent de sauvegarder et de recharger une partie. Game Maker le

propose automatiquement par les touches <F5> pour enregistrer et <F6> pour charger. Vous
pouvez le faire par programmation. Ceci doit être placé à la fin du cycle en cours

game_save(nom) sauve le jeu en lui donnant un nom

game_load(nom) recharge la partie enregistrée sou le nom donné

Un autre aspect important de beaucoup de jeux est le score final et le nombre de vies. Game
Maker conserve le score dans la variable globale score et le nombre de vie dans la variable
globale lives. Ces 2 variables sont normalement affichées dans le titre de la fenêtre du jeu.

78
Vous pouvez changer le score en changeant la valeur de la variable. Idem pour le nombre de
vie. Si lives <= 0 alors l'événement no-more-lives est exécuté pour toutes les
instances. Si vous ne voulez pas que score et lives s'affichent, mettez la variable
show_score à faux (false). Ceci est modifiable dans les options de fenêtre. Pour les jeux
compliqués, il est mieux d'afficher son score par soi-même.

score score en cours

lives nombre de vie
show_score indique si l'affichage de score te live se fait ou non

Il existe aussi un mécanisme interne pour gérer les listes de score. Ce mécanisme peut gérer
ainsi 10 scores. Pour plus d'information, voir au chapitre 30.

26.5 Gestion des Evénements

Comme vous le savez, Game Maker est complètement piloté par des événements. Toutes les
actions surviennent comme résultat d'événements. Il y a beaucoup d'événements différents.
Les événements Creation et Destroy surviennent lorsqu'une instance est créée ou détruite. A
chaque cycle, le système passe la main aux événements Alarm. Puis il s'occupe des
événements du clavier et de la souris (Keyboard, Mouse). Ensuite, la gestion des collisions
survient. Enfin, l'événement Draw (dessin) s'active pour l'instance (notez que quand il y a
plusieurs vues, affichages, l'événement Draw est activé à chaque fois). Vous pouvez
appliquer un événement à l'instance en cours à partir d'un script. Les fonctions suivantes
existent :

event_perform(type,numcode)
Exécute l'événement type à l'instance en cours.
Les types autorisés sont :
 ev_create création
 ev_destroy destruction
 ev_step cycle
 ev_alarm alarme
 ev_keyboard clavier
 ev_mouse souris
 ev_collision collision
 ev_other autres
 ev_draw dessin

Quand il y a des événements multiples d'un type donné, numcode peut être spécifié
pour indiquer l'événement précis. Pour les alarmes, il faut indiquer le n° par un chiffre
de 0 à 7.

Pour le clavier, utilisez le code clavier. Pour la souris, utilisez les codes suivants :
ev_left_button bouton gauche
ev_right_button bouton droit
ev_middle_button bouton milieu
ev_no_button aucun bouton

79
 Pour la collision, vous donnez l'index de l'autre objet. Enfin, pour les autres
événements, vous pouvez utiliser les constantes suivantes :
ev_outside sortie
ev_boundary limite, frontière
ev_game_start début de jeu
ev_game_end fin de jeu
ev_room_start au démarrage de la salle
ev_room_end fin de salle
ev_no_more_lives plus aucune vie
ev_animation_end fin d'animation

Pour l'événement Step (cycle), utilisez les constantes suivantes :

ev_step_normal normal
ev_step_begin début de cycle
ev_step_end fin de cycle

event_perform_object(obj,type,numcode)
Cette fonction fonctionne de la même façon que la précédente, excepté que
cette fois, vous pouvez déclencher un événement dans un autre objet. Notez
cependant que les actions de ces événements s'appliquent à l'instance en cours
et non à l'objet obj !
event_user(numb)
Dans les autres événements, vous pouvez aussi vous définir 8 événements
utilisateurs de 0 à 7. Ces événements ne sont activés par par programmation de
votre part.
event_inherited()
Exécute l'événement hérité. Ne fonctionne que si l'instance a un objet parent.

Vous pouvez obtenir des informations sur l'événement en cours en train d'être exécuté en
utilisant les variables suivantes qui sont en lecture seule :
event_type* type de l'événement en cours
event_number* nombre d'événements qui commencent à s'exécuter
event_object* le n° d'index de l'événement en cours
event_action* le n° d'index de l'action qui s'exécute (0 pour la 1ère action, etc. )

26.6 Variables et Fonctions diverses

D'autres fonctions peuvent être utiles dans diverses circonstances :

object_name(index) retourne le nom de l'objet n° index

room_name(index)
sprite_name(index)
background_name(index)
sound_name(index)
script_name(index)
retourne le nom de la salle n° index
retourne le nom du sprite n° index
le nom du fond, de l'arrière plan
le nom du son
le nom du script

Puis 2 variables concernant les erreurs :

error_occurred indique quelle erreur est arrivée

error_last dernier message d'erreur rencontré

80
Chap. 27 Les Interactions Utilisateur (Souris et Clavier)
Il n'y a pas de jeu sans interaction avec l'utilisateur. La voie classique dans Game Maker est
d'associer des actions avec les événements Clavier ou Souris (Keyboard, Mouse). Mais vous
aurez parfois besoin de plus de contrôle. Avec un petit programme, vous pourrez tester
quelles sont les touches du clavier qui ont été activées, idem pour la position de la souris et du
bouton appuyé. En général, ces tests sont vérifiés dans l'événement Cycle (Step) et vous y
programmez les actions qui s'y rapportent. Les variables et les fonctions suivantes existent :

mouse_x* Coordonnée X de la souris. Ne peut être changée.

mouse_y* Coordonnée Y de la souris. Ne peut être changée.
mouse_button Bouton enfoncé. Valeurs disponibles : mb_none, mb_left,
mb_middle, ou mb_right (aucun, gauche, milieu, droite)
keyboard_lastkey Code clavier de la dernière touche enfoncée. Voir plus loin
pour les codes clavier.
keyboard_key Code clavier de la touche actuellement enfoncée (voir plus
loin; 0 si aucun touche n'est enfoncée).
keyboard_lastchar Dernier caractère enfoncé.
keyboard_string Chaîne qui contient les 80 (maxi) derniers caractères
utilisés. Cette chaîne ne contient que les caractères
imprimables.

Pour vérifier quel touche ou bouton a été utilisé, vous pouvez utiliser les fonctions suivantes.
Elles sont utiles quand plusieurs touches ont été enfoncées simultanément.

keyboard_check(code) indique si la touche a été enfoncée.

keyboard_check_direct(code) indique si la touche a été enfoncée, en utilisant
directement les appels systèmes. Le résultat est
indépendant de l'application en cours. Vous pouvez
utiliser les codes claviers vk_lshift, vk_lcontrol,
vk_lalt, vk_rshift, vk_rcontrol and vk_ralt pour
vérifier si les touches Shift, Ctrl et Alt ont été
utilisées (ne fonctionne pas sous Windows 95 !).
mouse_check_button(numbtn) Indique si le bouton numbtn a été enfoncé (valeurs
disponibles : mb_none, mb_left, mb_middle, ou
mb_right).

Les constantes suivantes désignent le clavier virtuel :

vk_nokey Code indiquant qu'aucune touche n'a été enfoncée

vk_anykey Code indiquant qu'une touche a été enfoncée
vk_left flèche gauche
vk_right flèche droite
vk_up flèche haut
vk_down flèche bas
vk_enter entrée
vk_escape échap
vk_space espace
vk_shift shift
vk_control contrôle (ctrl)

81
 vk_alt alt
vk_backspace retour arrière
vk_tab tabulation
vk_home home (flèche diag haut gauche)
vk_end fin
vk_delete suppr
vk_insert inser
vk_pageup page haut
vk_pagedown page bas
vk_pause pause/break
vk_printscreen impr écran
vk_f1 … vk_f12 fonction de F1 à F12
vk_numpad0 … vk_numpad9
chiffre du pavé numérique
vk_multiply * du pavé numérique
vk_divide / du pavé numérique
vk_add + du pavé numérique
vk_subtract - du pavé numérique
vk_decimal point/virgule du pavé numérique

Pour les touches des lettres, utilisez par exemple ord('A'). (en majuscule). Les constantes
suivantes ne peuvent être utilisées que par la fonction keyboard_check_direct :

vk_lshift shift gauche

vk_lcontrol ctrl gauche
vk_lalt alt gauche
vk_rshift shift droit
vk_rcontrol ctrl droit
vk_ralt alt droit

Par exemple, imaginez que vous ayez à diriger un objet avec les flèches. Dans ce cas, utilisez
le script suivant dans l'événement Step de cet 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;
}

Naturellement, il est plus simple de programmer la même chose dans les événements du
clavier.

Comme vous le savez déjà, dans les options du jeu, vous pouvez indiquer quels événements
du clavier ou de la souris peuvent être continus, ou s'il faut que l'utilisateur ré-appuie à chaque
fois. Il est possible de changer ces paramètres avec les variables suivantes :

keyboard_continuous Les événements clavier sont continus (1) ou non (0).

mouse_continuous Les événements souris sont continus (1) ou non (0).

82
Il y a 3 fonctions relatives aux interactions :

keyboard_clear(code) efface l'état de la touche. Ne génère plus d'événement

clavier jusqu'à une répétition ou un ré appuis.
mouse_clear(bouton) efface l'été du bouton de la souris. Ne génère plus
d'événement souris tant qu'on ne ré enfonce pas le bouton.
io_clear() efface tous les états clavier et souris.
io_handle() met à jour les états du clavier et de la souris.
keyboard_wait() attend que l'utilisateur appuie sur une touche du clavier.

27.1 Le Support du Joystick

Bien que la méthode utilisée ne soit pas toujours évidente, Game Maker supporte
actuellement les joysticks. Les mouvements du joystick créée les événements <NUMPAD>1
à <NUMPAD>9 comme sur le pavé numérique. Les 4 boutons génèrent les événements
claviers des lettres A, B, C et D. Comprenez que vous n'obtenez pas ces informations en
utilisant la fonction keyboard_check() parce qu'elle teste le clavier. Néanmoins, vous
avez diverses fonctions qui gèrent les 2 joysticks que Game Maker supporte. Toutes ces
fonction demandent un argument id (numéro du joystick 1 ou 2).

joystick_exists(id) Indique si le joystick (id 1 ou 2) existe.

joystick_direction(id) retourne le code clavier (vk_numpad1 à
vk_numpad9) qui correspond au
mouvement du joystick id 1 ou 2.
joystick_check_button(id,num) indique si le bouton num du joystick id est
appuyé. (num entre 1 et 4).
joystick_xpos(id) indique la position (-1 à +1) sur l'axe X du
joystick.
joystick_ypos(id) indique la position (-1 à +1) sur l'axe Y du
joystick.
joystick_zpos(id) indique la position (-1 à +1) sur l'axe Z du
joystick, s'il existe un axe Z.

83
Chap. 28 Les graphiques
Une partie importante du jeu concerne les graphiques. Game Maker prend normalement soin
de ceux-ci au mieux dans des jeux simples. Mais parfois, vous voudrez mieux contrôler le jeu.
Pour ce faire, vous avez des actions mais aussi des fonctions et autres variables. Ce chapitre
décrit toutes les variables et fonctions disponibles et vous donne des informations sur ce qui
se passe réellement.

28.1 Fenêtre et Curseur

Par défaut, le jeu fonctionne dans une fenêtre centrée. Le joueur peut passer en plein écran par
la touche F4 (sauf si elle est neutralisée). Vous pouvez par programmation faire la même
chose avec la variable :

full_screen Cette variable est vraie (True) quand le jeu est en plein
écran. Vous pouvez affecter les valeurs True ou False à
cette variable.

Notez qu'en mode plein écran (Full Screen), le titre et le score sont affichés à l'écran (voir les
options du jeu). En plein écran, l'image est soit centrée ou change d'échelle. Vous pouvez
utiliser les variables suivantes :

scale_window Cette variable indique le % d'échelle en mode Fenêtre.

100 vaut pour 100% et signifie échelle réelle.
scale_full Cette variable indique le % d'échelle en mode Plein Ecran.
100 vaut pour 100% et signifie échelle réelle. 0 (zéro)
indique échelle maximum.

La mise à l'échelle (autre que 100%) peut ralentir sérieusement le jeu sur des machines lentes
(microprocesseur ou carte vidéo). Par défaut, chaque jeu fonctionne avec un curseur visible.
Dans un bon nombre de jeux, vous n'aurez pas besoin de curseur. Pour l'enlever, utilisez kla
variable :

show_cursor Si la variable est à False, le curseur est invisible dans la zone de

jeu, en dehors, il reste.

Remarquez qu'il est très facile de créer son propre curseur. Créez un objet avec une
profondeur négative et avec l'événement Cycle (Step), faites-lui suive la souris.

Pour obtenir la résolution du moniteur, vous pouvez utiliser ces 2 variables qui sont en lecture
seule :

monitor_width Largeur du moniteur en pixels.

monitor_height Hauteur du moniteur en pixels.

84
28.2 Sprites et Images

Chaque objet a un sprite qui lui est associé. Il s'agit soit d'une simple image ou un ensemble
d'images. Pour chaque instance de l'objet, le programme dessine l'image correspondante à
l'écran avec l'origine du sprite à la position (x, y) de l'instance. Quand il y a des images
multiples, le programme affichera en cycle les images afin d'obtenir une animation. Il existe
un certain nombre de variables qui affectent la façon dont sera affiché l'image. Cela peut être
utilisé pour obtenir des effets. Chaque instance possède les variables suivantes :

visible Si la variable est True (1, vrai), l'image est dessinée sinon elle
n'est pas dessinée. Les instances invisibles restent actives et
sont sujettes aux collisions mais vous ne les voyez pas. Jouer
sur la visibilité est pratique pour contrôler certains objets
comme des interrupteurs cachés ou faire que des objets non
solides soient aussi sujets aux collisions.
sprite_index C'est l'index du sprite courant de l'instance. Vous pouvez le
changer afin de donner à l'instance une apparence différente.
Comme valeur, vous pouvez utiliser le nom du sprite
concerné. Changer de sprite ne change pas l'index de la sous
image en cours.
sprite_width* Indique la largeur du sprite. Cette valeur ne peut être changée
mais vous pouvez l'utiliser.
sprite_height* Indique la hauteur du sprite. Cette valeur ne peut être changée
mais vous pouvez l'utiliser.
sprite_xoffset* Indique le décalage horizontal du sprite (cf. propriétés du
sprite). Lecture seule.
sprite_yoffset* Indique le décalage verticale du sprite (cf. propriétés du
sprite). Lecture seule.
image_number* Nombre de sous images du sprite en cours. Lecture seule.
image_index Quand un sprite contient plusieurs images, le programme
cycle dessus. Cette variable indique la sous image qui
s'affiche (la numérotation démarre à 0). Vous pouvez changer
le n° de sous image en cours. Le programme continuera de
cycle sur les sous images à partir de l'index indiqué.
image_single Parfois, vous voudrez qu'une sous image particulière soit
visible sans que le programme cycle sur les autres images (0
pour la 1ère sous image). Cela est pratique pour un objet ayant
diverses apparences. Par exemple, un objet a 4 apparences
pour les 4 directions (de 0 à 3; N, S, E et O). Par
programmation, vous pilotez l'image qui doit s'afficher en
fonction du mouvement en cours. En général, c'est dans
l'événement Step (Cycle) que le script s'écrit.
image_speed La vitesse avec laquelle nous cyclons sur les sous images.
Une valeur de 1 indique que nous passons à l'image suivante à
chaque cycle du jeu. Une valeur plus petite ralentit l'affichage
en laissant s'afficher la même image sur n cycles. Un plus
grande valeur saute quelques sous images ci et là afin de
rendre l'animation plus rapide.
depth Normalement, les sous images sont affichées dans l'ordre dans
lequel les instances ont été créées. Vous pouvez modifier cet

85
 ordre. La valeur par défaut est 0. Plus la valeur est grande,
plus l'instance est lointaine, au fond. Vous pouvez utiliser des
valeurs négatives. Les instances avec une valeur élevée sont
affichées derrière, sous les instances avec une valeur faible
(ou négative).
image_scale Un facteur d'échelle pour agrandir ou rétrécir les images. Une
valeur de 1 n'indique aucune modification d'échelle (100%).
Changer cette valeur influe sur les tests de collisions.
Attention, la modification d'échelle agit sur la vitesse du jeu.
Modifier en cours de route l'échelle d'un objet permet de
simuler un effet de profondeur de 3D.
image_alpha La transparence (alpha) rend + ou – translucide un objet. 1
signifie 100% d'opacité et 0 signifie complètement
transparent. Utilisez avec soin cette variable car elle peut
sérieusement ralentir le jeu.
bbox_left* Côté gauche du rectangle encadrant le sprite, l'image de
l'instance (ce rectangle permet la gestion des collisions).
bbox_right* Côté droite du rectangle.
bbox_top* Côté haut du rectangle.
bbox_bottom* Côté bas du rectangle..

Les sprites consomment beaucoup de mémoire. Pour les dessiner de façon suffisamment
rapide, il faut les stocker dans la mémoire vidéo. Comme ce le fut indiqué dans le chapitre 13,
vous pouvez indiquer quels seront les sprites qui seront chargés en mémoire vidéo. Vous
pouvez aussi charger des sprites à la demande. Ces sprites seront enlevés de la mémoire à la
fin du niveau. Vous pouvez intervenir partiellement sur le processus de gestion des sprites par
les fonctions suivantes :

sprite_discard(num) Retire le sprite num de la mémoire vidéo. Si le sprite

sprite_restore(num)
discard_all()
possède la propriété load-on-use à vrai, il est
complètement enlevé. Sinon, une copie est maintenue en
mémoire normale dans l'attente éventuelle d'un
rechargement en mémoire vidéo.
Replace le sprite num en mémoire vidéo. Normalement,
le chargement se fait automatiquement quand le sprite
est utilisé. Mais dans le cas d'un gros sprite intervenant
en milieu de niveau, il est judicieux de le charger en tout
début de partie afin de ne pas ralentir le cours du jeu
quand il faudra le charger en mémoire vidéo.
Retire tous les sprites, les arrière-plans et les sons qui
sont en mode load-on-use.

Quand un jeu utilise un grand nombre de gros sprites, le jeu grossit en taille mémoire et le
charment est fortement ralenti. Il est possible de moduler ce chargement lent. Il est possible
d'aller chercher les images des sprites sur le disque dur en chargeant des fichiers bitmaps
(.bmp, .jpg, ou .gif, seuls formats reconnus) en cours de jeu.

86
Il y a 3 routines pour ce faire :

sprite_add(nomfic,nbrimg,précis,transparent,mémvidéo,chargésiut
ilisé,originex,originey)
Ajoute l'image stockée dans le fichier NomFic à la liste
des sprites utilisables. Seuls les formats bmp, jpg and gif
sont autorisés. Si l'image est un bmp ou un jpg, elle peut
est une bande d'images l'une à côté de l'autre. Utilisez
NbrImg pour indiquer le nombre d'images de la bande
(1 pour une simple image). Pour les gifs animés, cet
argument n'est pas utilisé. L'argument Précis indique le
type de collision (mode précis ou non). Transparent
indique si l'image est partiellement transparente ou non.
MémVidéo indique si le sprite doit être stocké en
mémoire vidéo et ChargéSiUtilisé si le sprite est chargé
si et seulement si on en a besoin. OrigineX et OrigineY
indique la position de l'origine du sprite. La fonction
retourne l'index du nouveau sprite. En cas d'erreur, la
fonction retourne -1.
sprite_replace(index,nomfic,nbrimg,précis,transparent,mémvidéo,
chargésiutilisé,originex,originey)
Même fonction que la précédente mis à part qu'on
indique l'index dans lequel on charge le sprite. La
fonction indique si le chargement a pu se faire
(true/false).
sprite_delete(index) Détruit le sprite de la mémoire, libérant ainsi la
mémoire. Il ne peut plus être restauré.

ATTENTION : Quand vous sauvegarder le jeu durant la partie, les sprites ajoutés ou
remplacés ne sont PAS sauvegardés. Ainsi si vous rechargez un jeu sauvegardé, ils n'y seront
pas. Faites aussi attention aux copyrights des fichiers gif, bmp ou jpg. Du coup, il est mieux
de ne pas les utiliser.

87
28.3 Arrière-plans

Chaque salle peut avoir jusqu'à 8 arrière-plans. Il existe aussi une couleur d'arrière-plan. Vous
pouvez modifier les caractéristiques de ces arrière-plans à l'aide des variables qui suivent (les
nombres de 0 à 7 indiquent les différents arrière-plans) :

background_color Couleur d'arrière-plan de la salle.

background_showcolor La fenêtre de sa salle est-elle effacée avec la
couleur d'arrière-plan ?
background_visible[0..7] L'image d'arrière-plan est-elle affichée ?
background_foreground[0..7] L'arrière-plan est-il un premier plan ?.
background_index[0..7] N° d'index de l'image de l'arrière-plan.
background_x[0..7] Position X de l'arrière-plan.
background_y[0…7] Position Y.
background_width[0…7]* Largeur de l'arrière-plan.
background_height[0…7]* Hauteur.
background_htiled[0..7] Répétition horizontale d'images sous forme de
tuiles ?
background_vtiled[0..7] Répétition verticale de tuiles ?
background_hspeed[0..7] Vitesse horizontale du scrolling
(En pixel par cycle).
background_vspeed[0..7] Vitesse verticale du scrolling
(En pixel par cycle).
background_alpha[0..7] Valeur de la transparence (alpha) de l'arrière-
plan. Une valeur de 1 signifie de l'arrière-plan
est complètement opaque. Une valeur de 0
signifie qu'il est totalement transparent (et donc
invisible). Attention, la transparence ralentit
l'exécution du jeu.

Les images d'arrière-plan consomment beaucoup de mémoire. Pour en accélérer la vitesse,

n'oubliez pas de les stocker en mémoire vidéo si possible. Vous pouvez ainsi indiquer quel
fond sera mémorisé pour accélérer le jeu. Vous pouvez contrôler le tout par les fonctions
suivantes :

background_discard(num) Libère la mémoire vidéo utilisée par l'arrière-plan n°

background_restore(num)
discard_all()
num. Si l'arrière-plan a la propriété load-on-use
mise à vrai, il est complètement retiré de la mémoire.
Sinon, une copy est laissée dans la mémoire normale
pour restaurer l'arrière-plan par la suite.
Remet, restaure l'arrière-plan dans la mémoire vidéo.
C'est ce qui arrive normalement quand l'arrière-plan
est demandé. Mais vous pouvez contrôler cet état de
fait à volonté pour forcer l'arrière-plan à volonté.
Décharge tous les sprites, les sons et les arrière-plans
dont la propriété load-on-use est à vrai.

88
Quand un jeu utilise beaucoup d'arrière-plans, le jeu devient gros (en octets) et lent en
chargement. Implicitement, ces images sont chargées en mémoire mais rien ne vous empêche
d'aller les chercher sur le disque dur sous la forme de fichiers .bmp ou .jpg. (aucun autre
format n'étant autorisé). Cela vous permet aussi d'offrir une variété d'images que le joueur
sélectionnera. De plus, une image jpg consomme moins de place. Voici les fonctions qui
s'occupent de ceci :

background_add(nomfichier,transparent,mémvidéo,chargésiutil)
Ajoute l'image stockée dans le fichier NomFichier à la liste des arrière-plans. Seules
les images bmp et jpg peuvent être. Transparent indique si l'image est partiellement
transparente ou non. MémVidéo indique si l'image est stockée en mémoire vidéo.
ChargéSiUtil indique la propriété loadonuse doit être mise à vrai (ne charger qui si on
utilise l'image). La fonction retourne l'index du nouvel arrière-plan que vous pouvez
alors dessiner à l'écran ou l'affecter à la variable background_index[0] pour le rendre
visible dans la salle en cours. En cas d'erreur, la valeur -1 est retournée.

background_replace(index,nomfic,transp,mémvidéo,chargésiutil)
Même fonction que la précédente mais remplace l'image de l'arrière-plan index par
une nouvelle image chargée. La fonction indique vrai ou faux selon la réussite de
l'action. Si l'arrière-plan était actuellement visible, son image est donc modifiée.

background_delete(index)
Détruit l'arrière-plan index de la mémoire et libère la place qu'il prenait.

ATTENTION : Quand vous sauvez le jeu durant la partie, les arrière-plans ajoutés ou
modifier ne sont PAS stockés avec le jeu. Ainsi si vous rechargez un jeu par la suite, il risque
d'y avoir des étonnements ! Au fait, faites attention aux copyrights liés aux images dans vous
jeux commerciaux. Il est mieux de ne pas tenter le diable…

89
28.4 Tuiles

Comme vous le savez, vous pouvez ajouter des tuiles à vos pièces. Une tuile est une partie
d'un fond (en tant que ressource). Les tuiles ne sont que des images visibles. Elles ne
réagissent à aux événements et ne gèrent les collisions. Comme résultat, les tuiles sont plus
rapides que les objets. Donc, tout ce qui n'est pas sujet à une collision ou un événement
devrait être une tuile. Il est usuel, de mixer les tuiles et les objets : à un objet peut
correspondre plusieurs tuiles qui le visualisent.

Vous pouvez contrôler les tuiles. Vous pouvez en ajouter lors de la création de la salle mais
aussi lors du déroulement du jeu. Vous pouvez changer leurs positions et éventuellement leurs
échelles et même les rendre partiellement transparente. Une tuile a les propriétés suivantes :

background. La ressource arrière-plan sur laquelle la tuile est posée.

left, top, width, height. La localisation sur l'arrière-plan.
x,y. La position du coin supérieur gauche de la tuile dans la
salle.
depth. La profondeur de la tuile. Avec une profondeur de
1.000.000 (un million), la tuile s'enfonce au plus lointain et
avec une profondeur de –1.000.000, la tuile se place au
premier plan. Vous pouvez choisir la profondeur que vous
voulez entre ces 2 valeurs.
visible. La visibilité de la tuile.
xscale, yscale. L'échelle de la tuile en X et Y (1=100%, valeur par défaut).
alpha. La transparence de la tuile, 1 = opaque et 0 = transparent
(invisible). Faites attention, la transparence consomme du
temps machine et peut même poser des problèmes sur
certaines cartes vidéo.

Pour changer les propriétés d'une tuile, il faut connaître son ID (identifiant). Quand vous
placez les tuiles dans une salle, cet ID s'affiche dans la barre d'information. Il existe aussi une
fonction qui cherche l'ID d'une tuile situé à une certaine position.

Les fonctions suivantes existent pour gérer les tuiles :

tile_add(fond,gauche,droite,larg,haut,x,y,profondeur)
Ajoute une nouvelle tuile dans la salle ayant ces propriétés
(voir juste avant). La fonction retourne l'ID qui pourra être
utilisé par la suite.
tile_delete(id) Détruit la tuile d'identifiant ID.
tile_find(x,y,fond) Retourne l'ID de la tuile en position x,y. S'il n'y a pas de
tuile, la fonction retourne -1. Quand la variable foreground
est à true (vrai), seules les tuiles de profondeur <0 sont
retournées. Sinon, seules les tuiles de profondeur >= 0 sont
retournées. Quand divers arrière-plans ou premiers plans
existent à cette position, la 1ère tuile trouvée est retournée.
tile_delete_at(x,y,fond) Détruit les tuiles situées en position x,y. Quand la variable
foreground est à true (vrai), seules les tuiles de profondeur
<0 sont détruites. Sinon, seules les tuiles de profondeur >=
0 sont détruites.
tile_exists(id) Indique (true/false) si l'ID (d'une tuile) existe.

90
tile_get_x(id) Retourne la position x de la tuile ID.
tile_get_y(id) Retourne la position y de la tuile ID.

tile_get_left(id) Position gauche de la tuile.

tile_get_top(id) Position haute de la tuile.
tile_get_width(id) Largeur de la tuile.
tile_get_height(id) Hauteur de la tuile.
tile_get_depth(id) Profondeur
tile_get_visible(id) La tuile est-elle visible ?.
tile_get_xscale(id) Echelle en x de la tuile.
tile_get_yscale(id) Echelle en y de la tuile..
tile_get_background(id) Retourne l'arrière-plan de la tuile.
tile_get_alpha(id) Transparence de la tuile.

tile_set_position(id,x,y) Place la tuile ID à la position x,y.

tile_set_region(id,gauche,droite,larg,haut)
tile_set_background(id,fond)
tile_set_visible(id,visible)
tile_set_depth(id,depth)
tile_set_scale(id,xscale,yscale)
tile_set_alpha(id,alpha)
Change la région d'une tuile.
Change le fond (arrière-plan) de la tuile.
Change la visibilité d'une tuile.
Change la profondeur.
Change l'échelle.
Change la transparence.

91
28.5 Fonctions de Dessin

Il est possible de donner aux objets un aspect différent de leurs images. Il existe pour ce faire
une collection complète de fonctions pour dessiner des formes et aussi pour afficher du texte.
Vous pouvez les utiliser dans l'événement Draw (Dessin). Ces fonctions n'existent en script
(voir Section 28.8). Veuillez réaliser que seule la carte vidéo (graphics hardware) accélère
l'affichage et que dessiner avec des fonctions est relativement lent. Aussi Game Maker est
optimisé pour optimiser l'affichage d'images. Aussi évitez d'utiliser les routines graphiques et
préférez leurs des bitmaps. Réalisez aussi que la collision se gère avec des sprites (et leurs
masques) et non par ce que vous dessinez.

Les fonctions de dessin suivantes sont disponibles :

draw_sprite(n,img,x,y)
Dessine la sous image img (-1 = en cours) du sprite d'index n
dont l'origine est à la position x,y.
draw_sprite_scaled(n,img,x,y,éch)
Dessine la sous image img du sprite n à la position x,y avec le
facteur d'échelle éch.
draw_sprite_stretched(n,img,x,y,larg,haut)
Idem mais avec la largeur larg et la hauteur haut.
draw_sprite_transparent(n,img,x,y,éch,alpha)
Idem mais avec le facteur éch et la transparence alpha. 0 rend le
sprite complètement transparent et 1 opaque. Cela donne de
beaux effets mais ralentit sérieusement la machine. Aussi
utilisez cette fonction avec soin.
draw_background(n,x,y)
Dessin le fond d'index n à la position x,y.
draw_background_scaled(n,x,y,éch)
Dessine le fond à l'échelle éch.
draw_background_stretched(n,x,y,larg,haut)
Dessine le fond avec la largeur larg et la hauteur haut.
draw_background_transparent(n,x,y,éch,alpha)
Fond à l'échelle éch avec la transparence alpha (0..1). Lent !
draw_background_tiled(n,x,y)
Le fond est répété afin de remplir toute la pièce (papier-paint,
mosaïque).

92
Les fonctions suivantes dessinent des formes basiques. Elles utilisent un certain nombre de
propriétés en particulier les couleurs de crayon et du pinceau (brosse).

draw_pixel(x,y) Dessine un pixel à la position x,y dans la

couleur du pinceau.
draw_getpixel(x,y) Retourne la couleur du pixel en x,y.
draw_fill(x,y) Remplie la zone en x,y avec la couleur du
pinceau.
draw_line(x1,y1,x2,y2) Dessine une ligne de x1,y1 à x2,y2.
draw_circle(x,y,r) Dessine un cercle x,y de rayon r.
draw_ellipse(x1,y1,x2,y2) Dessine une ellipse.
draw_rectangle(x1,y1,x2,y2) Dessine un rectangle.
draw_roundrect(x1,y1,x2,y2) Dessine un rectangle aux coins arrondis.
draw_triangle(x1,y1,x2,y2,x3,y3) Dessine un triangle.
draw_arc(x1,y1,x2,y2,x3,y3,x4,y4) Dessine l'arc d'une ellipse.
draw_chord(x1,y1,x2,y2,x3,y3,x4,y4) Dessine la corde d'une ellipse.
draw_pie(x1,y1,x2,y2,x3,y3,x4,y4) Dessine le secteur d'une ellipse.
draw_button(x1,y1,x2,y2,relief) Dessine un bouton.
Relief : 1 = position haute; 0 = enfoncé.
draw_text(x,y,string) Dessine un texte en x,y.
draw_polygon_begin() Commence la description d'un polygone.
draw_polygon_vertex(x,y) Ajoute un segment au polygone.
draw_polygon_end() Fin de description et dessine le polygone.

Vous pouvez changer un bon nombre de caractéristiques comme la couleur des traits, des
lignes (crayon/pen), du remplissage (pinceau/brush) et d'autres encore. L'effet de ces variables
est global. Si vous changez par exemple la couleur de remplissage pour un objet, les autres
qui seront créés par la suite auront la même couleur de remplissage. Vous pouvez utilisez ces
variables dans divers événements. N'hésitez pas à initialiser ces variables au démarrage du
jeu.

brush_color Couleur utilisée pour remplir les formes fermées.

Une série de couleurs prédéfinies existe :

c_aqua Bleu aquatique
c_black Noir
c_blue Bleu
c_dkgray Gris foncé
c_fuchsia Fuchsia
c_gray Gris neutre
c_green Vert
c_lime Tilleul
c_ltgray Gris clair
c_maroon Marron
c_navy Cyan, bleu ciel
c_olive Olive
c_purple Violet
c_red Rouge
c_silver Argent
c_teal
c_white Blanc
93
 c_yellow Jaune

D'autres couleurs peuvent être créées avec la fonction make_color(rouge, vert,

bleu), avec rouge, vert et bleu qui sont des valeurs entre 0 et 255 (aucun à plein).

brush_style Style du pinceau, hachurage :

bs_hollow creux
bs_solid plein
bs_bdiagonal diagonale descendante
bs_fdiagonal diagonale montante
bs_cross quadrillage (+)
bs_diagcross croisillon (x)
bs_horizontal horizontal
bs_vertical vertical

pen_color Couleur du crayon pour dessiner les traits, les contours..

pen_size Taille du crayon en pixel.
font_color Couleur de la police, du texte.
font_size Taille, corps de la police en point.
font_name Nom de la police (ex: Arial).
font_style Style de la police. Les constantes suivantes sont disponibles :
fs_normal normal
fs_bold gras
fs_italic italique
fs_bolditalic gras-italique
font_angle Angle de rotation de la police (0-360 degrés). Par exemple, un texte
vertical est à 90°.
font_align Alignement du texte. Constantes disponibles :
fa_left gauche
fa_center centré
fa_right droite

Quelques autres fonctions diverses existent :

string_width(txt)
Largeur en pixel de la chaîne txt avec la police en cours. Utile pour positionner
au mieux un texte..
string_height(txt)
Haute de la chaîne txt.
screen_gamma(r,v,b)
Corrige la valeur gamma. Les arguments R, V et B doivent être compris entre
-1 et +1. Par défaut, c'est 0. Quand la valeur est <0 alors vous assombrissez la
couleur désignée. Une valeur >0 éclaircit cette couleur. En général, vous
modifiez les 3 valeurs en même temps. Cette fonction ne marche qu'en mode
exclusif (exclusive) !
screen_save(nomfichier)
Sauve l'écran sous la forme d'une image bmp dans le fichier nomfichier.
Effectue donc une capture d'écran (screenshots).
screen_save_part(nomfichier,gauche,haut,droite,bas)
Sauve une partie de l'écran sous la forme d'une image bmp.

94
28.6 Vues

Comme vous le savez déjà, vous pouvez définir jusqu'à 8 vues différentes quand vous créez
des salles. Par ce biais, vous pouvez voir différentes parties d'une salle à différents endroits de
l'écran. Vous pouvez faire en sorte d'un objet soit toujours visible. Vous pouvez contrôler les
vues avec du code. Vous pouvez rendre visible ou invisible vos vues, ou les changer de place
ou de dimension ainsi que les objets à voir dedans. Ceci est important quand l'objet principal
change durant le jeu. Par exemple, vous forcez le changement du héro en fonction de ce qu'il
lui arrive. Malheureusement, çà signifie qu'il n'est plus possible que l'objet reste visible. On
peut y remédier par une seule ligne de code dans l'événement Create de tous les objets
concernés (ici, on considère qu'on s'attache à la 1ère vue) :

{
view_object[0] = object_index;
}

Les variables suivantes influencent la vue. Toutes, sauf les 2 premières, commencent la
numérotation de 0 (première vue) jusqu'à 7 (dernière vue).

view_enabled Indique si les vues sont autorisées ou non.

view_current* La vue en cours (0-7). A utiliser que dans l'événement de
dessin. Vous pouvez tester cette variable pour dessiner
certaines choses. Cette variable est en lecture seule.
view_visible[0..7] Cette vue est-elle visible à l'écran ?
view_left[0..7] Position gauche de la vue dans la salle.
view_top[0..7] Position haute de la vue.
view_width[0..7] Largeur en pixel de la vue.
view_height[0..7] Largeur en pixel de la vue
view_x[0..7] Position x de la vue en pixel
view_y[0..7] Position y de la vue en pixel.
view_hborder[0..7] Taille de la bordure horizontale autour de l'objet visible.
view_vborder[0..7] Taille de la bordure verticale (en pixel).
view_hspeed[0..7] Vitesse horizontale maximum de la vue.
view_vspeed[0..7] Vitesse horizontale maximum de la vue.
view_object[0..7] Objet dont l'instance doit rester visible dans la vue.

Notez que la taille de l'image à l'écran est basée sur les vues visibles à partir du
commencement de la salle. Si vous changez les vues durant le jeu, elles pourraient ne plus
tenir à l'écran. La taille de l'écran ne s'adapte pas automatiquement. Si vous désirez un
changement de taille écran, vous avez les variables suivantes :

screen_width Largeur de l'image sur l'écran, la zone dans laquelle nous

dessinons. S'il n'y a pas de vue, cette variable est identique à
room_width.
screen_height Hauteur de l'image sur l'écran.

95
28.7 Transitions

Comme vous le savez, quand vous passez d'une salle à une autre, vous pouvez indiquer un
effet de transition. Vous pouvez aussi paramétrer la transition pour la frame, la trame suivante
(dans une seconde, il y a n frames, n images) sans changer de salle en utilisant la variable
transition_kind. Vous avez 13 effets de transition disponibles, les mêmes que ceux
présents pour le paramétrage des salles. La valeur 0 signifie "aucune transition". Cela
s'applicera à la prochaine frame qui sera dessinée. 3 variables sont disponibles pour changer
de salle :

transition_kind Indique la prochaine transition (0-13).

transition_time Durée de la transition (en millisecondes).
transition_steps Nombre de cycles (step) de la transition.

28.8 Redessiner l'Ecran

Normalement, à chaque cycle, la salle est redessinée à l'écran. Dans certaines rares
circonstances, vous voudrez repeindre la salle. Par exemple, après un long gel du jeu, un
message invitera l'utilisateur à appuyer sur une touche. Il faudra alors redessiner l'écran pour
passer à la suite.

screen_redraw() Redessine la salle, déclenche tous les événements Draw.

screen_refresh() Rafraîchit l'écran sans déclencher les événements.

Pour comprendre la seconde fonction, vous devez avoir une petite idée du fonctionnement
interne de l'affichage du jeu. GM affiche d'abord ses objets, sa salle dans une image interne,
un buffer. Cette image n'est visible à l'écran. A la fin du cycle, quand tous les objets sont bien
placés, cette image interne est affichée à l'écran (la technique du double buffer). La 1 ère
fonction redessine l'image interne puis l'affiche à l'écran. La seconde fonction affiche
simplement l'image interne à l'écran sans y redessiner les objets.

Réalisez aussi qu'il n'est pas possible d'utiliser les fonctions de dessin ailleurs que dans
l'événement Draw. Si vous le faites, cela ne sera pas visible à l'écran. Car quand l'événement
Draw est activé, c'est d'abord le fond de la salle qui se dessine, effaçant tout ce que vous
auriez dessiné par code dans l'image interne. Mais quand vous utilisez screen_refresh()
après votre dessin, l'image mise à jour reste visible à l'écran. Par exemple, un script dessine du
texte sur l'écran, appelle la fonction de rafraîchissement puis attend que le joueur appuie sur
une touche :

{
draw_text(screen_width/2,100,'Appuyez sur une touche pour continuer.');
screen_refresh();
keyboard_wait();
}

Veuillez comprendre que lorsque vous dessinez dans d'autres événements que le Draw, vous
dessinez simplement dans l'image interne, pas dans une vue. Les coordonnées sont les mêmes
que s'il n'y avait pas de vue !
Utilisez avec précaution ces fonctions. Le rafraîchissement prend du temps.

96
Chap. 29 GML : Son et Musique
Le son joue un rôle crucial dans les jeux vidéo. Il y a 2 types de son : la musique de fond et
les effets sonores. La musique de fond est en général un fichier midi qui se répète
indéfiniment. Les effets sonores ou bruitages sont de courts fichiers wav. Pour prendre effet
immédiatement, ces fichiers sont stockés en mémoire. Du coup, assurez-vous qu'ils ne soient
pas trop gros et longs en temps.

Les sons sont ajoutés à votre jeu sous forme de ressources. Assurez-vous de donner un nom
valide à celles-ci. L'un des aspects du son est la notion de buffer et du nombre de buffers. Le
système ne peut jouer qu'un seul même son wav à la fois. Quand vous rejouez un son
(boum!), le précédent boum s'arrête aussitôt. Ce n'est pas très sympathique. Si vous voulez
jouer un même effet sonore plusieurs fois, il faut le stocker sous différents noms (ex : un coup
de feu). Ce nombre est le nombre de buffers. Plus il y a de buffers pour un son, plus ce son
peut être joué simultanément mais, bien sur, çà consomme de la mémoire. Utilisez donc les
buffers avec soin. Game Maker utilise automatiquement le 1er buffer disponible, vous n'avez
pas à vous préoccuper du reste.

Il y a 4 fonctions de base concernant le son, deux pour jouer un son, une pour tester si le son
est joué et une pour stopper le son. Ces fonctions demandent l'index de la ressource du son
concerné. Le nom du son constitue cet index. Mais vous pouvez utiliser une variable pour
stocker ce nom.

sound_play(index) Joue le son une seule fois.

sound_loop(index) Joue le son en boucle infinie.
sound_stop(index) Arrête le son. S'il y a plusieurs fois le même son qui
est joué, ils s'arrêtent tous.
sound_isplaying(index) Indique si ce son est actuellement joué.

Il est possible d'utiliser davantage d'effets sonores. Mais çà ne s'applique qu'aux fichiers Wav
et non aux fichiers Midi. Quand vous voulez un effet spécial, vous devez l'indiquer dans
l'onglet Advanced des propriétés du son. Attention, ces effets spéciaux exigent plus de
ressources que les autres sons.

Il y a 3 types d'effet :

1. Changer le volume. Une valeur de 0 signifie "aucun son". Une valeur de 1 signifie le
volume initial du son. Vous ne pouvez pas indiquer une valeur > 1.
2. Changer l'origine du son (pan), la direction d'où vient le son. Une valeur 0 signifie que
le son vient de la gauche. Une valeur de 1, que le son vient de la droite et une valeur
de 0.5, que le son est équilibré, au milieu (valeur par défaut). Vous pouvez ainsi
simuler un déplacement de gauche à droite.
3. Changer la fréquence du son. Ce qui peut être utilisé pour modifier la vitesse d'un
engin. Une valeur de 0 signifie la plus basse fréquence et une valeur de 1, la plus
haute.

Les fonctions associées sont :

sound_volume(index,valeur) Change le volume du son (0 = bas, 1 = haut).

sound_pan(index,value) Change la provenance (0 = gauche, 1 = droite).
sound_frequency(index,value) Change la fréquence (0 = bas, 1 = haut).
97
Les sons consomment beaucoup de ressources et la plupart des systèmes ne peuvent stocker
qu'un nombre limité de sons. Si vous voulez fabriquer un gros jeu, vous devrez contrôler le
chargement et le déchargement en mémoire des sons. C'est bien sur à vous de planifier le tout.
Vous pouvez utiliser l'option "load-on-use" pour être sur que le son ne sera chargé que s'il est
réellement utilisé. Pour ce faire, vous avez les fonctions suivantes :

sound_discard(index) Enlève le son de la mémoire qui est libérée.

sound_restore(index) Replace le son dans la mémoire.
discard_all() Enlève tous les sprites, les fonds et les sons de la
mémoire dont l'option load-on-use est cochée.

Quand votre jeu utilise beaucoup de sons ou musiques de grande durée (ex : un fond sonore),
il est préférable de ne pas les stocker dans le jeu mais dans des fichiers extérieurs. Ce qui
réduira le temps de chargement du jeu et de choisir une musique parmi plusieurs. Pour cela,
utilisez les fonctions suivantes :

sound_add(nomfichier,nbrbuffers,effets,chargésiutilisé)
Ajoute une ressource sonore au jeu. NomFichier est le
nom du fichier. Buffers indique le nombre de buffers
utilisés. Effets indique si les effets sonores sont autorisés
ou non, même chose pour ChargéSiUtilisé qui est
l'option load-on-use. La fonction retourne l'index du
nouveau son (-1 indique une erreur, ex: le fichier
n'existe pas).
sound_replace(index, nomfichier,nbrbuffers,effets, chargésiutilisé)
Même chose que la fonction précédente mais on indique
l'index du nouveau son, l'ancien étant remplacé par ne
nouveau. Retourne true ou false selon la réussite du
chargement.
sound_delete(index) Détruit le son indiqué par l'index et libère la mémoire
qui lui était associée.

ATTENTION : Quand vous sauvez le jeu durant la partie, les sons ajoutés ou remplacés ne
sont pas stockés dans la sauvegarde.

Les sons sont un peu compliqués. Les fichiers Midi sont joués par le Lecteur Windows
Multimédia. Un seul son Midi peut être joué à la fois. Pour les fichiers Wav, Game Maker
utilise DirectSound (NdT: un driver interne à Windows, basé sur DirectX qui est un ActiveX.
Attention aux diverses versions). Dans ce cas, tous les fichiers Wav sont stockés en mémoire
et peuvent avoir des effets. Game Maker peut aussi exécuter d'autres fichiers musicaux
comme les MP3. Il utilise alors le Lecteur Windows Multimédia. Faites attention, cette
exécution dépend fortement de l'ordinateur et de sa configuration. Aussi, évitez, dans le cas
d'un jeu distribué à un maximum de gens, d'utiliser les fichiers MP3.

98
Chap. 30 GML: Splash, Highscores, et autres pop-ups
Beaucoup de jeux possèdent des fenêtres surgissantes (splash screen). Ces fenêtres affichent
une vidéo, une image ou du texte. Ces fenêtres sont souvent utilisées au commencement d'un
jeu (comme intro), au début d'un niveau ou à la fin du jeu (pour les crédits). Dans Game
Maker, vous pouvez faire surgir ces fenêtres à n'importe quel moment durant le jeu. Celui-ci
est temporairement gelé tant que la fenêtre s'affiche.
Les fonctions qui gèrent ces Splashs sont :

show_text(fic,pleinécran,couleur,délai)
Affiche un texte dans un splash. Fic est le nom du fichier qui
contient le texte (.txt ou .rtf). Ce fichier doit être dans le
même dossier que votre jeu et quand vous créez une
version définitive du jeu (stand-alone), n'oubliez pas ce
fichier texte. PleinEcran indique si le splash s'affiche sur
la totalité de l'écran (true/false). Couleur est la couleur
de fond et Délai indique l'attente en seconde avant de
retourner au jeu (le joueur peut toujours cliquer sur
l'écran pour retourner au jeu).
show_image(fic, pleinécran,délai)
Affiche une image dans un splash. Fic est le nom du
fichier image (uniquement .bmp, .jpg et .wmf). Ce
fichier doit être dans le même dossier que votre jeu.
PleinEcran indique si le splash est en plein écran et
Délai, l'attente en seconde avant de revenir au jeu.
show_video(fic, pleinécran,boucle)
Affiche une vidéo dans un splash. Fic est le nom du
fichier vidéo (.avi,.mpg). Ce fichier doit être dans le
même dossier que le jeu. PleinEcran indique si le splash
est en plein écran. Boucle indique si la vidéo joue en
boucle, indéfiniment.
show_info() Affiche les informations du jeu.

Un certain nombre d'autres fonctions proposant des boîtes de dialogues existent, comme
demander un nombre, un texte, un menu avec choix ou indiquer une couleur ou un nom de
fichier :

show_message(txt) Affiche une boîte de dialogue avec un texte txt.

show_question(txt)
show_menu(txt,déf)
get_integer(txt,def)
get_string(txt,def)
Affiche une question; retourne true si l'utilisateur a
cliqué sur le bouton Yes, sinon retourne false.
Affiche un menu pop-up. Le texte doit contenir les
différents items séparés par une barre verticale | .
Exemple : txt = 'menu0|menu1|menu2'. Si le 1er item est
sélectionné, la fonction retourne 0 et ainsi de suite. Si le
joueur ne sélectionne aucun item, la valeur par défaut
(déf) est retournée.
Pose une question demandant un nombre entier au
joueur. Txt est le message et Déf est le nombre par
défaut.
Pose une question demandant un texte au joueur. Txt est
le message et Déf est le texte par défaut.

99
 get_color(couleur) Demande une couleur. Couleur est la valeur par défaut.

get_open_filename(filtre,fic) Demande au joueur un nom de fichier afin de l'ouvrir,

Fic est le nom de fichier par défaut. Filtre aura la forme :
'nom1|masque1|nom2|masque2|…'. Un masque peut
contenir différentes options séparées par un point-
virgule. Exemple : 'images|*.bmp;*.wmf'.
get_save_filename(filtre,fic) Demande un nom de fichier pour la sauvegarde.
get_directory(dossier) Demande un nom de dossier. Dossier est le nom par
défaut.

Une fenêtre spéciale est la liste des meilleurs scores (highscores) qui est maintenue pour
chaque jeu. Les fonctions suivantes existent :

highscore_show(nombre) Affiche la liste des scores, Nombre étant le nouveau

highscore_clear()
highscore_add(nom,nbr)
highscore_value(place)
highscore_name(place)
score. S'il est assez élevé pour figurer dans la liste, le
joueur pourra entrer son nom. Utilisez -1 pour afficher
simplement la liste en cours.
Efface la liste des scores.
Ajoute le joueur Nom avec son score Nbr à la liste.
Retourne le score de la personne située à la place
indiquée (1-10).
Retourne le nom de la personne située à la place
indiquée (1-10).

Attention, il est impossible d'afficher ces splashs ou ces boîtes de dialogue en mode graphique
exclusif (exclusive graphics mode) !

100
Chap. 31 GML: Fichiers, Registres, et Exécutables
Dans certains jeux sophistiqués, vous voudrez probablement lire des données d'un fichier. Par
exemple, vous voudrez fabriquer un fichier qui décrit à quel moment certaines choses
surviennent. Vous voudrez aussi sauvegarder des informations pour la prochaine fois que le
jeu s'exécutera (ex : la salle en cours). Les fonctions suivantes sont disponibles :

file_exists(nomfic) Indique si le fichier NomFic existe (true/false).

file_delete(nomfic) Supprime le fichier NomFic.
file_rename(anc,nouv) Renomme le fichier Anc en Nouv.
file_copy(nomfic,nouv) Copie le fichier NomFic en Nouv.
file_open_read(nomfic) Ouvre le fichier NomFic en lecture.
file_open_write(nomfic) Ouvre le fichier en écriture, quitte à le créer s'il
n'existe pas.
file_open_append(nomfic) Ouvre le fichier pour ajouter des données en fin de
fichier, quitte à le créer s'il n'existe pas.
file_close() Ferme le fichier en cours (ne pas oublier !).
file_write_string(txt) Ecrit le texte txt dans le fichier actuellement ouvert.
file_write_real(x) Ecrit le nombre réel x dans le fichier en cours.
file_writeln() Ecrit un retour chariot (CR-NL).
file_read_string() Lit et retourne un texte. Un texte s'achève à la fin de
la ligne.
file_read_real() Lit et retourne une valeur réelle.
file_readln() Saute le reste de la ligne et pointe sur le début de la
ligne suivante.
file_eof() Indique si on est arrivé en fin de fichier.
directory_exists(rép) Indique si le dossier Rép existe.
directory_create(rép) Crée le dossier Rép.

Si le joueur s'est mis en mode sécurisé dans ses préférences, il est alors impossible de
spécifier un chemin et seules les fichiers étant dans le même dossier que le jeu peuvent être
utilisés (en lecture ou écriture).

Les 3 variables en lecture seule peuvent être utilisées :

game_id* Identifiant unique du jeu. Vous pouvez l'utiliser si

vous avez besoin d'un nom de fichier qui n'existe pas
encore.
working_directory* Dossier de travail du jeu (incluse pas le \ final).
temp_directory* Dossier temporaire créé par le jeu. Vous pouvez y
stocker divers fichiers. Ils seront détruits à la fin du
jeu.

101
Si vous voulez stocker des informations entre chaque partie, il existe un mécanisme plus
simple que d'utiliser un fichier. Vous pouvez utiliser les registres. La base des registres est
une base de données que Windows maintient en y stockant toutes sortes d'informations sur le
paramétrage des programmes. Chaque entrée a un nom et une valeur. Vous pouvez aussi bien
utiliser des chaînes de caractères que des réels. Le nom de l'entrée s'appelle parfois clé ou
mot-clé. Les fonctions suivantes sont disponibles :

registry_write_string(nom,txt) Crée une entrée ayant pour étiquette Nom

registry_write_real(nom,x)
registry_read_string(nom)
registry_read_real(nom)
registry_exists(nom)
et comme valeur Txt.
Crée une entrée avec le Nom et le réel X.
Retourne le texte lu à l'entrée Nom. Si le
Nom n'existe pas, un Txt vide est renvoyé.
Retourne le réel de l'entrée Nom. Si le Nom
n'existe pas, la valeur 0 est renvoyée.
Indique si l'entrée Nom existe.

Actuellement, les valeurs sont groupées en sections. Les fonctions sont liées implicitement à
la section spécialement crée pour votre jeu. Il est néanmoins possible d'aller lire des valeurs
situées dans d'autres sections. Ce qui permet à votre jeu d'aller lire des informations. Il est
impossible d'écrire dans les autres sections. Les fonctions suivantes ne fonctionnent que dans
la section générale HKEY_CURRENT_USER. Pour trouver le dossier temporaire, écrivez :

dossiertempo = registry_read_string_ext('/Environment','TEMP');

Les fonctions suivantes existent :

registry_read_string_ext(section,nom)
Retourne le texte associé à l'entrée Nom dans la Section. En cas d'erreur, une
valeur vide est retournée.
registry_read_real_ext(section,name)
Retourne le réel associé à l'entrée Nom dans la Section. En cas d'erreur, la valeur
0 est retournée.
registry_exists_ext(section,nom)
Indique si l'entrée Nom de la Section existe.

Game Maker peut aussi lancer des programmes externes. Il y a 2 fonctions :

execute_program(prog,arg,délai)
Exécute le programme prog avec les arguments arg. Délai indique si on doit
attendre la fin du programme pour passer à la suite.
execute_shell(prog,arg)
Exécute le programme prog (ou le fichier). Pas d'argument ni d'attente.

Ces 2 fonctions ne marchent pas en mode sécurisé. Il est possible de lire la variable en lecture
seule qui indique le mode en cours :

secure_mode* indique si le jeu fonctionne en mode sécurisé.

102
Chap. 32 GML: Mode Multi Joueurs
Jouer contre l'ordinateur est amusant. Mais jouer contre d'autres êtres humains peut être
encore plus amusant. Il est relativement facile de fabrique de tels jeux car vous n'aurez pas à
mettre en place des algorithmes compliqués d'Intelligence Artificielle (IA). Vous pouvez bien
sur mettre deux joueurs devant le même clavier et leurs demander d'utiliser des touches
différentes mais il est plus intéressant de mettre chaque joueur devant son ordinateur. Ou
mieux encore, un joueur de chaque côté de l'océan. Game Maker offre un support multi
joueurs. Veuillez réaliser que synchroniser tout ce petit monde sans délai d'attente est une
tâche difficile. Ce chapitre donne une rapide description de ces possibilités. Vous trouverez
sur le site Internet un tutorial avec plus d'information (ndt : en anglais, of course).

32.1 Configurer une connexion

Pour que 2 ordinateurs communiquent, il faut un protocole de connexion. Comme beaucoup

de jeux, Game Maker offre 4 différents types de connexion : IPX, TCP/IP, Modem, et Série :

IPX Ce protocole fonctionne de façon complètement transparente. Il peut être utilisé par
différents joueurs situés sur le même réseau local. Il doit être installé sur votre
ordinateur pour être utilisable (voir la documentation d'installation de Windows ou
allez dans les propriétés du Voisinage Réseau et ajoutez le protocole IPX)
TCP/IP est le protocole internet. Il peut être utilisé pour jouer avec des personnes situées
n'importe où sur le Web, à condition que vous connaissiez leurs adresses IP.
Modem Il faut dans ce cas appeler un autre joueur ayant lui aussi un modem par son numéro
de téléphone et une chaîne de caractères d'initialisation.
Série Grâce à un simple câble entre 2 ordinateurs, vous pouvez jouer ensemble à condition
de préciser le port série (Com1, Com2 etc.) utilisé.

Voici les fonctions utilisables :

mplay_init_ipx()
Initialise une connexion IPX.
mplay_init_tcpip(adr)
Initialise une connexion TCP/IP connexion. Adr est une chaîne IP
('www.gameplay.com' ou '123.123.123.222') suivie éventuellement d'un port (':12'
 '123.123.123.222:12). Sur un réseau local, les adresses ne sont pas nécessaires.
mplay_init_modem(init,notel)
Initialise une connexion modem. Init est la chaîne d'initialisation (peut être
vide) et NoTél est le numéro de téléphone à appeler ('001122334455'). C'est
seulement pour joindre une session qu'il vous faut un n° de téléphone.
mplay_init_serial(noport,vitesse,bitarret,parité,flux)
Initialise une connexion série.
- NoPort est le numéro de port (1-4). 0 affiche une boîte de dialogue.
- Vitesse (baudrate) 100 Bauds à 256 KBauds.
- BitArrêt 0 = 1 bit, 1 = 1.5 bit, 2 = 2 bits.
- Parité 0=none, 1=odd, 2=even, 3=mark.
- Flux (flow ctrl) 0=none, 1=xon/xoff, 2=rts, 3=dtr, 4=rts et dtr.
Indique si la connexion est réussie. Un paramétrage classique est : 1,57600,0,0,4.

103
Votre jeu doit utiliser ces fonctions qu'une seule fois. Toutes ces fonctions indiquent si
l'initialisation est correctement déroulée. Il y a erreur si le protocole n'est pas installé ou
supporté par l'ordinateur. Pour vérifier si la connexion en elle-même est correcte, utilisez la
fonction :

mplay_connect_status()
Retourne le type de statut de la connexion en cours
0 : erreur 1 : IPX 2 : TCP/IP 3 : Modem 4 : Série

mplay_end() Coupe la connexion.

Quand vous utilisez une connexion TCP/IP, vous devez connaître l'adresse IP de la personne
jointe. Et parfois la vôtre ! La fonction suivante y pourvoit :

mplay_ipaddress()
Retourne l'adresse IP de votre ordinateur (exemple : '123.123.123.12'). Vous
pouvez afficher cette adresse à l'écran. Attention, cette routine prend du temps.

32.2 Créer et Rejoindre des Sessions

Quand vous vous connectez à un réseau, il peut y avoir divers jeux en cours de route. Nous
appelons çà des sessions. Ces différentes sessions correspondent à différents jeux ou à un
seul. Un jeu doit être identifié de façon unique sur un réseau. Heureusement, Game Maker
s'en occupe. La seule chose à savoir est que vous devez changer l'identifiant dans les options
du jeu. Par ce biais, il est possible de jouer avec des personnes ayant une ancienne version ou
une récente.

Si vous démarrer un session multi joueur, il faut créer une nouvelle session :

mplay_session_create(nomsession,maxi,nomjoueur)
Crée une nouvelle session dans la connexion en cours.
- NomSession est le nom de la session à créer.
- Maxi est le nombre maximum de joueurs dans cette session.
- NomJoueur est le nom du joueur, le vôtre.
Indique si la session a pu être créée.

Une instance du jeu doit créer la session. Les autres instances du jeu rejoignent la session qui
vient être créée. C'est un peu plus compliqué : Vous devez d'abord voir quelles sessions sont
disponibles puis choisir celle à rejoindre. 3 fonctions s'en occupent :

mplay_session_find()
Recherche toutes les sessions qui acceptent des joueurs et retourne le nombre de
sessions trouvées.
mplay_session_name(num)
Retourne le nom de la session n° Num (0 est la 1 ère session). Cette routine ne
fonctionne que si la précédente a été appelée.
mplay_session_join(num,nomjoueur)
Vous introduit dans la session n° Num (0 est la 1 ère session). NomJoueur est le nom
que vous décidez de prendre en tant que joueur dans la session. Indique si tout c'est
bien passé.

104
Il y a une autre routine qui vous permet de changer de mode de session. Doit être appelée
après la création de la session :

mplay_session_mode(dépl) Faut-il oui ou non transférer l'hôte de la session sur un

autre ordinateur quand l'hôte quittera la partie ? Dépl
est soit à True ou à False (valeur par défaut).

Pour connaître le statut de la session en cours :

mplay_session_status() Retourne le statut : 0 = pas de session, 1 = session créée,

2 = session rejointe.

Un joueur peut quitter la session par la fonction suivante :

mplay_session_end() Termine la session pour le joueur.

32.3 Joueurs

Chaque instance du jeu qui rejoint une session est en réalité considérée comme un joueur.
Chaque joueur a un nom. Trois routines s'occupent des joueurs :

mplay_player_find() Recherche tous les joueurs d'une session et retourne le

mplay_player_name(num)
mplay_player_id(num)
nombre de joueurs trouvés.
Retourne le nom du joueur n° Num (0 étant le 1 er
joueur). Cette routine ne fonctionne que si la précédente
a été appelée.
Retourne l'identifiant unique (id) du joueur n° Num (0
étant le 1er joueur). Cette routine ne doit être utilisée
qu'après avoir lancé mplay_player_find(). Cet ID est
utilisé pour envoyer et recevoir des messages des autres
joueurs.

32.4 Partage de Données

La communication par partage de données est probablement la façon la plus simple de

synchroniser le jeu. Toutes vos communications sont protégées. Il y a un ensemble de 10.000
valeurs (ou emplacements) qui sont communes à tout le jeu. Chaque instance du jeu peut lire
et écrire des valeurs dans ces emplacements. Game Maker garantit que chaque instance du jeu
(chaque joueur) voit les mêmes valeurs. Une valeur peut être un réel ou un texte. Il y a
seulement 2 routines :

mplay_data_write(e,v) Ecrit la valeur V (texte ou réel) à l'emplacement E (E

compris entre 0 et 10.000).
mplay_data_read(e) Retourne la valeur de la l'emplacement E (entre 0 et
10.0000). Au début, toutes les valeurs sont à 0.

105
Pour synchroniser ces valeurs sur différents ordinateurs, vous pouvez utiliser un mode
"garanti" qui vous assure que chaque changement de valeur sera bien envoyé à tout le monde
(mode lent) ou un mode "non garanti". Pour choisir le mode, utilisez la fonction :

mplay_data_mode(guar) Guar = true  mode "garanti" (valeur par défaut).

Guar = false  mode "non garanti".

32.5 Messages

Le second mécanisme de communication que Game Maker supporte est l'envoi et la réception
de message. Un joueur peut envoyer des messages vers un joueur en particulier ou à tous les
joueurs. Les joueurs peuvent ainsi accorder leurs actions en fonction des messages reçus. Ces
messages peuvent être envoyés en mode "garanti" pour être sur qu'ils arrivent (mais ce mode
est lent) ou en mode "non garanti" (qui est plus rapide).

Les routines suivantes existent :

mplay_message_send(joueur,id,val)
Envoie un message au joueur indiqué (soit un identifiant ou un nom, utilisez 0
pour adresser un message à tous les joueurs). Id est un nombre entier qui
identifie le message et Val est la valeur (texte ou réel). Le message est envoyé en
mode "non garanti".
mplay_message_send_guaranteed(joueur,id,val)
Idem que la précédente sauf que le message est envoyé en mode "garanti".
mplay_message_receive(player)
Reçoit le prochain message stocké dans la mémoire d'entrée, de réception des
messages, tampon (buffer/queue) qui provient du joueur indiqué (nom ou
identifiant). Utilisez 0 pour recevoir un message de tous les joueurs. La routine
indique s'il existe effectivement un message à lire. Pour consulter le message,
utilisez les fonctions suivantes :
mplay_message_id() Retourne l'identifiant du dernier message reçu.
mplay_message_value() Retourne la valeur du dernier message reçu.
mplay_message_player() Indique le joueur qui a envoyé le dernier
message reçu.
mplay_message_name() retourne le nom du joueur qui...
mplay_message_count(joueur) Retourne le nombre de messages restés dans le
buffer d'entrée provenant du joueur indiqué (0
pour compter les messages de tous les joueurs).
mplay_message_clear(joueur) Supprime tous les messages restés dans le
tampon d'entrée du joueur indiqué (0 pour
effacer tous les messages de tous les joueurs).

Pour envoyer un message, il faut connaître l'identifiant ou le nom du joueur voulu. Utilisez la
fonction mplay_player_id()pour le connaître. Si plusieurs joueurs ont le même nom, seul le
1er est concerné. Idem pour lire un message particulier, il faut connaître qui l'envoie.
Pourquoi chaque message possède un identifiant ? La raison est que çà facilite beaucoup la
programmation. Cet identifiant est une sorte de type de message et permet de faire le tri en
réception. Comme l'envoie de messages n'est pas garanti, vous pouvez utiliser cet identifiant
comme une sorte de compteur afin de vérifier si tout a bien été reçu dans l'ordre.

106
Chap. 33 GML: Utilisation de DLL
Si jamais les fonctionnalités de GML ne suffisaient pas, vous pouvez étendre de celui-ci par
des plug-ins qui seront en réalité des fichiers DLL (Dynamic Link Library, librairie de liens
dynamiques). Dans une DLL, vous pouvez définir de nouvelles fonctions qui pourront être
programmées dans n’importe quel langage capable de créer ces dites DLL (logique non ?).
Exemple : Delphi, Visual C++, Visual Basic, etc… Vous devez néanmoins être bon
programmeur pour ce faire. Les fonctions doivent avoir un format spécifique et peuvent avoir
0, 1, 2, 3 ou 4 arguments qui seront soit des nombre réel (Float) ou des chaînes de caractères à
terminateur 0 (AsciiZ comme en C). L’argument en retour sera lui aussi un Float ou un
AsciiZ.

En Delphi, vous créez une DLL en choisissant New dans le menu File puis DLL. Il y a ci-
dessous un exemple de DLL que vous pouvez utiliser avec GM. Notez qu’il s’agit bien d’un
code écrit en Delphi et non en GML !

library MyDLL;

uses SysUtils, Classes;

function MyMin(x,y:real):real; cdecl;

begin
if x<y then Result := x else Result := y;
end;

var res : array[0..1024] of char;

function DoubleString(str:PChar):PChar; cdecl;

begin
StrCopy(res,str);
StrCat(res,str);
Result := res;
end;

exports MyMin, DoubleString;

begin
end.

Cette DLL définit 2 fonctions : MyMin qui a besoin de 2 arguments reels et qui retourne le
minimum des e et DoubleString qui dédouble la chaîne de caractères. Faites attention à la
gestion de la mémoire. C’est pour cela que j’ai déclaré une variable globale pour le retour de
la chaîne de caractères. Notez aussi la convention d’appel du cdecl calling. C’est
obligatoirement comme çà qu’il faut s’y prendre. Une fois la DLL compilée avec Delphi,
vous obtiendrez un fichier MyDLL.DLL. ce fichier doit être placé dans le même dossier que
votre jeu ou dans un dossier que Windows puisse trouver (Windows\System ou un dossier
prévu dans le path).

107
Pour utiliser cette DLL dans GM, vous devez d’abord déclarer les fonctions externes dont
vous avez besoin. Utilisez alors les fonctions suivantes :

external_define0(dll,name,restype)
 Définit une fonction externe sans argument.
 dll est le nom du la DLL.
 name est le nom de la fonction.
 restype est le type du résultat. Utilisez soit ty_real ou ty_string.

external_define1(dll,name,arg1type,restype)
 Définit une fonction externe avec 1 argument.
 dll est le nom du la DLL.
 name est le nom de la fonction.
 Arg1type est le type de l’argument. Utilisez soit ty_real ou ty_string
 restype est le type du résultat. Utilisez soit ty_real ou ty_string

external_define2(dll,name,arg1type,arg2type,restype)
 Définit une fonction externe avec 2 arguments.
.
external_define3(dll,name,arg1type,arg2type,arg3type,restype)
 Définit une fonction externe avec 3 arguments.

external_define4(dll,name,arg1type,arg2t,arg3t,arg4t,restype)
 Définit une fonction externe avec 4 arguments.

Chacun de ces fonctions retourne un identifient (id) qui devra être utilisé lors de l’appel. Voici
maintenant un exemple de déclaration en GML :

{
global.mmm =
external_define2('MYOWN.DLL','MyMin',ty_real,ty_real,ty_real);
global.ddd =
external_define1('MYOWN.DLL','DoubleString', ty_string, ty_string);
}

Maintenant voici comment récupérer l’identifiant :

{
aaa = external_call2(global.mmm,x,y);
sss = external_call1(global.ddd,'Hello');
}

Voici les fonctions de lancement :

external_call0(id)
 Appele la fonction externe à l’aide de l’identifiant sans argument.
external_call1(id,arg1)
 Appele la fonction externe à l’aide de l’identifiant avec 1 argument.
external_call2(id,arg1,arg2)
 Appele la fonction externe à l’aide de l’identifiant avec 2 arguments.
external_call3(id,arg1,arg2,arg3)
 Appele la fonction externe à l’aide de l’identifiant avec 3 arguments.
external_call4(id,arg1,arg2,arg3,arg4
 Appelle la fonction externe à l’aide de l’identifiant avec 4 arguments.

108
Vous savez maintenant comment créer une DLL pour GM. Vous pouvez utiliser cette
technique pour améliorer vos jeux. Par exemple, vous pouvez créer une DLL pour ajouter des
instances d’objets dans un jeu. La façon la plus simple serait que la fonction retourne une
chaîne de caractères contenant le code GML à exécuter. La chaîne contient dans ce cas le
morceau de code GML qui peut être exécuté en utilisant la fonction GML.

execute_string(str)
 Exécute le morceau de code GML de la chaîne str.

Maintenant, vous pouvez appeler une fonction externe et exécuter la chaîne résultante comme
dans l’exemple suivant :

{
ccc = external_call2(global.mmm,x,y);
execute_string(ccc);
}

Notez bien que cette DLL ne peut pas être utilisée en mode sécurisé (voir Préférences)

L’utilisation des DLL est une fonctionnalité extrêmement puissante. Mais veuillez l’utiliser
que si et seulement si vous êtes sur de ce que vous faites.

Fin du document


109