Tutoriel de Scripting Visuel (Logic Bricks)

Dans cette leçon, nous allons commencer à créer la logique de mouvement de base pour notre Player.

En utilisant uniquement les Logic Bricks de Cave Engine, nous allons implémenter une mécanique de saut simple via une logique visuelle. Cela vous aidera également à comprendre une des idées les plus importantes derrière les Logic Bricks : comment les événements, conditions et actions fonctionnent ensemble pour contrôler le comportement du jeu.

Dans ce cas, la logique sera très simple:

1. Vérifiez si le joueur a appuyé sur la touche de saut.
2. Vérifiez si le Player est autorisé à sauter.
3. Si tout est correct, appelez la fonction de saut du Character Component du Player.

C'est un bon premier exemple car le saut est une mécanique de jeu très courante, mais il introduit également la structure de base que vous utiliserez de nombreuses fois lors de la création de jeux avec les Logic Bricks.

1. Ajouter le Saut

Pour commencer à créer la logique de mouvement du Player, nous devons d'abord obtenir les Events du jeu.

L'objet Events vous donne accès à des informations liées à l'entrée, telles que les touches du clavier, les boutons de la souris, et d'autres vérifications d'événements qui se produisent pendant le jeu.

Dans la zone d'édition des Logic Bricks, faites un clic droit pour ouvrir le menu de recherche de nœuds.

Pour trouver rapidement un nœud, utilisez le champ de recherche identifié par l'icône de loupe et tapez le nom du nœud que vous souhaitez.

Les nœuds Entity, Scene, et Events sont utilisés très fréquemment, ils apparaissent donc déjà mis en surbrillance en haut de la fenêtre de recherche. De ce fait, vous n'avez généralement pas besoin de les rechercher manuellement par leur nom.

Sélectionnez Get Events pour ajouter un nœud Events à votre logique.

Ajoutez maintenant le nœud Pressed.

Ce nœud sera responsable de la vérification si une touche spécifique est en train d'être enfoncée par le joueur.

En d'autres termes, c'est la condition qui dira à notre logique : « le joueur veut sauter maintenant. »

Sélectionnez la touche qui sera utilisée pour exécuter le saut.

Dans la plupart des jeux, la touche Espace est couramment utilisée pour sauter, donc nous allons l'utiliser ici aussi.

Après avoir configuré la touche de saut, nous devons vérifier si cette touche a réellement été enfoncée par le joueur.

Pour cela, nous allons utiliser un nœud If (Bool).

Le nœud If (Bool) reçoit une valeur booléenne, ce qui signifie une valeur qui peut être soit True, soit False. Si la condition est vraie, la logique continue à travers la sortie True. Si la condition est fausse, elle continue à travers la sortie False.

Dans ce cas, la condition sera de savoir si la touche Espace est enfoncée ou non.

Maintenant, de la même manière que nous avons ajouté le nœud Events, nous devons également obtenir notre Entity actuelle.

C'est important car l'action de saut n'appartient pas à l'objet Events. L'objet Events ne fait que nous dire si la touche a été enfoncée. Le comportement réel du saut appartient à l'Entity Player, plus précisément à son Character Component.

Grâce au nœud Entity, nous pourrons accéder aux composants attachés au Player.

Depuis la Sortie du Character Component, tirez une connexion et recherchez Jump.

Ce nœud sera responsable de l'exécution du saut du personnage lorsque la condition est remplie.

Donc, à ce stade, nous disons essentiellement :

« Lorsque le joueur appuie sur la touche de saut, obtenez le Character Component du Player et appelez sa fonction Jump. »

Voici le flux principal de la logique de saut :

Entity → Character Component → Jump

Avec ce flux, nous accédons au character component de l'Entity et utilisons ensuite sa fonction de saut.

Maintenant, connectez la sortie True du nœud If (Bool) à l'entrée Flow du nœud Jump.

