Tutoriel de Scripting Visuel (Logic Bricks)

Dans cette leçon, nous allons terminer le système que nous avons commencé dans la leçon précédente en créant les boutons qui vont se connecter à la logique de la plateforme et compléter l'interaction entre les deux systèmes.

Au cours de ce processus, nous allons explorer plusieurs concepts importants dans le système logique visuel de Cave. Vous apprendrez à détecter les collisions en utilisant un Rigid Body, à utiliser le nœud Delay pour contrôler quand les actions se produisent dans le temps, à changer la couleur d'une Entity pendant le gameplay, et à pratiquer la création et l'utilisation de fonctions pour garder vos Logic Bricks organisés et réutilisables.

À la fin de cette leçon, nous aurons un système complet où les boutons peuvent être activés par le joueur et communiquer correctement avec la plateforme créée précédemment.

1. Création du Bouton

Pour commencer à créer le bouton, créez d'abord un nouveau Entity Template.

Ensuite, renommez l'Entity selon son objectif, configurez le Mesh qui sera utilisé comme sa représentation visuelle, et ajoutez les composants physiques nécessaires pour qu'il puisse interagir correctement dans le jeu.

Après cela, créez un nouveau Logic Brick et liez-le à l'Entity du bouton.

Ce processus est très similaire à ce que nous avons fait précédemment en créant la plateforme, donc c'est aussi une bonne occasion de pratiquer les concepts que vous avez déjà appris.

À la fin de cette étape, nous aurons la structure de base du bouton prête à recevoir sa logique d'activation.

Maintenant, il y a une étape très importante : nous ne pouvons pas oublier d'ajouter la balise button à l'Entity du bouton.

Si vous vous en souvenez, dans la leçon précédente, nous avons déjà préparé la logique de la plateforme pour compter automatiquement combien de boutons existent dans la scène en utilisant cette balise exacte.

De ce fait, la balise doit être créée et assignée au bouton en utilisant le même nom qui a été utilisé dans la logique de la plateforme.

Si le nom de la balise est différent, même d'un petit détail, la plateforme ne pourra pas trouver les boutons correctement et le compte ne fonctionnera pas comme attendu.

Alors avant de continuer, assurez-vous de créer la balise button et de l'ajouter à l'Entity du bouton.

Maintenant, ajoutons également une propriété à l'Entity du bouton.

Nous utilisons la balise button pour identifier le bouton dans la carte, mais nous allons utiliser une propriété pour contrôler une partie de son comportement.

Créez une nouvelle propriété appelée Active Time, de type Float.

Cette propriété stockera combien de temps le bouton doit rester actif avant de revenir automatiquement à l'état inactif.

Cela rend le système plus flexible car chaque bouton peut avoir un temps d'activation différent. Par exemple, un bouton peut rester actif pendant 3 secondes, tandis qu'un autre bouton peut rester actif pendant 10 secondes, sans changer le Logic Brick lui-même.

2. Création de la Logique du Bouton

Maintenant que notre Entity est prête, avec la balise et la propriété configurées, commençons à créer le comportement du bouton.

La première étape est de détecter la collision entre l'Entity du bouton et le joueur, afin que nous puissions l'activer lorsque le joueur le touche.

Cependant, avant d'implémenter cette logique, nous devons prendre en compte un détail important : nous ne voulons activer le bouton que lorsqu'il est actuellement inactif.

Puisque le bouton aura deux états différents, actif et inactif, nous avons besoin d'un moyen de stocker quel état est actuellement utilisé.

Pour cela, créez une nouvelle propriété dans le Logic Brick du bouton appelée Active Button, de type Boolean.

Cette propriété stockera l'état actuel du bouton, indiquant s'il est actif ou non. Nous utiliserons cette valeur dans les prochaines étapes pour contrôler l'ensemble du comportement du bouton.

Maintenant, nous pouvons commencer à construire la logique visuelle.

Dans On Update, nous allons constamment vérifier si le bouton est actif ou inactif en utilisant la propriété Active Button que nous venons de créer.

Pour ce faire, récupérez sa valeur en utilisant Get Active Button et utilisez un nœud If pour vérifier son état.

Si la condition est False, cela signifie que le bouton est inactif et peut être activé. Dans ce cas, nous allons détecter la collision entre le bouton et le joueur.

Pour ce faire, ajoutez un nœud Collided With.

Ce nœud a besoin d'un Rigid Body Component, donc récupérez l'Entity du bouton et, à partir de celle-ci, récupérez le Rigid Body Component que nous avons ajouté lors de la configuration de la physique.

Nous devons également indiquer au nœud quel objet nous voulons détecter. Pour cela, ajoutez une balise player au personnage et passez cette balise à Collided With.

De cette manière, la collision ne sera considérée valide que lorsque le bouton entre en collision avec le joueur.

Avec cette structure, le bouton ne peut être activé que lorsqu'il est inactif et lorsque le joueur entre effectivement en collision avec lui.

Maintenant que nous avons défini les deux chemins, implémentons d'abord la logique pour quand le bouton est actif.

