Tuto intégral debutant-intermédiaire-comfirmé

1)Les bases

Tous les jeux se déroulent dans des pièces (rooms). Dans ces rooms, le programmeur (vous) place les différents objets(objects). Les objets souvent présents sont par exemple des murs qui restent immobiles, des balles, qui rebondissent contre les murs.Certains objets réagissent à des événements comme par exemple quand le personnage touche le monstre, le personnage perds une vie et retourne à sa position de départ. Les objets réagissent aux collisions, mais peuvent aussi réagir au clavier, à la souris, au joystick: le personnage principal qui bouge en fonction des flèches appuyées sur le clavier.



À chaque objet est assigné un sprite c'est-à-dire une image qui apparaîtra dans le jeu. On pourra toujours changer cette image pendant le jeu. Les objets réagissent à plusieurs événements (events). Il existe beaucoup de sortes d'événements. Un des plus importants est l'événement de création de l'objet (creation event). Par exemple quand une balle est créée, on peut lui donner une vitesse initiale. Quand il y a collision avec un objet mur (collision event),on pourra faire rebondir la balle, et quand l'utilisateur appuie sur la flèche haut il y a un événement clavier (keyboard event) qui pourra faire changer la direction de la balle. Ainsi tous les objets agissent en fonction des événements qui se produisent.





Vous trouverez un exemple de base ici ( http://adrive.com/public/e6d9063e12e572daf87d172558b427990a9995df2e5d239f28b6d65440318c53.html )pour vous montrer le principe de game maker.
Vous avez deux sprites correspondants aux images de la balle et du mur.
Dans la balle il y a un événement create.
Cette événement se produit à chaque fois qu'une balle est créée, c'est-à-dire si vous utilisez un objet qui créera la balle ou quand le jeu démarre ( Au début du jeu tous les objets éxécutent les actions présentes dans l'événement de creation)
On a mis start moving in a direction dans cet événement, la balle aura donc une vitesse initiale de 4 dans une direction aléatoire. Dans l'événement collision with mur c'est à dire quand la balle touche n'importe quel mur, on a mis bounce against solid objects. La balle rebondira donc contre les murs. Pour que la balle rebondisse il faut que le mur soit solide, ouvrez l'objet mur, solid est coché.
Ouvrez maintenant le sous fichier des rooms, et ouvrez le level 1. Vous pouvez placez les murs et la balle comme vous le souhaitez. Fermez la fenêtre du niveau et démarrez le jeu en appuyant sur la touche f5.
Amusez vous à effectuer des changements au jeu!
Voici quelques idées d'amélioration:

-A chaque fois que le joueur appuie sur la touche espace la balle change de direction ( Utilisez l'event Key press-space et mettez la même action que dans create de la balle)
-Un objet arrivée. Quand la balle entre en collision avec l'arrivée, on passe au prochain niveau ( pour passer au prochain niveau utilisez Go to next room). Ajoutez des niveaux.
-Un objet piège. Quand la balle entre en collision avec le trou, on retourne au niveau précédent ( utilisez Go to previous room)
-Quand le joueur clique n'importe ou sur l'écran, un mur est créé (Pour cela il faudra créer un objet control sans sprite qui aura l'action create instance position x:mouse_x, y:mouse_y,pas relative, dans l'event global-left-mouse)
Pour vous entrainer, faites ces petits exercices. Surtout ne regardez pas tout de suite la solution! Si vous avez un blocage faites d'abord des recherches, ou alors regardez juste une partie de la solution sur laquelle vous bloquez mais n'ouvrez pas tout de suite les .gm6.

2)Les actions



Pour pouvoir programmer sur game maker,il vous faut aussi connaitre les principales actions du programme.

a)Les axes


image:
Je sais bien que c'est moche mais c'est qu'un schéma pour vous expliquer les axes.
On repère la position de tous les objets dans la room grâce aux deux valeurs x et y. Plus la valeur de x est grande, et plus le point est situé à droite (ca ca ne change pas des cours de maths). Par contre plus la valeur de y est grande , et plus l'objet est situé en bas. Une graduation correspond à un x.
Dans le jeu un x correspond à un pixel de l'écran.


Exercice

Quelles coordonnées ont les cercles colorés ?


rouge x=-3 y=-3
jaune x=2 y=6
bleu x=-5 y=1
vert x=2 y=-3




b)Les actions


onglet move: Ici vous pouvez choisir une direction et une vitesse que doit avoir votre vaisseau, vous pouvez changer la vitesse horizontale ou verticale
jump to a given position:aller vers une position donnée.
bounce against objects pour rebondir contre les objets
step toward a point pour suivre un point
step toward a point avoiding object pour suivre un point en évitant des objets.

onglet main1

create instance pour créer un objet
destroy instance pour détruire un objet ( vous verrez dans un prochain chapitre que on peut enlever les objets sans les détruire pour que le jeu utilise moins de mémoire vive)
change instance pour transformer un objet en un autre
change the sprite pour changer la sprite de l'objet par celle voulue
play a sound pour jouer un son
go to next room aller à la room suivante
go to previous room aller à la room précédente
restart the current room : recommencer la room




onglet main2

save the game pour enregistrer le jeu avec le nom file name et load the game pour charger.
restart the game pour recommencer le jeu et redémarrer le programme
End the game pour éteindre le programme

Nous parlerons de l'onglet controle,score et draw dans les prochains chapitres


Apply to

Vous vous posez la question que veut dire le apply to ? et bien c'est simple,c'est l'objet ou les objets sur lequel l'action aura lieu. Elle peut etre self : l'action se fait sur le propre objet. Cela peut etre other: dans le cas d'une collision l'action se fera sur l'autre objet de la collision. Par exemple pour un casse brique, vous pouvez utiliser destroy other dans l'event collision with brique pour l'objet balle. La troisieme possibilité est d'appliquer l'action à tous les exemplaires des objets. Vous devrez utiliser ceci par exemple si vous voulez détruire tous les ennemis.

3)Les bases(2)


Maintenant que vous avez les bases et que vous connaissez la notion d'objet, d'événement, de sprites et de room et que vous savez que les principaux événements sont l'événement de creation ( create event ), de collision (collision event),et les événements souris et claviers (keyboard event, mouse event), nous pouvons commencer à nous interesser aux événements qui sont moins important, mais pourtant indispensable à la création d'un jeu.