Cela signifie que lorsque la touche Espace est enfoncée, la condition sera vraie et le Player exécutera le saut.

Si la touche n'est pas enfoncée, la condition sera fausse et rien ne se passera.

Cependant, pour que cette logique soit réellement exécutée, elle doit être connectée à un événement Flow.

Les Logic Bricks ne s'exécutent pas au hasard. Ils ont besoin d'un point d'entrée, qui est le nœud qui commence le flux d'exécution.

Le nœud On Start s'exécute une seule fois, lorsque l'Entity commence. C'est utile pour une logique d'initialisation, comme le réglage des variables, la préparation des références, ou la configuration de quelque chose au début du jeu.

Le nœud On Update s'exécute à chaque image. Cela est utile pour la logique de jeu qui doit être vérifiée constamment, comme le mouvement, l'entrée, le contrôle de la caméra, ou tout ce qui peut changer pendant que le jeu s'exécute.

Puisque nous devons vérifier constamment si le joueur a appuyé sur la touche de saut, nous allons connecter notre logique à On Update.

Cela garantit que la vérification de la touche de saut se produit constamment pendant le gameplay.

Avec cette logique, le personnage devrait déjà être capable de sauter.

Pour garder vos Logic Bricks organisés, vous pouvez sélectionner tous les nœuds utilisés pour créer cette fonctionnalité en cliquant et en faisant glisser avec le bouton droit de la souris, ou en les sélectionnant individuellement tout en maintenant Shift enfoncé.

Après avoir sélectionné les nœuds, appuyez sur C pour créer un commentaire.

C'est une pratique d'organisation très utile. Au fur et à mesure que votre logique grandit, les commentaires vous aident à séparer visuellement les différentes parties du comportement, comme le saut, le mouvement, la caméra, les attaques, les interactions, etc.

Même si la logique est simple pour le moment, s'habituer à organiser vos nœuds dès le départ rendra votre projet beaucoup plus facile à comprendre par la suite.

2. Ajouter la Vérification du Sol

À ce stade, vous avez probablement remarqué un petit problème : si nous continuons à appuyer sur la touche Espace, le personnage peut continuer à sauter de manière répétée.

Cela se produit parce que notre logique ne vérifie pas encore si le personnage est réellement autorisé à sauter à ce moment-là. Elle vérifie seulement si la touche de saut a été enfoncée, puis appelle immédiatement la fonction de saut.

Dans la plupart des jeux, nous ne voulons pas que le joueur saute indéfiniment dans les airs. En général, le joueur ne devrait être capable de sauter que lorsqu'il touche le sol.

Heureusement, résoudre cela dans Cave est très simple.

Pour cela, nous allons utiliser le nœud On Ground.

Le nœud On Ground renvoie une valeur booléenne indiquant si le personnage touche actuellement le sol ou non.

Ainsi, au lieu de vérifier une seule condition, nous allons vérifier deux conditions :

1. La touche de saut est-elle enfoncée ?
2. Le personnage est-il sur le sol ?

Ce n'est que lorsque les deux conditions sont vraies que le nœud Jump doit être exécuté.

La logique devient :

• D'abord, vérifiez si la touche Espace a été enfoncée.
• Si c'est vrai, vérifiez si le Player est au sol.
• Si le Player est au sol, exécutez Jump.
• Si le Player n'est pas au sol, ne faites rien.

Cela empêche le personnage de sauter indéfiniment alors qu'il est déjà en l'air.

Avec cette vérification du sol ajoutée, la logique de saut devient beaucoup plus correcte pour un contrôleur de joueur de base.

Maintenant, le Player ne sautera que lorsque la touche de saut est enfoncée et que le Character Component signale que le Player est actuellement sur le sol. C'est la structure de base que vous utiliserez pour de nombreuses actions de gameplay dans Cave : d'abord vérifiez l'entrée, ensuite vérifiez si l'action est autorisée, et seulement ensuite exécutez l'action.