Tutoriel de Scripting Visuel (Logic Bricks)

Dans cette leçon, nous allons continuer à développer la logique de mouvement de base pour notre Joueur.

En utilisant les Logic Bricks de Cave Engine, nous allons créer la logique responsable de faire marcher et courir le personnage. En chemin, vous apprendrez comment capturer l'entrée du joueur, convertir cette entrée en direction de mouvement, contrôler la vitesse de mouvement et garder la logique visuelle organisée.

Cette leçon s'appuie sur la logique de saut créée précédemment. Désormais, au lieu de ne réagir qu'à une seule pression de touche, nous allons lire plusieurs touches en même temps et les utiliser pour définir où le Joueur doit se déplacer.

1. Ajout de la Séquence

Pour continuer à développer la logique de mouvement pour notre Joueur, nous allons apprendre à utiliser le nœud Séquence.

Le nœud Séquence vous permet de créer plusieurs sorties Flow à partir d'une seule entrée. Ceci est utile car de nombreux systèmes de jeu doivent exécuter plus d'un morceau de logique à partir du même événement.

Par exemple, notre événement Sur Mise à Jour doit vérifier la logique de saut à chaque image, mais il devra également vérifier la logique de mouvement à chaque image. Au lieu de tout créer dans une grande chaîne confuse, nous pouvons utiliser Séquence pour diviser le flux en plusieurs branches organisées.

De cette façon, le même événement Sur Mise à Jour peut exécuter différents blocs de logique à chaque image de manière plus propre et plus contrôlée.

2. Création de la Logique de Mouvement

Pour créer le mouvement du Joueur, nous allons commencer par ajouter le nœud Événements puis le nœud Actif.

Le nœud Actif vérifie si une touche est actuellement enfoncée. Ceci est différent de vérifier si une touche a été pressée une seule fois. Pour le mouvement, nous voulons généralement savoir si le joueur maintient en continu la touche, car le personnage devrait continuer à se déplacer tant que la touche reste active.

Nous allons faire cela pour toutes les touches de mouvement :

• W pour avancer
• S pour reculer
• A pour aller à gauche
• D pour aller à droite

La sortie du nœud Actif est une valeur Booléenne. Une variable booléenne peut seulement avoir deux états : Vrai ou Faux.

Lorsque nous convertissons cette valeur booléenne en un Flottant en utilisant le nœud Bool To Float, nous obtenons :

• 1 lorsque la valeur est Vrai
• 0 lorsque la valeur est Faux

Cela nous permet d'utiliser l'état du clavier dans des opérations mathématiques.

Par exemple, nous pouvons soustraire la valeur de S de la valeur de W pour calculer le mouvement avant/arrière. Nous pouvons également soustraire la valeur de A de la valeur de D pour calculer le mouvement gauche/droite.

Cela fonctionne parce que chaque touche renvoie soit 0 soit 1.

Par exemple, pour le mouvement avant et arrière :

• Si W est pressé et S n'est pas pressé, le résultat est 1 - 0 = 1, donc le Joueur avance.
• Si S est pressé et W n'est pas pressé, le résultat est 0 - 1 = -1, donc le Joueur recule.
• Si aucune touche n'est pressée, le résultat est 0 - 0 = 0, donc il n'y a pas de mouvement sur cet axe.
• Si les deux touches sont pressées, le résultat est 1 - 1 = 0, donc elles s'annulent.

Avec ces résultats, nous ajoutons un nœud Make Vector 3 et connectons les valeurs calculées aux axes X et Z, qui seront responsables de définir la direction de mouvement.

Maintenant, connectez la première sortie Puis du nœud Séquence au flux de cette logique de mouvement, tandis que l'autre sortie Puis peut continuer à être utilisée par la logique de saut créée dans la leçon précédente.

Enfin, obtenez l'Entité, accédez à son Composant de Personnage, et utilisez le nœud Définir la Direction de Marche. Connectez le vecteur créé par Make Vector 3 au paramètre de direction, afin que le Composant de Personnage sache où le Joueur doit se déplacer.

Nous devons maintenant créer un limiteur pour contrôler la vitesse de mouvement de notre Joueur.

Au lieu de définir directement la direction de mouvement dans Définir la Direction de Marche, nous allons d'abord stocker la direction de mouvement dans une propriété. Cela nous donne plus de contrôle car nous pourrons modifier cette direction avant de l'appliquer au personnage.

Ouvrez l'onglet Propriétés, créez une nouvelle propriété, changez son type en Vector3, et renommez-la en Move Dir.

Cette propriété sera utilisée pour stocker la direction de mouvement du Joueur et servira de base pour les ajustements suivants dans la logique.

Cliquez sur l'icône en forme de roue dentée affichée à côté de la propriété et sélectionnez Changer de Type pour modifier son type.

Ensuite, choisissez Vector3.

Retournez maintenant au Graph de vos Logic Bricks et définissez la propriété Move Dir que nous venons de créer.

Connectez la sortie du nœud Make Vector 3 à la valeur de la propriété Move Dir.