a) L'événement de destruction


Comme son nom l'indique l'événement de destruction se produit à chaque fois que l'objet en question est détruit. Pour détruire un objet, vous devez utiliser l'action destroy an instance. Grâce à cet événement, vous pouvez par exemple créer un objet d’argent quand un ennemi meurt.


b)Les alarms

Les alarms, à quoi ca sert ? Je vais vous expliquer à l'aide d'un exemple: Vous aimeriez qu' un objet crée des monstres toutes les 20 secondes, ou alors vous aimeriez que si on ne finit pas le niveau en moins de 40 seconde, le niveau recommence. Pour programmer ceci, il faudra forcément utiliser des alarms. Leur fonctionnement est simple: vous initialisez une alarm(de 0 à 11) avec l’action set an alarm clock à une valeur que vous choisissez. A chaque step, c’est-à-dire à chaque rafraichissement du jeu, soit tous les 30 èmes de secondes (valeur par défaut visible dans les caractéristiques de la room) la valeur de toutes les alarm baisse de 1. Dès que la valeur de la valeur de l’alarm arrive à 0, elle déclenche un événement alarm (une seule fois) Pour qu’un objet crée un monstre 10 secondes après sa création, il faudra mettre l’alarme à 10*30 steps = 300 steps. Comment faire alors pour qu’une action se répète toutes les 5 secondes ? Je vous laisse chercher. Vous avez deviné, il faut tout simplement réinitialiser ll’alarm dans l’événement alarm. Si vous n’avez pas compris, regardez les exemples d’alarm ici.


c)L’événement step



Vous voulez qu’un objet suive la souris pendant tout le jeu ? Peut-être vous avez pensé à mettre une alarm qui s’enclenche à tous les steps? Dans ce cas, bien pensé, vous avez un esprit de programmeur ! Mais il y a un moyen beaucoup plus simple : Utilisez l’événement step. L’événement step se produit par définition à tous les steps. Pour qu’un objet suive la souris, mettez dans l’event step move towards a point et comme coordonnées les coordonées de la souris (je vous rapelle mouse_x et mouse_y).


d)Les autres événements


L’événement keyboard: tant que la touche est enfoncée, l’événement a lieu.
L’événement keypress : au moment ou la touche est enfoncée, l’évenement a lieu
L’événement keyrelease: au moment ou la touche est relâchée,l’événement a lieu
Même chose pour la souris avec left button , left pressed et left released.
Différence entre mouse et global mouse : dans le cas de global.mouse on peut cliquer n’importe où à l’écran alors que pour l’événement mouse, c’est que quand on clique sur l’objet.
L’événement outside room est généré quand la totalité de l’objet est situé hors de la room.
On consacrera tout un chapitre sur l’événement draw, et pour les autres événements, vous pouvez vous amusez à deviner leur fonctionnement.



Les exercices


Faites un petit jeu ou vous controllez une balle avec le clavier, vous devez arriver avec la balle jusquà un bloc de fin, si vous touchez les murs vous devez recommencer le niveau.

Correction:

http://adrive.com/home/downloadfile/212417a2677b887e3955524db08ba324d5cf639db801a45eb126cde29527a91a

La prochaine fois nous nous lancerons dans les variables, nous apprendrons donc à inclure les vies le score, et pleins d'autres choses vous attendent...

4)Les variables

Petite introduction

Les variables ? Vous devez vous demandez ce que c'est. Les variables sont des chiffres stockés dans la mémoire courte de votre ordinateur,c'est-à-dire que à la fin de l'éxécution de votre programme,les valeus sont encore inscrites dans la mémoire mais on n'a aucune chance de les retrouver puisqu'on ne sait plus ou elles sont situées dans la mémoire.Cette mémoire est alors réutilisée par d'autres programmes qui inscrivent aussi leurs variables dans la mémoire courte. Chaque variable se caractérise par deux choses: son nom et sa valeur, son nom est en quelque sorte l'endroit ou la variable est enregistrée,le nom doit etre composée de lettres,de _, de majuscules de minuscules et de chiffres tant que ceci ne sont pas placés à la première position du nom de la variable. Les espaces sont interdits dans les noms de variables, utilisez à la place _. Les accents sont interdits !! La valeur des variables peut changer au cours du jeu. Vous pouvez alors créer une variable score qui comptera le nombre de points accumulés par le joueur. La valeur d'une variable peut aussi bien etre négative que positive et peut être décimale. Par exemple pour ajouter les vies aux jeux, il faudra créer une variable vies qui aura comme valeur 3 au début.
À chaque fois que l'on touche un ennemi, on perd une vie et la valeur de la variable vies doit baisser de 1. De plus pour que l'on perde complétement la partie quand on a plus de vies, il faudra tester en permanence la valeur de la varibale vies. Si elle est inférieur à 1, c'est que on a plus de vies et on doit recommencer la partie.


a)La déclaration



TOUTE VARIABLE doit être DÉCLARÉE !! C'est à dire que le programme doit chercher de l'espace pour stocker la variable. Pour cela: dans l'event create d'un objet mettez-y set the value of a variable avec comme nom le nom de votre variable et comme valeur ce que vous voulez. Ne cochez surtout pas relative dans l'action d'initialisation,sinon il apparaîtra un message d'erreur puisque le programme pense que l'espace pour stocker la variable à déjà été alloué alors qu'il ne l'est pas. N'oubliez jamais d'initialiser vos variables.


b)Changer la valeur d'une variable


Pour changer la valeur d'une variable, vous devez utiliser la même action set the value of a variable. Pour remettre le nombre de vies à 3, utilisez set the value of a variable vies to 3 not relative. Mais quelle est la différence entre relative et non relative ? Si c'est relatif, on ajoutera votre valeur à la valeur de la variable, par exemple pour ajouter une vie, mettez set value of a variable to 1 relative. Si vous voulez diminuer la valeur d' une certaine variable, mettez un nombre négatif et cochez relative. Si ce n'est pas relatif, quel que soit la valeur de la variable, la variable prend la valeur de votre valeur. J'espère que vous avez compris ce point très important. Si je mets set the variable vies to 1 sans cocher relative, le nombre de vies deviendra 1 indépendamment de la valeur de la variable. Si par contre je coche relative, la valeur de la variable augmentera de 1 et dépendra donc de la valeur de la variable.



