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 2002Version 1.1 – Mars 2003

patrikcarpentier@homail.com

2

Table des Matières

Chap. 1 Ainsi vous désirez créer votre propre jeu....................................................5Chap. 2 Installation..................................................................................................6Chap. 3 Idée Générale.............................................................................................7Chap. 4 Analysons un Exemple..............................................................................9Chap. 5 Fenêtre Principale....................................................................................11

5.1 Menu File (Fichier)...................................................................................................115.2 Menu Edit (Edition)..................................................................................................125.3 Menu Add (Ajout).....................................................................................................135.4 Menu Window (Fenêtre)...........................................................................................135.5 Menu Help (Aide).....................................................................................................135.6 Explorateur de Ressources........................................................................................13

Chap. 6 Définition de sprites.................................................................................14Chap. 7 Sons et Musiques......................................................................................16Chap. 8 Arrière-plans............................................................................................17Chap. 9 Définition d’objets...................................................................................18Chap. 10 Evénements...............................................................................................20Chap. 11 Actions......................................................................................................24

11.1 Actions de Mouvement............................................................................................2411.2 Object related actions (objets)..................................................................................2611.3 Miscellaneous Actions (divers).................................................................................2711.4 Questions...................................................................................................................2911.5 Actions de Dessin.....................................................................................................3111.6 Actions de Code........................................................................................................3211.7 Utilisation des expressions et des variables..............................................................32

Chap. 12 Création de salles.....................................................................................3412.1 Ajout d'instances.......................................................................................................3512.2 Paramètres de Salle...................................................................................................3512.3 Paramètres d'Arrière-Plans........................................................................................36

Chap. 13 Un peu plus sur les Sprites......................................................................3713.1 Editez vos sprites......................................................................................................3713.2 Edition des sous images individuelles......................................................................4113.3 Options avancées sur les Sprites...............................................................................42

Chap. 14 Plus sur les Sons et les Musiques............................................................43Chap. 15 Plus sur les Arrière-Plans.......................................................................44Chap. 16 Plus sur les objets.....................................................................................45

16.1 Profondeur (Depth)...................................................................................................4516.2 Objets persistants (Persistent objects).......................................................................4516.3 Parents.......................................................................................................................4516.4 Masques (Masks)......................................................................................................46

Chap. 17 Plus sur les Salles.....................................................................................4717.1 Onglet Settings (Paramètres)....................................................................................4717.2 Onglet Tiles (Tuiles).................................................................................................4717.3 Onglet Views (Vues).................................................................................................49

Chap. 18 Chemins (Paths).......................................................................................50

3

18.1 Définir des Chemins.................................................................................................5018.2 Affecter un chemin à un objet...................................................................................5118.3 Evénement Path........................................................................................................52

Chap. 19 Scripts.......................................................................................................53Chap. 20 Informations sur le Jeu (Game information)........................................54Chap. 21 Options de Jeu (Game options)..............................................................55

21.1 Options graphiques (Graphics).................................................................................5521.2 Options de Clavier (Key)..........................................................................................5621.3 Options d'Interaction.................................................................................................5721.4 Options de Score.......................................................................................................5721.5 Options de Chargement (Loading)............................................................................5821.6 Options d'Erreur (Error)............................................................................................58

Chap. 22 Considérations sur la Vitesse..................................................................59Chap. 23 Distribuez votre Jeu.................................................................................60Chap. 24 Le Langage de Game Maker (GML).....................................................61

24.1 Programme................................................................................................................6124.2 Variables...................................................................................................................6124.3 Affectations...............................................................................................................6224.4 Expressions...............................................................................................................6224.5 Variables Locales et Globales...................................................................................6324.6 Adresser les variables d'autres instances...................................................................6324.7 Tableaux....................................................................................................................6424.8 Instruction If..............................................................................................................6424.9 Instruction Repeat.....................................................................................................6524.10 Instruction While..................................................................................................6524.11 Instruction For.......................................................................................................6624.12 Instruction Exit......................................................................................................6624.13 Fonctions...............................................................................................................6624.14 Scripts...................................................................................................................6724.15 Constructeur With.................................................................................................6724.16 Commentaires //....................................................................................................6824.17 Style Pascal...........................................................................................................6924.18 Fonctions et Variables en GML............................................................................69