Cela signifie qu'au lieu d'appliquer directement la direction de mouvement au personnage, nous stockons ce vecteur dans une propriété afin que nous puissions l'utiliser et le modifier dans les prochaines parties de la logique.

Maintenant que nous stockons la direction de mouvement du personnage dans la propriété Move Dir, créons deux autres propriétés de type Flottant :

• Vitesse de Marche
• Vitesse de Course

Ces propriétés définiront la vitesse du Joueur dans chaque état de mouvement.

Utiliser des propriétés ici est une bonne pratique car cela facilite les ajustements du mouvement plus tard. Au lieu de chercher des valeurs codées en dur dans le graphique, vous pouvez simplement sélectionner l'Entité et ajuster la vitesse de marche et de course directement depuis l'onglet Propriétés.

Maintenant, créez une propriété de type Bool supplémentaire, appelée Est en Course.

Cette propriété stockera l'état de course du personnage. Elle dira à la logique si le Joueur est actuellement en train de courir ou non, nous permettant de choisir entre les valeurs de Vitesse de Marche et Vitesse de Course.

Ajoutez maintenant un nœud Actif pour vérifier si la touche Shift est enfoncée.

Ensuite, utilisez Définir Est en Course pour définir la propriété en fonction de cette condition. Lorsque Shift est actif, Est en Course devrait être défini sur Vrai, indiquant que le personnage est en train de courir.

Nous allons maintenant définir la Direction de Marche en utilisant la direction stockée dans la propriété Move Dir, tout en appliquant la bonne vitesse pour chaque état de mouvement.

Pour ce faire, ajoutez un nœud Si qui vérifie si la propriété Est en Course est Vrai ou Faux.

Si le résultat est Vrai, obtenez la valeur de Move Dir et multipliez-la par la propriété Vitesse de Course.

Si le résultat est Faux, obtenez la valeur de Move Dir et multipliez-la par la propriété Vitesse de Marche.

Enfin, connectez le résultat de cette multiplication au nœud Définir la Direction de Marche.

De cette façon, la direction de mouvement reste la même, mais son intensité change selon que le Joueur marche ou court.

Nous devons maintenant résoudre un petit problème.

Si vous déplacez le personnage en diagonale, vous pouvez remarquer qu'il se déplace plus vite que lorsqu'il marche seulement en avant, en arrière, à gauche ou à droite. Cela se produit parce que la combinaison de deux axes de mouvement crée un vecteur avec une plus grande magnitude.

Par exemple, se déplacer seulement en avant crée une direction comme ceci :

(0, 0, 1)

Mais se déplacer en avant et à droite en même temps crée quelque chose comme ceci :

(1, 0, 1)

Ce vecteur diagonal est plus long qu'un vecteur unidimensionnel, ce qui fait que le personnage se déplace plus vite en diagonal.

Pour corriger ce comportement, nous allons normaliser le vecteur de direction avant de le stocker dans la propriété Move Dir.

Tout d'abord, obtenez la Longueur du vecteur généré par Make Vector 3.

Ensuite, ajoutez un nœud Si pour vérifier si cette valeur est supérieure à 0.

Cette vérification est importante car nous ne devrions pas normaliser un vecteur vide. Un vecteur de longueur 0 signifie qu'aucune touche de mouvement n'est enfoncée, donc il n'y a pas de direction à normaliser.

Si la condition est vraie, utilisez le nœud Normalisé pour obtenir la version normalisée du vecteur.

Sinon, utilisez le vecteur original.

Enfin, connectez le résultat au nœud Définir Propriété de Move Dir.

Cela préserve la direction de mouvement, mais garde sa magnitude cohérente, assurant que le personnage se déplace à la même vitesse dans toutes les directions.

3. Utilisation des Événements

Il existe des moyens plus organisés de structurer le flux de notre logique à l'intérieur des Logic Bricks.

En plus des commentaires et du nœud Séquence, nous pouvons également utiliser des Événements pour rendre le système plus propre et plus facile à comprendre.

Les événements vous permettent de séparer un bloc de logique spécifique et de l'appeler d'un autre endroit dans le graphique. Cela est particulièrement utile à mesure que votre graphique grandit, car cela évite d'avoir tout directement connecté à Sur Mise à Jour dans une grande chaîne.

Créons maintenant un nouvel événement appelé Déplacer Joueur.

Ensuite, connectez cet événement au flux du bloc logique de mouvement du Joueur.

Avec cela, au lieu de garder l'ensemble de la logique de mouvement directement connectée à Sur Mise à Jour, nous pouvons simplement appeler l'événement Déplacer Joueur à l'intérieur de la séquence Sur Mise à Jour.

Cela rend le flux plus propre, plus modulaire et plus facile à comprendre, surtout à mesure que la logique du projet devient plus complexe.

À ce stade, le Joueur a déjà un système de mouvement de base créé avec les Logic Bricks.

La logique vérifie maintenant les touches de mouvement, calcule une direction de mouvement, normalise la direction pour éviter un mouvement diagonal plus rapide, la stocke dans la propriété Move Dir, vérifie si le Joueur court, applique la bonne vitesse, et finalement envoie le résultat au Character Component via Set Walk Direction.