Comment utiliser les variables ?

Les variables sont extrêmement utiles dans un jeu : elles sont utilisées pour retenir certaines informations, comme la vie d'un joueur, l'état d'un objet, le nombre de munitions disponibles…
Dans ce tutoriel, nous allons passer en revue l'utilisation des variables dans plusieurs contextes.

Vous pouvez télécharger le petit projet utilisé pour le tutoriel ici :http://www.compilgames.net/dl/VariablesTutorial.zip
et essayer le résultat en ligne.

Bien sûr, n'hésitez pas à modifier les événements afin d'expérimenter par vous même !

Rappel rapide à propos des variables dans GDevelop

Les variables permettent de stocker des données, comme un nombre ou un texte. On peut les comparer à des tiroirs ou boites en mémoire où l'on peut placer la donnée souhaitée.

Les variables sont rattachées à une scène (on les appelle alors des variables de la scène) ou au jeu (variables globales dans ce cas). Les valeurs des variables globales ne sont pas changées lorsque le jeu change de scène, alors que les variables de la scène sont effacées.
Tous les objets présents sur la scène ont aussi des variables qui leurs sont spécifiques : Dans ce cas, les variables sont appelées variables d'objets.

Utiliser les variables

Retenir l'état d'un objet

Les variables peuvent être utilisées pour stocker l'état d'un objet : Dans l'exemple, l'objet Player contient une variable nommée Jumping ( Sauter en anglais ).
Quand la variable est à 0, on considère que l'objet n'est pas entrain de sauter, et quand elle est à 1, on considère que l'objet est en l'air. Ici, la variable est notamment utile pour éviter d'appliquer plusieurs fois une impulsion à l'objet quand la touche Space ( Espace ) est appuyée :

Les conditions testent si Space est appuyée et si la variable de l'objet est égal à 0. Si ces conditions sont remplies, les actions sont lancées : L'objet est déplacé, et la variable est mise à 1. Ainsi, les actions ne seront pas relancées plus d'une fois à la suite ( Précisement, pas avant que la variable ne soit remise à 0 ).

Nous devons donc mettre la variable Jumping à 0 quand l'objet a atterri sur le sol:

Et c'est tout. En utilisant cette variable, on peut connaitre facilement si l'objet est en l'air ou au sol, et éviter la répétition d'actions.

Stocker une quantité

Les variables sont souvent utilisées pour stocker la vie ou les munitions, ou toute autre quantité liée au joueurs.
Dans notre exemple, la vie est stockée dans une variable nommée Life. Par défaut, la variable est mise à 100 ( Dans le gestionnaire de projet, faites un clic droit sur le nom de la scène et choisissez Variables initiales pour afficher les valeurs initiales de toutes les variables. )

Quand le joueur clique sur le personnage, celui ci est envoyé en l'air et une animation est jouée. Nous voulons également baisser la vie de 20 unités:

Ici, on a juste utilisé une action pour soustraire 20 à la variable.
Notez que les conditions assurent que les actions ne seront pas répétées plus d'une fois à la suite ( Autrement, on enlèverait 20 à la vie plusieurs fois par seconde, à chaque fois que les évènements seraient exécutés ! )

Augmenter progressivement une variable

Parfois, on souhaite augmenter une variable progressivement au fil du temps. Cela peut être facilement fait en utiliser la fonction TimeDelta, qui retourne le temps, en secondes, écoulés depuis le rendu de la dernière image affichée à l'écran ( qui correspond donc également au temps depuis que les évènements ont été lancés ). Ici, on augmente la variable à une vitesse de 5 points par seconde :

Vous pouvez abaisser une variable de la même façon : Utilisez juste un - à la place du +.

Limiter les valeurs prises par une variable

La vie doit toujours être entre 0 et 100 dans notre petit jeu: Pour assurer ceci, il suffit d'utiliser deux évènements comme ceux ci :