Chap. 25 Fonctions de Calcul..................................................................................7025.1 Constantes.................................................................................................................7025.2 Fonctions Mathématiques.........................................................................................7025.3 Fonctions Alphanumériques.....................................................................................71

Chap. 26 GML: Déroulement du Jeu.....................................................................7226.1 Concernant le Déplacement......................................................................................7226.2 Instances....................................................................................................................7426.3 Le Temps..................................................................................................................7626.4 Salles et Scores.........................................................................................................7726.5 Gestion des Evénements...........................................................................................7826.6 Variables et Fonctions diverses................................................................................79

Chap. 27 Les Interactions Utilisateur (Souris et Clavier)....................................8027.1 Le Support du Joystick..............................................................................................82

Chap. 28 Les graphiques.........................................................................................8328.1 Fenêtre et Curseur.....................................................................................................8328.2 Sprites et Images.......................................................................................................84

4

28.3 Arrière-plans.............................................................................................................8728.4 Tuiles.........................................................................................................................8928.5 Fonctions de Dessin..................................................................................................9128.6 Vues..........................................................................................................................9428.7 Transitions.................................................................................................................9528.8 Redessiner l'Ecran.....................................................................................................95

Chap. 29 GML : Son et Musique............................................................................96Chap. 30 GML: Splash, Highscores, et autres pop-ups........................................98Chap. 31 GML: Fichiers, Registres, et Exécutables...........................................100Chap. 32 GML: Mode Multi Joueurs...................................................................102

32.1 Configurer une connexion.......................................................................................10232.2 Créer et Rejoindre des Sessions..............................................................................10332.3 Joueurs....................................................................................................................10432.4 Partage de Données.................................................................................................10432.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. Export scripts. Pour exporter vos propres scripts (programmation). Plus de détails au

chapitre 18.

12

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 RessourcesA 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 eventCet é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 eventCet é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 eventsChaque 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 eventL’é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 eventsQuand 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 eventsQuand 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 eventsLes é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 eventsIl 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 eventLes 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 directionDé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 motionChoisir 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 speedVitesse 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 speedVitesse verticale. Même logique que ci-dessus.

Move towards a pointDé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 gravityVous 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 frictionLa 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 positionSauter à 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 positionSauter à la position de départ. L’instance se replace à sa position initiale, celle de la création.

Jump to a random positionSauter à 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 directionInverse 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 directionInverse 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 objectsRebondit 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 gridCollé à 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 instanceAppliquer 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 objectCré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 instanceChager 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 instanceDétruire une instance. L’événement Destroy s’applique.

Destroy instances at a positionDé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 spriteChanger 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 soundAvec 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 soundArrêter un son. Toutes les instances qui jouent ce son deviennent muettes.

Set an alarm clockParamé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 messageAfficher 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 scoreParamé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 listAfficher 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 livesPramé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 whileDormir 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 roomAller à 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 roomAller à la salle suivante. Vous pouvez indiquer un effet de transition.

Restart the current roomRecommencer 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 roomAller à une salle différente. Indiquez la salle et l'effet de transition.

Restart the gameRecommencer le jeu. Redémarrer tout le jeu à zéro.

End the gameFinir le jeu. Le jeu s'arrête. Game Over !

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

Load the gameCharger 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 informationMontrer les informations du jeu. Cette action affiche une fenêtre avec un texte. Voir le chapitre 20.

Switch fullscreen modeBasculer 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 freeSi 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 positionS'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 positionS'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 valueSi 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 oneSi 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 playingSi 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 questionSi 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 trueSi 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 pressedSi 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 gridSi 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.

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

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

End of blockFin de bloc.

31

Repeat next actionRé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 eventSortir 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 imageDessiner 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 imageDessiner 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 textDessiner 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 textChoisir la police du texte.

Draw a rectangleDessiner 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 ellipseDessiner une ellipse. Comme pour le rectangle, indiquez les 2 coins opposés.

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

Set the fill colorChoisir la couleur de remplissage. Pour les rectangles et les ellipses.

32

Set the line colorChoisir 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 scriptExé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 variableAffecter 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 codeExé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 eventAppeler 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.