c)Tester la valeur d'une variable

Souvent vous devez tester la valeur de certaines variables. Par exemple pour savoir si vous avez assez de pièces pour gagner une vie. Il faudra bien sur avoir avant créer une variable nb_de_pieces. Pour la tester, utilisez l'action if a variable has a value, et choisissez entre smaller than, equal to et larger then (respectivement plus petit, égal où plus grand) Si l'équation où l'inéquation est vérifiée, l'action située juste après ce if est executée. Pour effectuer plusieurs actions si une variable à une certaine valeur, utilisez start of a block et end of a block pou délimiter toutes les actions à effectuer.

5)Le GML


Le GML ( ou Game Maker Language) est un langage de programmation proche du langage "c/c++" pour la syntaxe, qui a été créé pour game maker.
Pour utiliser un script gml, il vous faudra utiliser l'action execute a piece of code dans l'onglet control.


a)Les variables en gml


Si vous avez déjà programmé en un autre langage contenant des variables, vous comprendrez très vite comment utiliser les variables en gml.

Pour initialiser une variable il suffit de mettre le nom de la variable suivi d'un signe égal suivi de la valeur à assigner. La syntaxe peut donc ressembler à ceci:
Dans l'evenement create:
vies=5
vous pouvez mettre comme valeur à droite du signe égal aussi bien un nombre réel qu' un nom de variable pour utiliser la valeur de la variable, par exemple:




a=1
b=4
c=5
a=(b+c)
b=a*c
c=a+b




Quelles seront alors les valeurs des variables ?


a sera égal à b+c=4+5=9
b sera égal à a*c=9*5=45
c=a+b=45+9=54


Mais alors, quel est l'équivalent de relative en gml:
Vous l'avez peut-être deviné, il suffit d'écrire vies=vies+1
Mais les programmeurs sont de gros fainéants et ont inventé une syntaxe qui prend moins de place: ils écrivent simplement vies+=1 , cequi ajoutera 1 à la valeur de vies, on peut faire la même chose avec tous les signes,ainsi :
vies-=2 équivaut à vies=vies-2
vies*=3 équivaut à vies=vies*3
vies/=2 équivaut à vies=vies/2

C'est donc très simple de changer la valeur d'une variable mais comment tester sa valeur?

Pour tester la valeur d'une variable, il faudra utiliser la fonction if.

Mais avant cela il faudra connaitre les symboles de test
Voici les symboles de test:
> plus grand que
< plus petit que
>= plus grand ou égal
<= plus petit ou égal
== égal
!= différentij

Voici un exemple de code pour comprendre à quoi cela peut servir:

if (vies<1) //la condition
{
instance_destroy() //ce code entre les crochets n'est que éxécuté si la condition est vraie
high_score_show(score)
game_end()
}

Vous auriez très bien pu mettre vies==0 dans la condition

C'est super ce que tu nous apprend mais on aimerais bien savoir mettre plusieurs conditions dans un if, comment faire alors ?

Très simple il faut utiliser les connecteurs logiques and et or
-and qui veut dire "et" en anglais veut aussi dire "et" en programmation, on a donc
if (vies>1 and vies <5) si les vies sont supérieures à 1 et inférieures à 5.
-or qui veut dire ou :
if (vies==5 or vies==2) si la valeur de vie égal 5 ou égal à 2.
Il faut bien comprendre que le and signifie que les deux éléments sont vrais
alors que le or nécessite au moins un élément (si les deux éléments sont vrais, le test est aussi vérifié) . En francais quand on demande :As tu bu un thé ou un café , on considère que le ou est exclusif et donc que on ne peut que répondre si l'on n'a pris ou bien l'un, ou bien l'autre, si un jour un voleur vous demande l'argent ou la mort, faites attention car comme le ou n'est pas exclusif, il pourra encore vous tuer.

Pour que la syntaxe prenne encore un peu moins de place les programmeurs ont inventés des symboles pour le and et le or qui valent pour presque tous les langages, y compris le gml: && pour le and et || pour le or.

Vous pouvez combiner les and et les or
vous pouvez par exemple écrire:

if (lives==0|| (lives>0&&health==0))
N'oubliez pas de bien ouvrir et fermer les parenthèses aux bons endroits.



a) Les fonctions




Le GML est composé de pleins de fonctions. Chaque fonction est une commande à donner à l'ordinateur une fonction ressemble donc à ca:

fonction(arg1.arg2.arg3)
Chaque fonction a un nom .On ouvre une parenthèse ou l'on écrit le premier argument, un argument est une valeur qu'à besoin la fonction pour s'éxécuter. Chaque argument est séparé par des parenthèses. La fonction instance_create(x,y,obj) , par exemple a comme arguments x: la position en x où l'objet sera créé, l'argument y et l'argument obj ( le nom de l'objet à créer).


1)Les principales fonctions


Les principales fonctions du GML sont les suivantes
instance_create(x,y,obj) Crée un objet obj à la position (x;y)
instance_destroy() détruit l'instance qui execute le script
point_distance(x1,y1,x2,y2) Retourne la distance entre (x1,y1) et (x2,y2).
point_direction(x1,y1,x2,y2) Retourne la direction entre (x1,y1) et (x2,y2).


2) Les fonctions mathématiques


random(x) cette fonction renvoie un nombre aléatoire réel entre 0 et x
abs(x) Retourne la valeur absolue de x
floor(x) Retourne la valeur de x tronqué c'est à dire arrondi vers le bas
sqrt(x) Retourne la racine de x
power(x,n) Retourne x^ n.

6)L'événement draw

L'événement draw est un événement spécial puisqu'il est semblable à l'événement step puisqu'il s'execute à tous les rafraichissements du jeu.
Nous allons étudier cet événement dans un chapitre complet pour comprendre son fonctionnement et ses utilités.
Grâce à l'événent draw, vous pouvez afficher la valeur d'une variable à l'écran ,dessinez des ronds, des carrés de taille,de couleur , d'orientation et de forme différente. Cela vous permet par exemple de dessiner une barre de vie en haut à droite de l'écran. Un point très important est que les objets ayant un événement draw deviennent automatiquement invisible dans le jeu.