Notez que ce genre d'évènements doit être placé vers la fin de la liste des évènements, ou du moins après tous les évènements qui modifient la variable. Autrement, la valeur pourrait être modifiée après et dépasser les bornes.

Afficher une variable à l'écran

Afficher la valeur d'une variable à l'écran se fait facilement : Placez un objet texte quelque part sur la scène.
Ensuite, ajoutez un évènement modifiant le texte de l'objet :

La valeur de la vie est ici obtenue avec la partie Variable(Life). Ensuite, on converti celle ci en une chaine de caractère avec la fonction ToString, et on rajoute enfin un petit texte devant la variable. Le texte doit être inscrit entre guillemets pour que GDevelop sache que c'est un texte constant.
On a également utilisé les fonction round, afin que la variable soit arrondie et s'affiche comme un nombre sans virgule.

Vous pouvez également afficher la variable d'un objet comme ceci : ToString(Player.Variable(Munitions)), si l'on imagine que vous stockez les munitions du joueur dans la variable Munitions de l'objet Player.
Si votre variable contient un texte, utilisez la fonction VariableString : “Votre nom est ”+VariableString(NomDuJoueur).

La dernière partie concerne les structures. Si vous êtes débutant, vous n'avez absolument pas besoin de lire cette partie : Expérimentez d'abord avec les techniques décrites plus haut, et revenez par ici plus tard si vous avez envie d'en savoir plus. ;-)

Utilisation avancée des variables : Structures

GDevelop supporte une fonctionnalité avancée pour les variables, appelées Structures. Les variables dans GDevelop peuvent soit contenir un nombre ou un texte, ou être une structure. Dans ce cas, la variable n'a pas de valeur mais contient d'autres variables, appelées des variables enfants. Bien sûr, les variables enfants peuvent contenir des nombres, des textes ou même être elle mêmes des structures.

Si vous voulez qu'une variable soit une structure, vous devez juste ne pas changer sa valeur ou son texte ( Vu qu'une variable n'a pas de texte ni de valeur. ). Pour modifier la valeur d'une variable enfant, entrez dans l'action ou la condition, en nom de variable : Le nom de la variable structure, suivi d'un point et finissez par entrer le nom de l'enfant souhaité. Par exemple : Joueur.NombreDeMorts. ( Les espaces ne sont pas autorisés dans les noms. )

Comme les variables normales, si un enfant n'existe pas, il sera automatiquement ajouté au parent.
Il existe une condition permettant de tester si un enfant est défini dans une variable parent, et une action pour retirer une variable enfant d'une structure.

Accès dynamique aux enfants

Il est également possible d'accéder à une variable enfant en utilisant une expression texte, en suivant cette syntaxe : Variable[expression].
Par exemple, on peut imaginer que l'on stocke les statistiques du joueur pour chaque niveau, appelés Niveau1, Niveau2, Niveau3… Si on nomme la variable parent StatsJoueur, on a donc des variables enfants StatsJoueur.Niveau1, StatsJoueur.Niveau2, StatsJoueur.Niveau3
Si vous voulez afficher les statistiques au joueur pour un niveau spécifique, vous pouvez d'abord stocker le numéro du niveau souhaité dans une variable nommée NiveauCourant.
Ensuite, accédez aux statistiques avec cette syntaxe : StatsJoueur[“Niveau”+ToString(Variable(NiveauCourant))].

Autres utilisations avancées

Les structures sont utiles pour stocker des données structurées. Vous pouvez également les utiliser comme un tableau : Nommez simplement les enfants 0, 1, 2

Attention, les noms des enfants sont toujours du texte. Ainsi, dans le cas où vous utilisez une variable structure comme un tableau indexé, il faut bien convertir les indices en chaîne de caractères pour les utiliser comme nom d'enfant.

Des actions et expressions sont également disponibles pour convertir une structure depuis ou vers le format JSON, une notation couramment utilisée sur le web.

Pour aller plus loin, un article dédié existe sur les variables structures : Comment simuler un tableau dynamique avec une variable structure