CommentCommentaire. 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 variablesDans 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'instancey la coordonnée y de l'instancehspeed 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 directionvisible 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 viemouse_x la position en x de la sourismouse_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 FileCe 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 EditCe 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 TransformDans 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 ImagesDans 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 AnimationDans 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 StripsComme 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 1er sol est le parent des 4 autres, il suffit de créer le code Collision du 1er 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 modeDémarre le jeu en plein écran.

Scale percentage in windowed modeFacteur 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 screenL'é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 modeEn 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 drawingL'é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 cursorAfficher 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 modeAffiche 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 gameSi 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 informationSi 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 modesSi 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 gameSi 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 eventsSi 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 eventsSi 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 focusGeler le jeu quand la fenêtre perd la main. Si une autre fenêtre Windows passe au 1er

plan, le jeu s'arrête momentanément.

21.4 Options de Score

Show the scoreSi 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 messagesPermet d'afficher les messages d'erreur sauf si vous êtes en mode exclusif..

Write error messages to file game_errors.logToutes 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 messagesCertaines 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 0Une 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)>

}

ExempleLe 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.

ExempleLe 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.

ExempleLe 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 Whilefor (i = 1; i <= 10; i++ ){ fairetruc;}

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

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

ExempleLe 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é comme 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.

ExempleCeci 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 comprisabs(x) valeur absolue de xsign(x) signe de x (-1 or 1)round(x) x arrondi à l'entier le plus prochefloor(x) x converti à l'entier proche le plus petitceil(x) x converti à l'entier proche le plus grandfrac(x) partie factionnelle de xsqrt(x) racine carrée de x avec x >= 0sqr(x) carré de x, soit x*x.power(x,n) x à la puissance nexp(x) e à la puissance xln(x) logarithme népérien (naturel) de xlog2(x) log en base 2 de xlog10(x) log en base 10 de xlogn(n,x) log en base n de xsin(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 xarccos(x) cosinus inverse de xarctan(x) tangente inverse de xdegtorad(x) convertit les degrés en radians.radtodeg(x) convertitt les radians en degrés.min(x,y) minimum entre x et ymax(x,y) maximum entre x et ymin3(x,y,z) minimum entre x, y et zmax3(x,y,z) maximum entre x, y et zmean(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 valord(texte) retourne le code ascii du 1er caractèrereal(texte) convertit une chaîne en un réel. Str peut contenir le signe moins,