Après cela, nous créerons le comportement responsable de son activation.

Pour cela, suivez la condition True du nœud If qui vérifie si le bouton est actif ou non.

Dans ce flux, nous utiliserons la propriété Active Time que nous avons créée dans l'Entity du bouton pour contrôler combien de temps le bouton doit rester actif.

Tout d'abord, récupérez l'Entity du bouton et accédez à ses propriétés via le nœud Get Properties.

Ensuite, utilisez Get Property, en connectant le dictionnaire retourné précédemment et en utilisant Active Time comme Key.

Étant donné que cette propriété est un Float, changez le type de sortie de Get Property en Float, en vous assurant que nous pouvons utiliser cette valeur correctement dans la prochaine partie de la logique.

Maintenant, la sortie de Get Property renvoie la valeur de la propriété Active Time, qui définit combien de temps le bouton doit rester actif.

Ensuite, ajoutez un nœud Delay et utilisez cette valeur comme durée.

De cette manière, le temps d'attente est contrôlé directement par la propriété de l'Entity, permettant à différents boutons d'avoir des temps d'activation différents sans changer la logique.

Après que le Delay soit terminé, utilisez Set Active Button et définissez sa valeur sur False.

Avec cela, le bouton revient automatiquement à l'état inactif après le temps spécifié dans sa propriété.

Très bien. Maintenant, suivons l'autre chemin et créons le comportement responsable de l'activation du bouton.

La sortie du nœud Collided With renvoie une valeur Bool.

Lorsque cette valeur est True, cela signifie que le bouton a percuté le joueur.

À ce moment-là, nous pouvons simplement utiliser Set Active Button et définir sa valeur sur True.

En procédant ainsi, le bouton entre dans l'état actif et commence automatiquement à utiliser la logique active que nous avons créée précédemment, ce qui le maintient actif pendant une certaine période et puis le désactive à nouveau.

Avec cela, nous avons créé un cycle de comportement complet :

• lorsque le joueur entre en collision avec le bouton, il est activé
• après le temps défini dans Active Time, il est désactivé
• après cela, il peut être activé à nouveau par une autre collision

Même si cette logique est simple, elle donne déjà au bouton deux états différents et sera la base des prochaines fonctionnalités que nous allons ajouter.

Tout fonctionne, mais une pièce importante manque encore.

Bien que la logique d'activation et de désactivation du bouton soit déjà correcte, notre plateforme ne sait toujours pas quand un bouton a été activé.

C'est exactement là que la propriété Button Count que nous avons créée précédemment dans la Scene devient importante.

Si vous vous souvenez, dans la logique de la plateforme, nous avons défini que la plateforme ne doit être supprimée que lorsque la valeur de cette propriété devient égale au nombre total de boutons dans la carte.

En d'autres termes, la plateforme est déjà prête à réagir, mais jusqu'à présent, aucun bouton ne change cette valeur.

Ce que nous devons faire maintenant, c'est permettre aux boutons de modifier directement la propriété Button Count de la scène chaque fois qu'ils sont activés et désactivés.

C'est une excellente occasion de pratiquer une autre fonctionnalité très importante de Logic Bricks dans Cave : la création de fonctions.

Au lieu de répéter la même logique plusieurs fois, nous allons encapsuler ce comportement dans des fonctions réutilisables, gardant notre Graph plus organisé, plus facile à comprendre et plus facile à maintenir.

Puisque la propriété Button Count est stockée dans la scène, nous devons d'abord y accéder.

Pour cela, récupérez la scène en utilisant Get Scene, puis utilisez Get Properties.

3. Création de la Fonction qui Contrôle les Propriétés de la Scène

À partir de ces nœuds, nous allons créer une fonction.

Pour cela, sélectionnez les nœuds concernés, faites un clic droit et choisissez Promote Selection to Function.

Ensuite, renommez la nouvelle fonction avec un nom clair et descriptif qui représente son objectif dans la logique du projet.

Dans ce cas, nous utiliserons le nom Set Scene Property.

Maintenant, structurons comment la fonction Set Scene Property fonctionnera.

Tout d'abord, passez le dictionnaire des propriétés de la Scene au nœud Get Property. Ce dictionnaire provient du flux Get Scene → Get Properties.

Ensuite, changez la sortie de Get Property en Int, en vous assurant que nous travaillons avec des valeurs entières.

Dans Function Inputs, créez deux nouveaux paramètres pour cette fonction :

• Prop Name, de type String
• Value, de type Int

Le paramètre Prop Name sera utilisé comme la Clé dans Get Property, permettant à la fonction d'accéder à la propriété désirée dans le dictionnaire des propriétés de la Scène.

Ensuite, nous allons mettre à jour cette propriété en utilisant Set Property.

Pour cela, obtenez la valeur actuelle de la propriété, ajoutez l'entrée Value et écrivez le résultat dans la même propriété.

Nous passons à nouveau le dictionnaire des propriétés de la Scène et utilisons Prop Name comme clé.

Cela crée une fonction générique et réutilisable qui peut modifier les propriétés de la Scène de manière simple et organisée.