a)Dessiner la valeur d' une variable


Pour dessiner la valeur d'une variable, il faudra utiliser la fonction suivante dans un événement draw: draw_text(x,y,str)
x ,y correspond à la position du texte , str correspond au texte à écrire entre "".
Ainsi pour écrire Score à la position de l'objet, utiisez le code ci-dessous:
draw_text(x,y,"Score")

C'est bien mais nous on aimerai bien aussi pourvoir écrire les valeurs des variables à l'écran ! D'accord , c'est très simple il faudra remplacer str par le nom de la variable à dessiner entre les parenthèses de string( ) . N'oubliez pas de déclarer la variable ou vous aurez droit à un vieux message d'erreur. Par exenmple, pour dessiner la valeur de la variable vies, il faudra un code ressemblant à ceci: draw_text(x,y,string(vies))
Oui mais moi je veux écrire le texte Vies : suivi de la valeur de la variable de vies, comment je peux faire ?

Très simple il suffit d'ajouter un + entre chaque terme, par exemple:
draw_text(x,y,"Vies: "+string(vies)+" Score: "+string(score))


b) Tout ceci en couleurs...



Vous voulez dessiner un texte en couleur, je suis désolé mais si vous n'avez pas la version enregistrée ce n'est pas possible avec cette fonction.
Avec la version enregistrée, pour dessiner un texte en couleurs, utilisez la fonction
draw_text_color(x,y,str,couleur1,couleur2,couleur3,couleur4,alpha)
Les trois premiers arguments sont les mêmes que draw_text, les arguments couleur1.couleur2,couleur3,couleur4 déterminent la couleur du texte. Si vous mettez quatre fois la même couleur, le texte sera uniformément de cette couleur. Vous pouvez aussi créer des dégradés en mettant des couleurs différentes. La valeur de alpha est une valeur comprise entre 0 et 1 à 0 le textesera complétement translucide, à 1 il sera opaque, et à 0.5 il sera à moitié transpartent.

Pour utiliser les textes en couleurs sans la version enregistrée, il faudra mettre changer la couleur avec laquelle on dessine, pour cela il faut utiliser la fonction

draw_set_color(couleur)

Le code à écrire pour écrire un texte en rouge sera donc:
draw_set_color(c_red)
draw_text(x,y,"Score")
Malheureusement vous ne pouvez quand meme pas utiliser les dégradés pour dessiner les valeur des vos variables.


Dessiner des triangles,rectangles, barres de vie


Rien de plus simple que de dessiner un triangle.
Utilisez la fonction :
draw_triangle(x1,y1,x2,y2,x3,y3,outline)
ou (x1,y1) ; (x2,y2) ; (x3,y3) sont les arguments de position des trois points et outline signifie si seulement les rebords doivent etre dessinés (1) ou tout le triangle (0).
Mais moi je veux les dessiner en couleur les triangles !
Eh bien regardez ca la fonction draw_triangle_color existe
draw_triangle_color(x1,y1,x2,y2,x3,y3,col1,col2,col3,outline)
Le seul problème,c'est que de nouveau il fautla version enregistrée.

Pour dessiner un rectangle, il faut utiliser le code :
draw_rectangle(x1,y1,x2,y2,outline)
Et maintenant en couleur pour la version enregistrée:
draw_rectangle_color(x1,y1,x2,y2,col1,col2,col3,col4,outline)

Voici un petit lot de consolation pour les personnes tristes ayant la version non-enregistrée : Pour faire des rectamgles colorés vous pouvez utiliser la fonction
draw_healthbar(x1,y1,x2,y2,pourcent,backcol,mincol,maxcol,direction,showback,showborder)
(x1,y1);(x2,y2) étant la position de la barre
pourcent est le pourcentage de remplissage de la barre
backcol étant la couleur du fond, mincol étant la couleur quand la barre est à 0, maxcol quand la barre est à 100. Quand la valeur est entre 0 et 100, la couleur est d'un mélange entre les deux couleurs.
direction est la direction dans laquelle la barre se remplit: à 0 elle se remplit de gauche à droite, à 1, de droite à gauche, à 2, de haut en bas et à 3 de bas en haut.
Si l'argument showback est à 0, la couleur de fond ne sera pas dessinée.
Et enfin l'argument showborder désigne si l'on doit dessiner un rebord noir où non.

Le chapitre sur le draw étant terminé, je considère que j'ai fini la partie 1 de mon grand tutoriel. Le dermier chapitre de cette partie sera un jeu que vous ferez vous même. Bien entendu je vais vous aider.

1)Le gml(2)


Le gml, vous connaissez déjà un peu. Vous devez savoir parfaitement manier les variables, puisque maintenant, nous allons nous lancer dans les boucles. Vous trouverez des boucles dans quasiment tout langage de programmation, alors ce chapitre n'est pas que utile pour game maker. Les boucles vous serviront par exemple à effectuer plusieurs fois de suite la même action jusqu' à ce qu une condition soit vraie. Ainsi vous pourrez aussi effectuer des actions un nombre de fois défini.C'est pour cela que nous allons tout d'abord commencer par présenter la boucle while:


a) La boucle while


Le while, traduit en francais, veut dire "tant que". La syntaxe du while est la suivante:
While(condition)
{
action
action
action
}

Tout d'abord la condition sera testée. Vous pouvez bien entendu utiliser les && et les || :
while(x==1||(x==2 && y==1)
Si la condition est vraie la suite d' actions situées entre crochets est réalisée puis on reteste la condition du while, si elle est fausse, on saute toutes les actions et on recommence à lire après la fin des crochets ,si elle est vraie, on réeffectue ces actions jusquà ce que la condition soit fausse.
Exemple de boucle while:

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

Cette boucle testera d'abord si l'objet ne subit pas de collision au point x,y.
Si il en subit une, les actions sont éxécutées et ses positions sont changées aléatoirement. Ensuite on reteste la condition jusqu'à ce que l objet soit à une place ou il ne subira pas de collision.

Il faudra donc faire attention à mettre une condition qui peut devenir vraie après l'éxécution des actions. Sinon on appelle cela une boucle infinie; la condition est toujours vérifiée et les actions sont éxécutées un nombre infini de fois.

Exemple de boucle infinie (à ne pas tester)

a=1
b=1
while(a==1)
{
b+=1
}

Cette boucle s'effectuera un nombre illimité de fois, et sera donc une boucle infinie. Vous ne pourrez plus quitter cette boucle et le jeu sera bloqué.


b) Le do until


