[Apprendre le GML] 1 - Initiation

Apprendre le GML

Initiation

Sommaire

Les fonctions
Le temps
L'affichage
Les variables
Les chaines de caractères
Scripts
Paramètres
Le mot clé 'return'
Variables locales a un bloc d'instruction

1. Fonctions

Nous allons voir ici une chose très importante : les fonctions.
Les fonctions servent a exécuter des taches sans qu'on ai rien a faire, mis part les appeler et en leur passant facultativement des paramètres.
Une fonction ce présente de cette manière :

nom_fonction(paramètre, paramètre, ...)

Bien sur les paramètres sont facultatif et il n'y en auras pas toujours, mais une fonction sans paramètres est moins intéressante car le principe même d'une fonction, comme son nom l'indique, est d'effectuer une tache en fonction de son/ses paramètre(s).

Utiliser une fonction est très simple du moment qu'on sait a quoi elle sert, et que l'on connais l'utilité de chacun de ses paramètres.
Par exemple pour afficher du texte a l'écran il y a la fonction draw_text (qui signifie dessiner texte en français).
draw_text possède 3 paramètres : les deux premiers sont les coordonnées x et y ou l'on va écrire notre texte, et le troisième le texte a afficher.
Par exemple draw_text(50,50,"Hello World !") afficheras Hello World ! aux coordonnées (50,50). (Cela n'est vrai que si la fonction est utilisée dans l'event draw)

Il y a deux types de fonctions sous GM :
-Les fonctions qui effectuent une tache et renvoient un résultat.
-Les fonctions qui effectuent une tache sans renvoyer de résultat.

2. Le temps

Dans GM , la gestion du temps est faite automatiquement, donc une question nous viens souvent a l'esprit, combien dure un step ?
Le fps peut être changé dans chaque room dans l'onglet setting : speed
Le fps est le nombre d'image par secondes, donc la durée d'un step
varie en fonction de la room_speed qui est le fps.

un step = 1 / fps

Pour un fps de 1, un step dure une seconde. Pour un fps de 30 il dure ~33ms.
Et pour 60, 16ms.
Au moins 50 fps est conseillé pour un jeu bien fluide. Par contre il faudra faire attention a ne pas utiliser trop de performances afin de ne pas faire
descendre le fps trop sous cette valeur, au risque d'avoir une mauvaise impression de lag.
Bien sur un jeu fait avec GM qui descend trop en fps ce n'est pas normal, c'est soit qu'il a été mal codé/optimisé, soit que le joueur a un matériel vraiment très vieux...

3. L'affichage

Maintenant que nous savons a quoi correspond un step, il faut savoir comment est géré l'affichage dans GM.
En fait tout dépend d'une case cochée par défaut dans les rooms, qui se situe dans l'onglet backgrounds : 'draw background color'

Si elle est cochée, a chaque step la fenetre seras remplie de la couleur choisie, et tout ce qui a été dessiné en dehors de l'event DRAW seras effacé.
Si l'event draw sert a l'affichage, c'est qu'il est exécuté de façon a ce que les pixels de la fenêtres soient effacés avant, de ce fait on vois toujours ce qui a été dessiné dans cet event.

Si 'draw background color' n'est pas coché, alors l'event draw deviens inutile, car les autre event comme create, step, begin step, etc... permettrons d'utiliser les fonctions de dessin sans aucun souci.

A vous de voir si vous préférez développer votre jeu avec 'draw background color' cochée ou non, les deux manières étant totalement différentes.