Au lieu de simplement définir une valeur exacte, cette fonction fonctionne comme un système d'incrément : elle ajoute la Value reçue à la valeur actuelle de la propriété de la Scène.

Avec cette fonction prête, nous n'avons plus besoin de garder toute cette chaîne de nœuds directement dans le Graph principal.

Maintenant, au lieu de répéter toute la logique, nous appelons simplement la fonction juste après avoir défini Active Button à True.

Cela signifie qu'au moment où le bouton est activé, nous disons immédiatement à la logique de la plateforme qu'un bouton de plus a été pressé.

Pour cela, passez le nom de la propriété Button Count, qui est la propriété stockée dans la Scène, et envoyez la valeur 1 comme incrément.

La fonction ajoutera automatiquement +1 à la valeur actuelle de cette propriété.

De cette manière, tout bouton activé met directement à jour le progrès global du système, sans duplicata de logique.

Cela nous donne également plus de flexibilité pour changer les propriétés de la Scène à l'avenir en réutilisant cette même fonction.

Pour montrer à quel point cela est simple et flexible, revenons à la logique du bouton actif.

Juste après que le temps d'activation soit écoulé et que nous définissons Active Button à False, nous appellerons à nouveau Set Scene Property.

Le paramètre Prop Name sera Button Count, utilisant la même propriété de la Scène.

Mais cette fois, le paramètre Value sera -1.

Puisque notre fonction ajoute la valeur reçue à la valeur actuelle de la propriété de la Scène, passer un nombre négatif soustrait automatiquement 1 de l'actuel Button Count.

De cette façon, chaque fois qu'un bouton est désactivé, le système met également à jour correctement le progrès global, maintenant la logique de la plateforme synchronisée avec l'état réel des boutons sur la carte.

Maintenant notre logique fonctionne comme prévu.

Il ne reste qu'un détail important : créer un effet visuel pour rendre clair pour le joueur lorsque le bouton est actif.

Chaque fois qu'un bouton est activé, nous allons directement changer sa couleur en utilisant le Tint, mettant en évidence visuellement son état.

Avant de définir Active Button à True, ajoutez une Sequence.

Puisque nous n'avons plus besoin de trois flux, nous pouvons supprimer une des sorties en cliquant avec le bouton droit et en sélectionnant Remove Last Flow Output, gardant seulement deux chemins.

Ensuite, obtenez l'Entité enfant du bouton appelée ButtonMesh, accédez à son Mesh Component, et ajustez la valeur de Tint.

Dans l'axe Y, définissez la valeur à 25, faisant en sorte que le bouton apparaisse vert lorsqu'il est activé.

Cela donne au joueur un retour visuel clair chaque fois qu'un bouton est pressé, améliorant la lisibilité et la réponse de l'interaction dans le jeu.

De la même manière, nous allons restaurer la couleur d'origine du bouton lorsqu'il devient inactif.

Utilisez la même logique, mais dans le flux où nous définissons Active Button à False.

À ce moment-là, accédez à nouveau à l'Entité enfant ButtonMesh, obtenez son Mesh Component, et ajustez la valeur de Tint.

Pour revenir à la couleur par défaut, il suffit de rétablir toutes les valeurs de Tint à 1, restaurant l'état visuel d'origine du bouton.

De cette manière, chaque fois que le bouton est désactivé, il retrouvera également son apparence initiale, rendant clair pour le joueur qu'il peut être activé à nouveau.

En sélectionnant une instance de modèle de bouton que nous avons ajoutée à la scène, nous pouvons accéder à ses propriétés et changer la valeur de Active Time.

De cette façon, chaque bouton peut avoir une durée d'activation différente et fonctionner indépendamment.

Cela nous donne plus de flexibilité pour créer des défis variés à l'intérieur du niveau, car chaque bouton peut être configuré individuellement sans changer la logique principale du système.

Avec cela, nous pouvons ajouter autant de boutons que nous le voulons sur la carte, chacun avec un temps d'activation différent et un comportement indépendant.

La plateforme suit automatiquement ce paramètre sans nécessiter d'ajustements manuels, car le comptage se fait à l'exécution.

Le système reste également synchronisé avec l'état réel du jeu. Au fur et à mesure que les boutons sont activés et désactivés, la valeur globale est mise à jour, et la plateforme réagit lorsque la condition est remplie, étant retirée de la scène au bon moment.

En plus de la logique, nous avons ajouté un retour visuel important pour le joueur.

Changer la couleur du bouton lorsqu'il est activé et restaurer son apparence initiale lorsqu'il est désactivé rend le système beaucoup plus clair et intuitif. Le joueur peut comprendre visuellement quels boutons sont actifs et lesquels nécessitent encore une attention.

À la fin, nous avons créé un système modulaire et évolutif qui combine la communication entre les Entités, le contrôle centralisé par la Scène et un retour visuel direct dans le monde du jeu.

Cette même structure peut être facilement étendue pour des portes, des plateformes, des ascenseurs, des énigmes, des pièges, des défis chronométrés, et bien d'autres événements interactifs.