Il s'agit ici simplement d'une variante du while. On effectue d'abord une fois toutes les actions présentes dans la boucle puis ensuite on teste si la condition est vraie, dans ce cas on réeffectue les actions jusquà ce que la condition ne soit plus vérifiée.La syntaxe se présent ainsi:

Do
{
actions
actions
actions
}
until(condition)


c) La boucle for



La boucle for est une boucle while que l'on a simplifié, qui offre plus de simplicité mais moins de possibilités. Elle permet d'éxécuter les actions un nombre préprogrammé de fois.

for (action,test,incrementation)
{
actions
actions
actions
}

La boucle for éxécute tout d'abord une fois l'action.
Si le test est faux, alors on passe toutes les actions et on continue à la fin de la boucles. Si le test est vérifié, on éxécute toutes les actions. Ensuite on éxécute l'incrémentation, puis on reteste l'expression test. Si elle est vraie on éxécute les actions situées entre les crochets puis on éxécute, sinon on saute la boucle.On répète l'opération jusqu'à ce que le test ne soit plus vérifié.



c) La boucle repeat


La boucle repeat est elle encore une boucle for particulière. En effet, celle ci répétera simplement un nombre de fois donné les actions situées dans la boucle.
exemple:

repeat(10)
{
actions
actions
}

2)Le gml(3)



Introduction:


Nous allons dans ce chapitre apprendre à connaitre les fonctions gml les plus importantes. De plus à la fin du chapitre, vous saurez utiliser le with, vous saurez ce que sont les ids,les variables globales,et enfin vous pourrez créez vos propres scripts



a)Les ids et différents instances d’un objet

Vous devez savoir de quelle facon les variables sont stockées dans game maker.Chaque objet peut avoir plusieurs instances dans la room. Chacune de ces instances a des variables qui peuvent être différentes. Par exemple, chaque soldat peut avoir une variable de vie différente. Mais comment game maker sait il à quel instance de quel objet il faut attribuer quelle variable? Eh bien, c est très simple,à chaque instance dans la room, game maker attribue un id (identifiant) différent. Cette id est un nombre supérieur à 100000. Dans l’éditeur de rooms, vous pouvez connaitre l id de nimporte quel objet en posant le curseur sur celui ci. De plus la variable id , qui est une variable que chaque objet a, indique son identifiant. Vous pouvez changer la variable de n’importe quel objet en connaissant son identifiant comme ceci:
100001.x=50 Bien entendu, vous pouvez à la place de devoir écrire 100001 en chiffres utiliser une variable. On aura donc ce code ci dessous qui aura la meme fonction. que le premier
a=100001
a.x=50
De plus la fonction instance_create(x,y,objet) qui crée un objet à la position x,y retourne l’id de l’objet crée. Ainsi, vous l’avez peut être compris, vous pourrez lui assigner quelque chose dès sa création.

Exemple:

balle_id=instance_create(x,y,balle) //Création de l’objet balle, son id est contenu dans balle_id
balle_id.speed=5 //L’objet balle qui vient d’être créé voit sa vitesse à 5
balle_id.direction=direction //et sa direction à la direction du personnage

Et voilà grâce à ceci, je vais vous montrer comment on peut créer des ennemis avec chacun leurs propres barres de vies sur la tête. Je comprends que ca vous paraisse compliqué, mais essayez de chercher, c’est vraiment simple si vous avez compris le fonctionnement des ids.

Voici un petit schéma qui vous aide à savoir quoi programmer



http://www.zshare.net/download/109914560ed97183/
Ce pack contient aussi les exercices pour la prochaine sou section "les variables locales et globales"

Lors d’une collision, la variable other contiendra l’id de l’objet entrant en collision avec l’objet principal, vous pouvez alors écrire: other.x+=1



b)Les variables locales et globales


Toute variable normale est spécifique à chaque objet comme nous venons de le voir. Chaque objet a sa valeur x, sa valeur y,... Parfois, vous voulez créer une seule variable pour tout les objets. Pour cela il faudra utiliser les variables globales. Rien de plus simple, devant le nom de la variable, mettez global. Par exemple, je peux créer la variable global.time qui sera accessible par n’importe quel objet. Voici un exemple qui vous aidera à comprendre cette utilité.

Comme vous pouvez le remarquer, la valeur de cette variable globale est la meme pour toutes les barres de vies. En plus d’être universelles, les variables globales restent durant tout le jeu, et ne sont pas automatiquement réinitialisées à chaque début de room.


c)L instruction with

Maintentant que vous connaissez les id et les variables locales et globales, vous n’aurez aucun problème à comprendre le with(). Il sert à ce que l’on puisse éxécuter des actions avec une autre instance que celle qu’on est en train d’utiliser.Vous pouvez entre les parenthèses,mettre un numéro d id ou une variable qui contient ce numéro

with(100325)
{
instance_destroy()
}


Mais vous pouvez aussi y mettre un nom d’objet. Dans ce cas là l’action sera effectuée pour tous les instances de l’objet, une par une, en commencant par celle qui a la plus petite id.

Vous pouvez alors écrire

with(obj_balle)
{
if x<50 || x>100||y<50||y>100
instance_destroy()
}

Ce script détruira toutes les instances balles qui sont situées dans un carré de 50*50

En plus de cette fonction, vous pourrez aussi utiliser le mot clé all qui désigne tout les objets

with(all)
{
instance_destroy()
}

détruira simplement tout les objets.

4)Les choses à connaitre par coeur:


Il existe plusieurs fonctions dont vous aurez besoin tout le temps, c’est pour cela que je donne ici une petite liste de fonctions expliquées que nul n’est censé ignorer:

Les fonctions:

instance_number(objet) //retourne le nombre d’instances d’un certain objet présents dans la room

show_message(string) // affiche un message string

