Tutoriel de Scripting Visuel (Logic Bricks)

Dans cette leçon, nous allons commencer à intégrer des animations dans notre Joueur logique.

À ce stade, le Joueur peut déjà se déplacer et sauter. Maintenant, nous devons faire réagir visuellement le personnage à ces états en jouant les bonnes animations, comme veille, marche, court, et tombe.

L'idée principale est simple : nous allons utiliser l'état actuel du personnage pour décider quelle animation doit être jouée.

Par exemple :

• Si le Joueur est au sol et ne bouge pas, jouer l'animation d'attente.
• Si le Joueur est au sol et se déplace, jouer l'animation de marche.
• Si le Joueur court, jouer l'animation de course.
• Si le Joueur n'est pas au sol, jouer l'animation de chute.

C'est l'un des modèles les plus courants lors de la création d'un contrôleur de personnage. La logique de mouvement contrôle ce que le personnage fait, et la logique d'animation lit ces informations pour décider ce que le joueur doit voir.

1. Création de la Logique d'Exécution d'Animation

Maintenant que nous avons appris à créer et organiser des événements, créons un nouvel événement pour le bloc logique d'animation appelé Mettre à Jour les Animations.

Cet événement sera responsable de la mise à jour de l'état d'animation du Joueur.

La première chose que nous allons faire est de connecter cet événement à un nœud Si qui vérifie si le personnage est actuellement au sol ou non. Cette information sera utilisée pour décider quelle animation doit être jouée.

Par exemple, lorsque le Joueur est au sol, nous pouvons jouer les animations d'attente, de marche ou de course. Lorsque le Joueur n'est pas au sol, nous pouvons jouer une animation de chute à la place.

Ensuite, nous devons accéder au Composant d'Animation, qui est responsable de la gestion et de la lecture des animations du personnage.

Pour ce faire, nous allons d'abord obtenir l'Entité, puis utiliser le nœud Enfant pour obtenir l'objet enfant nommé Maille, qui est l'objet de maille de notre Joueur. De cette entité enfant, nous pouvons accéder au Composant d'Animation.

Puisque nous devrons probablement accéder au Composant d'Animation plusieurs fois, nous pouvons transformer les nœuds Obtenir Entité, Obtenir Enfant et Obtenir Composant d'Animation en une fonction réutilisable.

Pour ce faire, sélectionnez les nœuds que vous souhaitez, faites un clic droit et choisissez Promouvoir la Sélection en Fonction.

Cela va créer une fonction contenant cette logique, rendant le Graphe plus propre et plus facile à comprendre. Cela nous permet également de réutiliser ce même flux dans d'autres parties du Bloc Logique sans avoir à recréer les mêmes nœuds à nouveau.

Renommons cette fonction en Jouer Animation.

Utiliser des noms clairs et descriptifs est très important lors du travail avec la logique visuelle. Au fur et à mesure que votre graphe grandit, de bons noms vous aideront à comprendre rapidement ce que chaque événement, fonction et bloc de logique est responsable.

Maintenant, double-cliquez sur la fonction Jouer Animation pour l'ouvrir et l'éditer.

Ensuite, faites un clic droit sur le nœud Entrées de Fonction et ajoutez deux nouvelles entrées.

La première entrée sera :

• Animation, de type Chaîne.

Cette entrée sera utilisée pour informer le nom de l'animation qui doit être jouée.

La deuxième entrée sera :

• Fondu, de type Flottant.

Cette entrée sera utilisée pour contrôler le temps de transition entre les animations.

Ces paramètres rendent la fonction beaucoup plus flexible.

Au lieu de créer un bloc différent de nœuds pour chaque animation, nous pouvons utiliser la même fonction Jouer Animation et simplement passer un nom d'animation et une valeur de fondu différents chaque fois que nous l'appelons.

À partir de la sortie d'Obtenir Composant d'Animation, ajoutez le nœud Jouer par Nom.

Ce nœud est responsable de la lecture d'une animation en fonction de son nom.

Ensuite, connectez les paramètres Animation et Fondu que nous avons créés dans le nœud Entrées de Fonction aux champs correspondants du nœud Jouer par Nom.

Cela signifie qu'à chaque fois que la fonction Jouer Animation est appelée, elle recevra le nom de l'animation et le temps de fondu, puis passera ces valeurs à Jouer par Nom.

N'oubliez pas d'activer l'option Boucle dans le nœud Jouer par Nom.

Avec Boucle activée, l'animation continuera à jouer tant qu'elle est active, au lieu de s'arrêter lorsqu'elle atteint la dernière image. C'est particulièrement important pour des animations comme l'attente, la marche, la course et la chute, car elles doivent généralement continuer à jouer en continu.

