Comme tout langage de programmation, GML utilise des variables comme unité de base pour la plupart des opérations de programmation. Les variables sont utilisées pour stocker des informations dans la mémoire des périphériques pour une utilisation ultérieure (ou instantanée), et un nom leur est attribué afin que vous puissiez les consulter dans les fonctions et les scripts. Une variable dans GML peut stocker de nombreux types de données différents, comme un nombre réel (comme 100, 2.456575, -56 etc...), une chaîne (comme "Hello world!"), Un entier (comme 1, 556, -7 ), ou un booléen ( true ou false ).
Une variable est quelque chose que nous utilisons pour stocker une valeur à utiliser dans une ou plusieurs opérations ou fonctions. Pensez à "pi", par exemple... c'est une variable du monde réel qui détient la valeur 3.14159265 (etc...). Pourquoi? Eh bien, il est beaucoup plus facile de dire à quelqu'un "pi" que "trois points un quatre un cinq neuf deux six cinq"! Ainsi, nommer les choses rend la vie beaucoup plus simple et cela signifie aussi que si la valeur de cette variable ne changera jamais, nous ne devons pas changer le numéro partout comme le nom de la variable est toujours le même. En GML, une variable a un nom qui doit commencer par une lettre et ne peut contenir que des lettres, des chiffres et le symbole de soulignement '_' d'une longueur maximale de 64 symboles. Donc, les variables valides sont des choses comme fish, foo_bar, num1, et les variables invalides seraient 6fish, foo bar, ou *num.
Maintenant, dans de nombreux langages de programmation, vous devez "déclarer" une variable avant de pouvoir l'utiliser. Cela signifie essentiellement que vous dites à l'ordinateur le nom que vous souhaitez utiliser afin qu'il puisse attribuer une place en mémoire pour stocker la valeur que vous décidez de conserver dans cette variable. Avec GML, ce n'est pas toujours nécessaire car cela dépend de la portée de la variable. Il existe quatre catégories de variables principales lorsque vous programmez avec GameMaker Studio 2 et que chacune a sa propre portée (qui peut être considérée comme sa zone d'opération, ou portée). Ces variables et leur portée sont décrites ci-dessous:
Une variable d'instance est créée dans une instance d'un objet et est considérée comme unique pour cette instance: plusieurs instances du même objet peuvent avoir la même variable, mais chaque variable peut contenir une valeur différente car elles sont uniques à chaque instance. Mais comment est créée une variable d'instance? Eh bien, vous créez de nouvelles variables simplement en leur affectant une valeur comme indiqué dans ce petit exemple:
potions = 12;
life = 100;
name = "Jock MacSweeney";
strength = 5.5;
armour = -2;Comme vous pouvez le voir, il suffit de donner le nom et ensuite une valeur (numérique ou une chaîne) pour définir cette variable et l'avoir prêt à l'emploi dans une instance de l'objet que vous êtes en train de coder. Ces variables peuvent ensuite être utilisées et modifiées de plusieurs manières depuis l'instance, par exemple ce code pourrait être dans un événement de collision et utilisé pour prendre un montant de la variable "life":
life -= 5 + armour;
Si "life" est à 100, il aura maintenant une valeur de 97 (100 - (5 + -2) = 97). Maintenant, c'est un exemple simple, et vous pourriez remplacer "armure" pour la valeur réelle de -2, mais que se passe-t-il si vous utilisez cette valeur à plusieurs endroits et décidez ensuite de la changer? Vous auriez à passer par TOUS votre code et changer tous les -2 à quelle que soit la nouvelle valeur, ce qui prend du temps et très sujet aux erreurs! Mais si vous utilisez une variable, tout ce que vous avez à faire est de lui attribuer une nouvelle valeur et le code utilisera automatiquement cette nouvelle valeur à partir de ce moment, rendant les choses beaucoup plus flexibles et plus faciles à corriger en cas de problème. Il convient également de noter que même si une valeur ne va pas changer, il est beaucoup plus facile de se souvenir de ce qu'une variable appelée «vie» signifie plutôt que de simplement regarder un nombre.
GameMaker Studio 2 possède également une collection de variables d'instance "intégrées", vous devez donc en être conscient car vous pouvez nommer l'une de vos propres variables d'instance ou bien avoir votre propre variable globale avec le même nom et vous demander pourquoi obtenez des erreurs. Ils sont faciles à repérer, car ils sont affichés dans une couleur différente dans l'éditeur de code et apparaissent également dans la barre de saisie automatique en bas.
Il y a quelques fonctions conçues pour vous aider lorsque vous manipulez des variables d'instance (principalement pour les scripts de compatibilité pour les projets importés et le code pour les actions de glisser-déposer, mais ils peuvent aussi être utilisés ailleurs):
Une variable locale est celle que nous créons pour un événement spécifique seulement, puis rejetons lorsque l' événement est terminé (la seule exception à cela est dans les ressources de script, où un var la variable déclarée est locale au script et ensuite rejetée). Pourquoi aurions-nous besoin d'eux? Eh bien, les variables occupent de l'espace en mémoire et il se peut que nous ne les utilisions que pour une opération ou une fonction, auquel cas nous n'avons besoin de l'avoir en mémoire que pendant une courte période. Cela permet de garder votre base de code propre et bien rangé ainsi que de garder l'espace mémoire optimisé pour les choses qui en ont vraiment besoin. Pour déclarer une variable locale, nous utilisons la fonction var comme ça:
var i, num, str;
i = 0;
num = 24.5;
str = "Hi there!";Toutes les variables créées ci-dessus seront "oubliées" (c'est-à-dire: supprimées de la mémoire) à la fin de l'événement (ou du script) dans lequel elles ont été créées. Vous devez faire attention que le nom que vous donnez var les variables déclarées ne coïncident pas avec une autre variable d'instance dans l'objet exécutant le code, et assurez-vous également que vous n'avez pas l'intention d'utiliser la valeur stockée dans cette variable en dehors de l'événement déclarée. Ces variables sont beaucoup utilisées dans les programmes, en particulier dans les boucles pour compter les itérations, ou lors de l'utilisation d'une valeur plusieurs fois en une opération qui ne sera pas répétée. Voici un autre couple d'exemples:
var i = 0;
repeat (10)
{
inventory[i] = 0;
i+=1;
}Le code ci-dessus crée une variable locale appelée "i" et la définit à 0, tous dans la même ligne. Notez que dans les versions précédentes de GameMaker vous GameMaker d' GameMaker déclarer vos variables locales, puis leur attribuer des valeurs, mais dans cette version, vous pouvez les déclarer et leur attribuer une valeur en même temps. Le code ci-dessus utilise ensuite cette variable pour initialiser un tableau. Comme la variable "i" ne va pas être utilisée pour d'autres fonctions dans l'instance autre que celle-ci, elle peut avoir une portée locale. Voici un autre exemple:
var xx,yy;
xx = x - 32 +irandom(64);
yy = y - 32 +irandom(64);
instance_create_layer(xx, yy, "Effects", obj_blood);Ici, nous avons utilisé les variables locales pour stocker des coordonnées aléatoires que nous utilisons ensuite pour créer une instance. Dans cet exemple, vous pouvez voir qu'il n'est pas strictement nécessaire que nous utilisions ces variables, mais pour des raisons de lisibilité et de facilité d'utilisation, nous le faisons. Il est BEAUCOUP plus clair et évident de ce que nous faisons ici que si nous utilisions ce code:
instance_create_layer(x - 32 + irandom(64), y - 32 + irandom(64), "Effects", obj_guts);
Une autre chose à propos de var Les variables déclarées doivent être notées... Comme elles sont uniques à l'événement qui les exécute, elles peuvent aussi être utilisées dans d'autres instances via le code! Cela signifie que nous pouvons utiliser ces variables pour définir et modifier des choses dans d'autres instances en utilisant la construction "with ()" (il y a une section à ce sujet dans la section GML Overview du manuel). Le code lui-même ressemblerait à ceci:
var num = instance_number(obj_Enemy);
with (obj_Enemy)
{
if num>10 instance_destroy();
}Le code ci-dessus fonctionne parce que le var La variable déclarée est locale à l' événement (ou au script) dans lequel elle est contenue, pas à l'instance, ni au monde du jeu, et peut donc être utilisée dans n'importe quelle fonction d'un objet tant qu'elle se trouve dans le même bloc de code.
Une description de base d'une variable globale est celle qui, une fois déclarée, n'appartient à aucune instance en particulier et est accessible à tous. Tout comme les variables locales, les variables globales doivent être déclarées, mais contrairement à une variable locale, une variable globale reste en mémoire jusqu'à la fin de la partie. Ainsi, vous pouvez créer une variable globale pour suivre (par exemple) le nombre de puces que possède le joueur, puis mettre à jour cette variable à différents moments de la partie. Une variable globale n'appartient à aucune instance spécifique et peut être consultée, modifiée et utilisée par toutes les instances à tout moment, mais toute modification apportée à la variable est "globale", en ce sens que toutes les instances utilisant la variable seront affectées par le changement. Jetons un coup d'oeil à un exemple:
global.food = 5;
Nous déclarons la variable "food" en écrivant d'abord "global" puis "." pour indiquer à GameMaker Studio 2 que cette variable est maintenant globale. Nous devrons utiliser cette méthode à partir de maintenant chaque fois que nous devrons accéder ou modifier cette variable de quelque façon que ce soit. Nous avons donc créé une nouvelle variable appelée "nourriture" et nous l'avons déclarée globale. Maintenant, n'importe quelle instance peut utiliser et modifier cette variable de n'importe quelle façon et toutes les autres instances "verront" cela. Par exemple, nous pourrions avoir un objet alimentaire différent avec lequel le joueur entre en collision et dans l'événement de collision que nous avons:
global.food +=1;
Nous avons également un autre objet qui dessine cette valeur comme ceci:
draw_text(32, 32, "food = " + string(global.food));
Avec les variables globales, nous pouvons changer les valeurs et voir ces changements reflétés dans toutes les instances des objets qui font référence à cette variable. Comme pour les variables locales, vous devez prendre soin de ne pas nommer vos variables globales de la même façon que les variables d'instance, car cela pourrait vous causer des problèmes et faire glisser des bugs dans vos jeux en raison du chevauchement variable. En général, vous devriez avoir un seul script ou objet qui déclare toutes vos variables globales au tout début du jeu (par exemple, dans l'événement Room Start), afin qu'elles soient initialisées et prêtes à être utilisées par n'importe quelle instance, et cela aussi vous donne un endroit pratique pour revenir en arrière et référence si vous avez besoin de vérifier un nom de variable.
GameMaker Studio 2 dispose également d'une collection de variables globales "intégrées", vous devez donc les connaître, car vous pouvez nommer l'une de vos variables d'instance de la même manière ou souhaiter avoir votre propre variable globale avec le même nom et vous demander pourquoi obtenir des erreurs! Ils sont faciles à repérer, car ils sont affichés dans une couleur différente dans l'éditeur de code et apparaissent également dans la barre de saisie automatique en bas. La majorité des variables globales intégrées sont très spécifiques et ne seront utilisées que rarement - et sont listées dans les sections appropriées du manuel - mais il y en a une importante qui est fréquemment utilisée et qui n'est pas listée ailleurs:
Il existe également trois variables globales intégrées obsolètes dont vous devez tenir compte (ces variables sont uniquement conçues pour prendre en charge les projets hérités des versions précédentes de GameMaker et ne doivent pas être utilisées dans de nouveaux projets ):
La méthode suivante peut également être utilisée pour déclarer des variables globales, mais elle n'est incluse que pour la rétrocompatibilité, et il n'est pas recommandé d'utiliser cette méthode pour les nouveaux projets car les futures versions de GameMaker Studio 2 ne la GameMaker Studio pas en charge.
La deuxième méthode pour créer des variables globales est de les déclarer comme telles en utilisant globalvar déclaration, tout comme vous le feriez une variable locale en utilisant le var déclaration.
IMPORTANT! le globalvar La déclaration est obsolète et uniquement prise en charge pour les besoins hérités. Vous devriez toujours utiliser le global. identifiant pour marquer les variables globales.
Cette déclaration (obsolète) serait utilisée comme suit:globalvar food;
food = 5;Une fois déclarée de cette manière, cette variable "nourriture" est maintenant considérée comme globale et ne nécessite aucune global. préfixe - ce qui signifie également qu'il est beaucoup plus difficile d'identifier les variables globales dans votre code et qu'il est également beaucoup plus facile d'obtenir un chevauchement variable lorsque vous utilisez le même nom de variable dans différents objets ou extensions que vous avez installés. Une fois déclarée de cette manière, la variable globale est accédée comme suit:
food += 2;
ou:
draw_text(32, 32, "food = " + string(food));
Comme vous pouvez le voir, rien n'indiquant que la variable est d'envergure mondiale, vous risquez de vous exposer à de nombreux problèmes subtils dans votre jeu. C'est pourquoi cette déclaration devrait être évitée.
Il y a quelques fonctions conçues pour vous aider lorsque vous manipulez des variables globales (principalement pour les scripts de compatibilité pour les projets importés et le code pour les actions de glisser-déposer, mais ils peuvent aussi être utilisés ailleurs):
Les variables intégrées sont des variables spéciales qui sont "intégrées" aux objets et aux pièces dans le monde du jeu et qui peuvent être de type instance ou globales (mais jamais locales). Certaines variables globales sont listées dans la section ci-dessus, et les différentes sections du manuel pour les sprites, les pièces, les objets etc... décrivent également les variables intégrées disponibles. Des exemples de telles variables d'instance intégrées seraient:
Et des exemples de variables globales intégrées seraient:
Les variables intégrées peuvent être changées et réglées comme la plupart des autres variables, et certaines peuvent même être des tableaux, seulement vous n'avez pas besoin de les définir pour les créer comme une variable normale puisqu'elles seront déjà initialisées à une valeur par défaut.
Bien qu'elles ne soient pas exactement des variables, les macros leur ressemblent dans la façon dont elles sont utilisées, c'est-à-dire: ce sont des valeurs nommées que vous pouvez utiliser dans votre code pour remplacer les valeurs dures. Fondamentalement, une macro (également appelée une constante lorsqu'elle est utilisée comme cela) est une variable nommée qui contient une valeur unique constante (ou une chaîne). Vous pouvez définir vos propres constantes en utilisant l' éditeur de script, puis les utiliser dans votre code et DnD comme s'il s'agissait de variables régulières, à la seule différence qu'elles ne peuvent pas être changées dans le jeu. Par exemple, disons que vous définissez la macro suivante comme une constante (notez le "#" précédent et l'absence de deux-points ";" à la fin):
#macro total_weapons 10
Vous appelez cela dans votre code comme ceci:
if ++pos == total_weapons
{
pos = 0;
}Notez que vous ne seriez pas en mesure de modifier la valeur de la constante, donc un code comme celui-ci provoquera le crash du jeu:
total_weapons = 11;
Vous pouvez définir une macro n'importe où dans votre code ou vos scripts et elle sera pré-compilée et incluse dans votre jeu comme si elle était là depuis le début, mais nous vous recommandons de créer une ressource de script dédiée et de définir toutes vos macros. Il sera plus facile d'organiser et de déboguer plus tard!
Si vous avez besoin de modifier la valeur d'une macro au moment de l'exécution, vous devriez probablement en faire une variable globale, puisqu'on peut en changer depuis le code, sauf si vous définissez la macro comme une fonction. En définissant la macro sur une fonction, cela signifie que cette fonction sera appelée chaque fois que vous utiliserez la macro. Par exemple:
#macro col make_colour_hsv(irandom(255), 255, 255)
Vous appelleriez alors cette macro quelque chose comme ceci:
image_blend = col;
L'utilisation de ce code fera que l'image fusionnera une couleur différente chaque fois que la macro est utilisée.