get_int(string,def) //demande à l’utilisateur un nombre avec comme question string et comme valeur par défault def

get_string(string,def) //meme chose mais pour un string

instance_nearest(x,y,obj) //retourne l id de l’objet le plus proche


Les variables locales

Chaque objet a des variables locales qui sont préprogrammées, vous pouvez avoir la liste complète dans gamemaker en écrivant menu:scripts/show-built-in-variables.Apprendre la liste complète serait abusée, voila pourquoi je vous donne ici une autre liste à aussi connaitre par coeur:

x // Si vous savez pas ca, retournez au chapitre 1
y // De meme
hspeed //La vitesse horizontale, en pixels/step
vspeed //La vitesse verticale, en pixels/step
direction// La direction du mouvement du personnage en degrés, 0 étant vers la droite
id // vous devez savoir ce que c est :
sprite_index // le nom de la sprite en cour
speed // La vitesse en pixels/steps
visible // si l’objet est visible:1 ou non:0
solid // si l’objet est solide:1 ou non:0

image_angle//La rotation de l image (seulement version enregistrée)
image_alpha//La transparence (seulement version enregistrée)

Voila ca devrait suffir pour le moment, je ne veux pas etre sadique

3)L'IA(1)


Nous allons dans ce chapitre juste présenter les fonctions d'IA en 2D vue de dessus et les exliquer.Je n'ai que choisi les fonctions les plus importantes, c'est à dire celles qui vous servirons le plus.


La première fonction est
mp_potential_step(x,y,stepsize,checkall)
Cette fonction fait suivre l'objet qui éxécute la fonction le point (x;y) à une vitesse de stepsize en évitant les objets solides si checkall=0 et tout les objets si checkall=1.

La fonction mp_potential_step_object(x,y,stepsize,obj) est semblable à la fonction précédente sauf que celle ci ne fait que éviter les objets obj.
Et enfin la fonction servant à paramétrer l' IA, peut être même la plus intéressante:
mp_potential_settings(maxrot,rotstep,ahead,onspot)
Cette fonction paramètre les fonctions concernant l'IA en 2D
Commencons par le paramètre ahead: Celui définit le nombre de steps que l'ordi calcule à l'avance pour savoir si un mur est situé sur la trajectoire. Plus ce nombre est grand, et plus l'objet changera vite de direction avant la rencontre contre un mur. Ensuite on a le paramètre rotstep, qui définit la vitesse de rotation maximale de l'objet par step. Si vous faites une intelligence pour jeux de voitures, je vous conseille de garder cette valeur basse pour garder un mouvement fluide est réaliste. On a l'argument maxrot qui définit la direction maximale que l'objet a le droit d'avoir par rapport à la direction de l'objet vers le point (x,y).
Si onspot=1 , et que l'objet est bloqué car il ne peut plus avancer ni tourner, on tourne de la direction de

4)Les jeux de plateforme


Étant donné que les fonctions de collision pour les jeux de plateforme laissent à désirer, nous allons nous mêmes créer nos fonctions pour effectuer les mouvements des objets, notamment à l'aide de boucles.


a)La gravite


Tout d'abord commencons par définir ce qu'est la gravité: La gravité c'est une force qui nous tire constamment vers le bas,et qui influe donc sur notre vitesse si nous sommes sur le sol, la force de réaction de celui ci est égale à la force de gravité et de sens différent. Grâce à ces définitions nous allons pouvoir ajouter de la gravité. Il faudra donc créer une variable gravite (attention ne pas mettre d'accent) qui ajoutera constamment de la vitesse à la valeur de la vitesse verticale, sauf si l'objet est au sol. On appeller la vitesse verticale vit_y. Nous aurons donc pour l'instant un script qui pourrait ressembler à ca:
Pour faire bouger l'objet en fonction des valeurs vit_y et vit_x, il faudra ajouter ces valeur aux valeurs actuelles de x.

create:
gravite=0.5


step:

vit_y+=gravite
x+=vit_x
y+=vit_y


Mais bien sur, le sol existe et sa réaction est toujours assez forte pour pouvoir arrêter l'objet.

on crée donc un objet sol et on change le script de la gravité qui devrait maintenant ressembler à ceci. Voici la fonction place_meeting(x,y,obj) qui teste si il y a une collision avec obj à la position x,y.

create:
gravite=0.5


end step:

vitessev+=gravite

bougev+=vitessev
while(bougev>1 || bougev<-1)
{
if bougev>0 //si tu dois aller en bas
{
if (!place_meeting(x,y+1,bloc)) //Si il y a pas d’objet en bas
{
y+=1
bougev-=1 //alors bouge
}
else
{
bougev=0 //sinon stop tout
vitessev=0
grav=0
}
}

if bougev<0 // si tu dois aller en haut
{
if (!place_meeting(x,y-1,bloc))//si il y a pas d’objet en haut
{
y-=1 // va en haut
bougev+=1
}
else //sinon
{
bougev=0 //stoppe le tout
vitessev=0
grav=0
}
}
}


b)Les mouvements


Maintenant que nous avons programmés la gravité, il nous faut programmer les mouvement horizontaux, pour cela, créons


bougeh+=vitesseh
while(bougeh>1 || bougeh<-1)
{
if bougeh>0 // si tu dois aller à droite
{
if (!place_meeting(x+1,y,bloc)) //si il y a pas d objet a droite
{
x+=1 //bouge à droite
bougeh-=1
}
else //sinon
{
bougeh=0 //ne bouge plus
vitesseh=0
}
}

if bougeh<0 // si tu dois aller à gauche
{
if (!place_meeting(x-1,y,bloc))// si il y a pas d’objet à gauche
{
x-=1 //bouge à gauche
bougeh+=1
}
else //sinon
{
bougeh=0 //stoppe
vitesseh=0
}
}
}


Voici le moteur de mouvement au point, vous n’aurez pas de ces p****** de bugs de collision de game maker et votre personnage ne se coincera dans aucun cas.
Maintenant il nous faut donc plus que règler la gravité

donc aussi dans step, avant que le personnage éxécute le script de mouvement:

if place_meeting(x,y+1,bloc) //si il y a un bloc en dessous
gravite=0 //la gravité=0 puisque annulée
else //sinon
gravite=0.5 //la gravité=0.5