un point décimal et une partie exponantiellestring(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 xy position en yxprevious ancienne position en xyprevious ancienne position en yxstart position de départ en x dans la salleystart position de départ en y dans la sallehspeed vitesse horizontale en pixels par cyclevspeed vitesse verticale en pixels par cycledirection orientation (0-360, sens trigonométrique, inverse des

aiguilles d'une montre, 0 = à droite).speed vitesse en pixels par cyclefriction 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éemotion_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 s'accrochant à la grille de résolution hor et vert.

move_snap(hsnap,vsnap) accroche l'instance à la grille.move_towards_point(x,y,vit)

déplace l'instance à la vitesse vit vers la position x,y.move_bounce_solid(adv) rebondit contre les instances solides comme l'action

correspondante.move_bounce_all(adv) rebondit sur toutes les instances (solides ou non).move_contact(dir) 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 coordonnées x,y. La fonction retourne l'id de la nouvelle instance.

instance_copy(quelévént) 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

instance_destroy() détruit l'instance en cours.instance_change(obj,évn) change l'instance en cours en objet obj.

L'argument évn indique si les événements Destroy et Creation sont activés.

position_destroy(x,y) détruit toutes les instances dont les sprites sont sur la position x,y.

position_change(x,y,obj,évn) 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 secondefps* nombre de frames/images dessinées par secondecurrent_time* nombre de millisecondes écoulées depuis le bootcurrent_year* année en courscurrent_month* mois en courscurrent_day* jour en courscurrent_weekday* jour de la semaine en cours (1=dimanche, 7=samedi)current_hour* heure en courscurrent_minute* minute en courscurrent_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 coursroom_first* index de la 1ère salle du jeuroom_last* index de la dernière salle du jeuroom_goto(nsalle) aller en salle nsalleroom_goto_previous() aller à la salle précédenteroom_goto_next() aller à la salle suivanteroom_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 jeugame_restart() recommence tout le jeu

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

room_width* largeur en pixels de la salleroom_height* hauteur en pixel de la salleroom_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 nomgame_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 courslives nombre de vieshow_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 gaucheev_right_button bouton droitev_middle_button bouton milieuev_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 sortieev_boundary limite, frontièreev_game_start début de jeuev_game_end fin de jeuev_room_start au démarrage de la salleev_room_end fin de salleev_no_more_lives plus aucune vieev_animation_end fin d'animation

Pour l'événement Step (cycle), utilisez les constantes suivantes :ev_step_normal normalev_step_begin début de cycleev_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 coursevent_number* nombre d'événements qui commencent à s'exécuterevent_object* le n° d'index de l'événement en coursevent_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° indexroom_name(index) retourne le nom de la salle n° indexsprite_name(index) retourne le nom du sprite n° indexbackground_name(index) le nom du fond, de l'arrière plansound_name(index) le nom du sonscript_name(index) le nom du script

Puis 2 variables concernant les erreurs :

error_occurred indique quelle erreur est arrivéeerror_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éevk_left flèche gauchevk_right flèche droitevk_up flèche hautvk_down flèche basvk_enter entréevk_escape échapvk_space espacevk_shift shiftvk_control contrôle (ctrl)

81

vk_alt altvk_backspace retour arrièrevk_tab tabulationvk_home home (flèche diag haut gauche)vk_end finvk_delete supprvk_insert inservk_pageup page hautvk_pagedown page basvk_pause pause/breakvk_printscreen impr écranvk_f1 … vk_f12 fonction de F1 à F12vk_numpad0 … vk_numpad9

chiffre du pavé numériquevk_multiply * du pavé numériquevk_divide / du pavé numériquevk_add + du pavé numériquevk_subtract - du pavé numériquevk_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 gauchevk_lcontrol ctrl gauchevk_lalt alt gauchevk_rshift shift droitvk_rcontrol ctrl droitvk_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 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.

sprite_restore(num) 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.

discard_all() 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ésiutilisé,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° 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.

background_restore(num) 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é.

discard_all() 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) Profondeurtile_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) Change la région d'une tuile.tile_set_background(id,fond) Change le fond (arrière-plan) de la tuile.tile_set_visible(id,visible) Change la visibilité d'une tuile.tile_set_depth(id,depth) Change la profondeur.tile_set_scale(id,xscale,yscale) Change l'échelle.tile_set_alpha(id,alpha) 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 aquatiquec_black Noirc_blue Bleuc_dkgray Gris foncéc_fuchsia Fuchsiac_gray Gris neutrec_green Vertc_lime Tilleulc_ltgray Gris clairc_maroon Marronc_navy Cyan, bleu cielc_olive Olivec_purple Violetc_red Rougec_silver Argentc_tealc_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 creuxbs_solid pleinbs_bdiagonal diagonale descendantebs_fdiagonal diagonale montantebs_cross quadrillage (+)bs_diagcross croisillon (x)bs_horizontal horizontalbs_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 normalfs_bold grasfs_italic italiquefs_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 gauchefa_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 pixelview_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) Affiche une question; retourne true si l'utilisateur a

cliqué sur le bouton Yes, sinon retourne false.show_menu(txt,déf) 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.

get_integer(txt,def) Pose une question demandant un nombre entier au joueur. Txt est le message et Déf est le nombre par défaut.

get_string(txt,def) 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 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.

highscore_clear() Efface la liste des scores.highscore_add(nom,nbr) Ajoute le joueur Nom avec son score Nbr à la liste.highscore_value(place) Retourne le score de la personne située à la place

indiquée (1-10).highscore_name(place) 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 et comme valeur Txt.

registry_write_real(nom,x) Crée une entrée avec le Nom et le réel X.registry_read_string(nom) Retourne le texte lu à l'entrée Nom. Si le

Nom n'existe pas, un Txt vide est renvoyé.registry_read_real(nom) Retourne le réel de l'entrée Nom. Si le Nom

n'existe pas, la valeur 0 est renvoyée.registry_exists(nom) 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 nombre de joueurs trouvés.

mplay_player_name(num) Retourne le nom du joueur n° Num (0 étant le 1er

joueur). Cette routine ne fonctionne que si la précédente a été appelée.

mplay_player_id(num) 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;

beginend.

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