Enfin, connectez la sortie Flux du nœud Jouer par Nom aux Sorties de Fonction, terminant l'exécution de la fonction Jouer Animation.

Il est maintenant beaucoup plus facile de jouer les animations de notre personnage.

Retournez au nœud Si qui vérifie si le Joueur est au sol ou non, et utilisez la fonction Jouer Animation.

Lorsque la condition est Vraie, cela signifie que le Joueur est au sol, appelez la fonction en passant "p-idle" comme paramètre d'animation. C'est l'animation utilisée lorsque le personnage est immobile.

Lorsque la condition est Fausse, cela signifie que le Joueur n'est pas au sol, appelez la fonction en passant "p-fall". C'est l'animation utilisée lorsque le personnage est en l'air.

Pour les deux cas, utilisez 0.1 comme valeur de Fondu. Cela donne à l'animation un petit temps de transition, rendant le changement plus fluide plutôt que de passer instantanément d'une animation à une autre.

Nous devons maintenant simplement appeler l'événement Mettre à Jour les Animations dans le flux de l'événement Déplacer Joueur.

De cette manière, chaque fois que la logique de mouvement du Joueur est mise à jour, la logique d'animation sera également mise à jour.

Avec cela, le Joueur pourra déjà passer entre p-idle et p-fall en fonction de son état actuel. Lorsque le Joueur est au sol, il jouera l'animation d'attente. Lorsque le Joueur est dans l'air, il jouera l'animation de chute.

Parfait. Continuons maintenant à développer la logique d'animation du Joueur en ajoutant les animations de mouvement.

Pour ce faire, obtenez la Direction de Marche et utilisez le nœud Longueur pour mesurer l'intensité du vecteur de mouvement.

La longueur du vecteur de mouvement nous indique si le personnage se déplace ou non.

Ajoutez ensuite un nœud Si pour vérifier si cette valeur est supérieure à 0.

Si le résultat est Vrai, cela signifie que le personnage est en déplacement, nous pouvons donc jouer l'animation de marche p-walk.

Si le résultat est Faux, cela signifie que le personnage ne bouge pas, nous devrions jouer l'animation d'attente p-idle.

Cela fait que le Joueur passe automatiquement de l'immobilité à la marche en fonction de son mouvement.

Maintenant, il y a deux autres détails à compléter le comportement de l'animation de mouvement de notre personnage :

Tout d'abord, nous devons jouer l'animation de course lorsque le Joueur court.

Deuxièmement, nous devons faire en sorte que le Joueur regarde dans la direction où il se déplace.

Pour contrôler les animations de marche et de course, ajoutez un nœud Séquence juste après la vérification qui détermine si le Joueur est en mouvement.

Ensuite, obtenez la propriété Est en Course et utilisez un nœud Si pour vérifier sa valeur.

Si Est en Course est Vrai, jouez l'animation de course.

Si Est en Course est Faux, jouez l'animation de marche.

De cette manière, le Joueur saura non seulement s'il est en mouvement ou arrêté, mais aussi s'il doit utiliser l'animation de marche ou de course en se déplaçant.

Sur la deuxième sortie Alors de la séquence que nous venons d'ajouter, utilisez le nœud Regarder Doucement.

Ce nœud fera tourner le personnage en douceur, lui permettant de regarder dans la direction où il se déplace. Cela rend le mouvement beaucoup plus naturel, car la maille du personnage se tournera visuellement dans la même direction que le mouvement.

Nous devons multiplier la valeur de Obtenir Direction de Marche par -1 avant de l'envoyer à Regarder Doucement.

Cela inverse le vecteur directionnel et corrige la direction dans laquelle la maille du personnage est orientée. En fonction de la manière dont le modèle de personnage a été importé ou orienté, la maille visuelle peut faire face à l'opposée du vecteur de mouvement. La multiplication par -1 corrige cela et fait en sorte que le personnage fasse face à la direction correcte tout en se déplaçant.

Après cela, connectez la direction déjà multipliée au nœud Regarder Doucement.

Ensuite, nous devons également fournir le Transforme de l'objet qui sera tourné.

Pour ce faire, accédez à l'Entité, puis obtenez la Maille du Joueur, et utilisez le nœud Obtenir Transforme.

Cette transformation doit être connectée à Regarder Doucement, en vous assurant que la rotation est appliquée à l'objet correct, qui est la maille visible du personnage.

À ce stade, la logique d'animation du Joueur est déjà beaucoup plus complète.

Le personnage peut maintenant passer d'animations d'attente, de chute, de marche et de course en fonction de son état actuel. Il se tourne également en douceur vers la direction du mouvement, rendant le contrôleur plus naturel et visuellement connecté à la logique de gameplay.