vitessev+=gravite //En plus, la vitesse verticale augmente
à chaque step de la force de la gravité
(puisque celle ci n’est que verticale)



Ca c est fait. Il ne nous reste plus que les mouvements des personnages quand le joueur appuie sur les touches (le plus important mais aussi le plus simple)
dans keyboard_left vitesseh=-5
dans keyboard_right vitesseh=5
dans keyboard_up :

if place_meeting(x,y+1,bloc) //si il y a un bloc en dessous
vitessev=-12 //saute

Et voila, vous pouvez tester le tout ici, et changez les valeurs de la gravité, de la vitesse du personnage et de la vitesse du saut.

Maintenant qu’on a programmé tout ce qui concerne les mouvements du personnage, on va continuer en ajoutant des ennemis. Vous aimeriez faire des ennemis qui vous tuent si vous venez par un des cotés, mais si vous leur sauter dessus, c’est eux qui meurent ?
C’est très simple. Créez tout d’abord un objet ennemi.Maintenant faisons le bouger, Pour les mouvements vous pouvez reprendre le code du personnage controlable. Ensuite son intelligence. Sa seule intelligence sera d’aller à gauche quand il rencontrera un bloc à sa droite et vice-versa.

Pour cela dans step

if place_meeting(x+1,y,bloc) //si il y a un bloc à sa droite
vitesseh=-5 //Bouge vers la gauche

if place_meeting(x-1,y,bloc) //Si il y a un bloc à sa droite
vitesseh=5 //Bouge vers la droite

Voila notre petit ennemi bouge, il ne suffit que de lui donner une vitesse horizontale initiale, donc, dans create:
vitessseh=5

Exemple disponible ici http://www.zshare.net/download/10991462df0bf64b/
Ce pack contient tous les exemples nécessaires pour le chapitre sur les jeux de plateforme


c)Ajouts d'ennemis


Lors d’un événement de collision, le mot other signifie l’autre objet qui entre en collision.
Pour détruire l’autre objet de la collision, il faut donc écrire:

with(other) instance_destroy()


Maintenant je vais utiliser ca pour tuer l’ennemi, le code ressemblera à ceci:

if vitessev>5 //si ma vitesse verticale est supérieure à 5 ( autrement dit si je tombe)
with(other)instance_destroy() //détruit l'autre objet, c est à dire l'ennemi en question
else //sinon (si je ne tombe pas)
instance_destroy() //détruit l'objet joueur


Et voilà nous avons créés notre premier jeu de plateforme, j’éspère que vous avez compris la logique de la gravité.Je sais bien que le code est bien plus dur que ce que l’on pourrait faire avec les fonctions de collisions basiques de game maker, mais je voulais vous donner un moteur de jeu de plateforme qui ne fasse jamais de bugs de collisions et j’éspère que vous en êtes satisfait.
De toute facon, ce n’est pas grave si vous ne comprenez pas tout ce qui est codé dans le step.
Si vous ne comprenez pas tout, relisez ce chapitre, ou revenez dessus plus tard, jusqu’à ce que vous comprenez.

5)Les views



Les views ? Vous devez vous demander ce que cela signifie. Souvent vous voulez créer un jeu avec des niveaux longs qui prennent plus de place que l’écran. Dans ce cas là, vous devrez créer une sorte de caméra qui suit l’objet principal pour que vous puissiez vous ballader partout en gardant toujours votre personnage sur la vue. Nous allons donc apprendre dans ce chapitre, à inclure des views. Créez tout d'abord un objet que l'on peut controler au clavier et changez le background du niveau en un background qui ne se répéte pas. Testez. On remarque que le personnage peut sortir de l'écran. Nous allons maintenant remédier à ce problème.
pack disponible ici http://edi9999.ifrance.com/packviews.rar
voir l exemple sansview du pack

a)Initialisation des views





Pour que les views puissent fonctionner, il va falloir ouvrir la room correspondant au niveau dans lequel vous voulez utiliser des views, et, dans l'onglet views,cocher enable the use of views, choisissez la view0 et cochez aussi visible when room starts. Ensuite choisissez comme objet pour object following l'objet que vous avez crée. Cela aura comme conséquence que la caméra suivra l'objet que vous choisissez. Pour que les views soient utiles, il vous faut une room qui est plus grande que la taille de la view. Pour cela, dans l'onglet settings, changez la width a 6400 et la height a 4800 par exemple. Vous pouvez maintenant tester ceci avec les views, vous pouvez voir que maintenant, quand le personnage sortira de l'écran, la caméra se chargera de le suivre automatiquement et vous verrez ce personnage même s'il sort de l'écran.
Voir view1 du pack


b)Parame*tre des views





Vous pouvez changer certains paramètres des views. Pour cela réouvrez la room dans laquelle vous voulez changer les paramètres. Vous avez trois grandes cases: view in room, port on screen et object following. Commencons tout d'abord par étudier la case view in room. C'est ce que la caméra va montrer au joueur dans la room. Vous pouvez changer la largeur et la hauteur, mais aussi à quelle position la view sera au début du niveau. Dans la case Port on Screen, vous pouvez régler ou la view sera visible sur l'écran. Vous pouvez aussi bien changer la hauteur, la largeur ou la position de la vue dans la room. La dernière case, object following, prend en compte plusieurs paramètres. D'abord vous pouvez changer l'objet que la caméra doit suivre. Ensuite vous pouvez changer hbor et vbor, qui désignent des bords verticaux et horizontaux, à partir desquels la caméra bouge quand l'objet à suivre est en dehors de la view. Par exemple si vous choisissez vbor=60 et hbor=60, quand l'objet se situera à 60 pixels d'un des bords, la caméra se replacera. Vous pouvez en plus changer la vitesse horizontale et verticale de la caméra quand l'objet dépasse les bords horizontaux ou verticaux. Une valeur de -1 pour les vitesses fera que la vitesse de la camera sera instantanée. Testez plusieurs possibilités pour comprendre mieux le fonctionnement de ces paramètres.
voir l exemple view2 du pack


c)Paramêtrage en GML