Exemples de fonctions (a placer dans l'event Draw)

Citation :: draw_text(16, 16, "Appuyez sur espace")
draw_text(16, 32, keyboard_check(vk_space))
draw_rectangle_color(16, 64, 128, 160, c_red, c_green, c_blue, c_yellow, 0)

4. Les variables

Dans GM il est possible de créer et utiliser des variables.
Ce sont des emplacements de mémoires capable de stocker des informations telles que des nombres ou des chaines de caractères.

Pour assigner une variable, la créer, il faut faire :
<variable> = <expression>

exemple :

Citation :: vie = 20 // Exemple d'affectation de variable

Il existe deux types de variables :
-Les variables locales
-Les variables globales

Une variable locale est propre a l'objet ou elle a été crée, tandis qu'une variable globale peut être utilisée par tous les objets

exemple :

Citation :: ma_variable = 18 //Une variable locale
global.variable = 25 //Une variable globale

Les variables globales sont a éviter pour écarter les conflits et erreurs, mais dans un petit jeu simple elles peuvent faciliter le fonctionnement
du programme.

Il existe par défaut certaines variables globales comme score, et lives (ou l'on a pas besoin de mettre le global devant).
Il y a aussi de nombreuses variables locales, comme health par exemple.

5. Les chaines de caractères

Nous avons vu comment créer une variable, mais il y a une chose importante a savoir, c'est qu'il est possible de leurs affecter autre chose que de simples nombres.
Une variable peut contenir deux type de donnée : nombre ou chaine de caractère souvent appelé string.
Une chaine string s'écrit soit entre " , soit entre '. C'est une suite de caractères pouvant être utilisé pour manipuler du texte.

exemple d'affectation d'un string a une variable :

Citation :: str = "hello world"

Il est possible d'ajouter une chaine de caractère a une autre avec l'opérateur +.
Par exemple "hello" + "world" donne la chaine "helloworld"

Par contre il n'est pas possible d'ajouter a une variable de type string un nombre.
Ceci déclencheras une erreur : "he" + 11 + "o"
Pour contourner ce problème il existe une fonction qui permet de convertir un nombre en chaine de caractères.
C'est la fonction string : "he" + string(11) + "o" seras alors utilisable sans poser de problèmes.
La fonction réal permet elle de passer d'une chaine a un nombre : real("1234") donne 1234.

Infos supplémentaires :
Chaque variable non string dans GM est du type double. C'est un type que l'on retrouve dans de nombreux langages est qui a les caractéristiques suivantes :
-Prend 8 octets de mémoire, soit 64 bits
-Permet de stocker des nombres flottants (a virgule) de 10 puissance -308 à 10 puissance 308.
Attention cependant, plus le nombre est grand dans les négatifs ou positifs, moins les calculs seront précis.

Les variables string quand a elles prennent en mémoire un octet par caractère et ne peuvent pas contenir plus de 32 000 caractères, ce qui fait 32ko quand elles sont au max.

6. Les scripts

Il est possible de créer ses propres fonctions sous GM (et encore heureux, sinon nous serions bien limités) a l'aide des scripts.
Les scripts se situent dans la colonne de gauche de l'interface GM, entre Fonts et Paths.
Vous pouvez créer un script avec le raccourci Ctrl+Alt+C ou avec clic droit sur le dossier scripts, add a script.

La première chose quand on crée un script est de lui donner un nom pour l'appel de la fonction.
Par exemple si vous l'appelez dessiner_etoile vous pourrez alors ensuite l'utiliser comme tout autre fonction de GM.
Il faudra cependant faire attention a ne pas utiliser une syntaxe biscornue pour le nom du script :
pas d'accents, pas de caractères spéciaux autres que _ et pas d'espaces (utilisez les noms des fonctions de GM comme modèle).

Voici un exemple de script sans paramètre :

afficher_hello

Citation :: draw_text(room_width/2, room_height/2, "HELLO")

Vous pouvez maintenant utiliser cette fonction dans le Draw event :

Citation :: afficher_hello()

7. Les paramètres (scripts)

Bon nous savons créer des fonctions sans paramètres mais ce n'est pas super utile, passons donc a l'étape suivante.

Sous GM il est possible de récupérer le n ième paramètre avec une variable locale : argumentn
De ce fait vous pourrez récupérer le premier paramètre avec argument0, le second avec argument1, et ainsi de suite.
Il est possible de récupérer un paramètre jusqu'a argument15.

Voici un exemple de script qui affiche un certain texte au coordonnées de la souris :
texte_souris

Citation :: draw_text(mouse_x, mouse_y, argument0)

Vous pouvez l'utiliser de cette manière dans draw :

Citation :: texte_souris("HELLO WORLD")

8. Le mot clé 'return'

Bon c'est bien beau tout ça mais maintenant si je veux faire une fonction qui me donne un résultat, comme la fonction somme par exemple je fait comment ?
Et bien la il va falloir utiliser un mot clé de GM dans notre script : return (qui signifie renvoyer).

Lorsque vous utilisez return, vous arrêtez votre fonction pour renvoyer une variable.

Voici notre fonction somme :
somme

Citation :: return argument0 + argument1 // additionne les deux paramètres et renvoie la valeur obtenue

Et un exemple de son utilisation (dans draw)

Citation :: draw_text(16, 16, "somme des coordonnées de la souris :" + string( somme(mouse_x, mouse_y) ))

Variables locales a un bloc d'instruction

Il se peut maintenant, que pour une raison ou une autre, qu'une variable soit détruite après création.
Il n'y a pas de fonction pour détruire une variable, ni même de mot clé, mais il est possible de créer une variable localement a un bloc d'instruction. De ce fait a la fin du bloc d'instruction la variable seras automatiquement détruite. Les scripts et les 'piece of code' sont considérés comme des blocs a part entière.

Voici le mot clé : var
Utilisation :
var nomvariable1, nomvariable2, ..., nomvariablex;
Pour une fois il ne faudra pas oublier le ; a la fin de l'instruction.

Ce mot clé est très utilisé dans les scripts, donc fonctions.
Imaginez que vous créez une fonction, avec une variable i qui serviras a faire une boucle for.
Maintenant vous utilisez cette fonction dans une boucle for qui utilise aussi une variable i, ben la c'est la cata.
Votre variable va être modifié par les deux boucles, et ça ne se finiras jamais (ce qu'on appelle boucle infinie).
Pour résoudre ce problème, il suffiras de mettre var i; a la première ligne du script et le tour seras joué.

Exemple :

Citation :: compteur = 0
for(i=0; i<16; i+=1)
{
    var i;
    i = 5
    draw_text(16, 16, i)
    compteur += 1
}
draw_text(16, 32, compteur)

Passons maintenant aux conditions dans le prochain chapitre

» Initiation au GML
» Initiation à la programmation et au langage C.
» [Tutoriels] Apprendre le GML
» [Apprendre le GML] 2 - Condition
» où apprendre le GML