Plusieurs fonctions pour changer les options des views existent en gml.
view_xview[0..7] La position x de la caméra
view_yview[0..7] La position y de la caméra
view_wview[0..7] La largeur de la vue de la caméra
view_hview[0..7] La hauteur de la vue de la caméra
view_xport[0..7] La position x de la vue sur l'écran
view_yport[0..7] La position y de la vue sur l'écran
view_wport[0..7] La largeur de la vue sur l'écran
view_hport[0..7] La hauteur de la vue sur l'écran
view_hborder[0..7] Bord horizontal (en pixels).
view_vborder[0..7] Bord vertical (en pixels).
view_hspeed[0..7] Vitesse horizontale maximale.
view_vspeed[0..7] Vitesse verticale maximale.
view_object[0..7] nom de l'objet à suivre.
Bien sur, remplacez ce qu'il y a dans les crochets par un des chiffres de 0 à 7 pour utiliser une des 8 views.

Exercice

Essayez de créer un autre objet que l'on controle avec les touches du clavier w,a,s,d. Et de faire que, quand le joueur appuye sur espace,la caméra suit l'autre objet.
correction de l'exercice: exemple view3 du pack


d)Plusieurs views pour des jeux multijoueurs




Vous pouvez aussi créer des jeux multijoueurs sur un ordinateur avec plusieurs views qui suivent chacun un autre objet.
exemple disponible dans le pack: multiview

6)Les particules




Attention: Vous devez avoir la version enregistrée de gamemaker pour pouvoir utiliser les particules. Si vous ne l'avez pas, passez au chapitre suivant.
Vous voulez créer de jolis effets dans vos jeux ? Vous avez peut etre essayés de créer des effets en créant plusieurs objets d'un mème type. Mais vous avez surement remarqués que ces objets pompent énormément de ram sur votre ordi. Mark Overmarks, le créateur de gamemaker, a pensé à créer un type d'objet simplifié qui n'a qu'une fonction de décor dans le jeu et qui ne réagit à aucun événement. Ce type d'objet est largement simplifié, et ne contient donc pas les événements des objets normaux.


a)Initialisation du système de particules





Avant de commencer à utiliser les particules, vous devrez simplement creer un système de particules. Pour cela, utilisez la fonction part_system_create(). Elle retourne l'id du système ainsi crée. Gardez cet identifiant dans une variable, car il vous sera nécessaire pour toute fonction utilisant des particules. Après avoir utiliser le système de particules, vous pouvez le détruire avec la fonction part_system_destroy(ind) qui prend en valeur l' id du système a détruire.


b)Création de différents types de particules





Maintenant que nous avons crée un système de particule, nous pouvons créer différents types de particules. Chaque type de particule pourra avoir sa forme, couleur, taille, vitesse, gravité spécifique. Pour cela il existe une multitude de fonctions que nous allons étudier.

part_type_create() Cette fonction crée un type de particules et retourne son index
part_type_shape(ind,shape) Cette fonction change la forme de la particule par shape. Les formes de particules par défault sont les suivantes:
pt_shape_pixel
pt_shape_disk
pt_shape_square
pt_shape_line
pt_shape_star
pt_shape_circle
pt_shape_ring
pt_shape_sphere
pt_shape_flare
pt_shape_spark
pt_shape_explosion
pt_shape_cloud
pt_shape_smoke
pt_shape_snow
Vous pouvez aussi mettre comme forme de la particule une image sous forme de sprite:
part_type_sprite(ind,sprite,animat,stretch,random) ind: index du type de particule
sprite: nom du sprite
animat: si l image doit être animée ou non
stretch: désigne si l'image est agrandie durant la vie de la particule
random: si la première image de l'animation doit être aléatoire ou non
part_type_size(ind,size_min,size_max,size_incr,size_wiggle) ind est l index du type, la taille de la particule sera comprise entre size_min et size_max aléatoirement pour chaque particule du type.size_incr désigne l augmentation de la taille de la particule entre chaque step.Et enfin size_wiggle désigne le clignotement de la particule. Par exemple, vous pouvez faire un effet d'étoile scintillante avec un size_wiggle.
part_type_color3(ind,color1,color2,color3) designe trois couleurs color1,color2 et color3 que doit avoir la particule ind en fonction du temps
part_type_alpha3(ind,alpha1,alpha2,alpha3) designe trois valeurs alphas que doit avoir la particule en fonction du temps
part_type_life(ind,life_min,life_max) le temps de vie en steps de la particule est une valeur comprise entre life_min et life_max. Après ce temps, la particule est dètruite.
Vous pouvez choisir de générer un certains nombres d'un certain type de particules à la mort de la particule.
part_type_death(ind,death_number,death_type) ind désigne l index de la particule qui, quand elle meurt, créera un nombre death_number de particules de type death_type.
Grace a cette fonction, vous pouvez créer par exemple un feu d'artifice.

Enfin, on a aussi des options pour la vitesse, la direction et la gravité des particules.
Ces trois fonctions sont:

part_type_speed(ind,speed_min,speed_max,speed_incr,speed_wiggle)
part_type_direction(ind,dir_min,dir_max,dir_incr,dir_wiggle)
part_type_gravity(ind,grav_amount,grav_dir)


Maintentant qu'on a créé un certain type de particule, on va voir comment créer un certain nombre d'un certain type de particules à une certaine position.
part_particles_create(ind,x,y,parttype,number) ou index est l'index du système, x et y la position ou seront crées un nombre number de type de particules parttype.


c)Les emetteurs de particules





Pour cela, il faut commencer paar créer un émetteur. La fonction correspondante est:
part_emitter_create(ps) la fonction retourne l index de l'emetteur, il est donc à stocker dans une variable.
Il faut ensuite délimiter un endroit de création des particules crées par l'émetteur:
part_emitter_region(ps,ind,xmin,xmax,ymin,ymax,shape,distribution) ou xmin,xmax,ymin,ymax sont le rectangle dans lequel la forme de l'émetteur est comprise, shape est une valeur de forme qui peut etre une des suivantes:
ps_shape_rectangle
ps_shape_ellipse
ps_shape_diamond
ps_shape_line
et distribution est le type de distribution:
ps_distr_linear qui créera aléatoirement partout des particules
ps_distr_gaussian qui créera plus de particules au centre de la forme que aux bords de la forme