Cave : Guide pour débutants

À mesure que votre gameplay se développe, vous aurez éventuellement besoin d'objets qui se comportent différemment en fonction de ce qu'ils font actuellement. Un ennemi peut être inactif, patrouiller, chasser, attaquer, être sonné ou mort. Une porte peut être fermée, en train de s'ouvrir, ouverte ou verrouillée. Un combat de boss peut passer par plusieurs phases.

C'est là que les Machines à États deviennent utiles.

Dans l'image ci-dessus, vous pouvez voir l'ennemi par défaut que Crave crée pour le nouveau projet, avec sa Machine à États ouverte sur le côté droit. Nous sommes à l'intérieur de l'état "wander" qui a des états internes, tels que le "random selector" (l'état initial, représenté par la couleur verte), le "go to random" et le "idle". Vous pouvez voir les transitions entre les états représentées par les flèches, et que chaque état peut avoir sa propre logique, soit en Python, comme montré dans l'image, soit dans des blocs logiques.

Une machine à états vous aide à organiser le comportement en états clairs plutôt que d'écrire un gros script rempli de conditions non liées.

Dans cette leçon, vous apprendrez :

• Ce qu'est un État.
• Ce qu'est une Transition.
• Pourquoi les machines à états hiérarchiques sont utiles.
• Comment le Composant de Machine à États de Cave s'intègre dans une entité.
• Comment fonctionnent On Enter, On Update et On Exit.
• Comment Python et les Blocs Logiques peuvent être utilisés à l'intérieur des états et des transitions.

L'objectif est d'abord de comprendre le modèle mental. Une fois que cela a du sens, l'éditeur devient beaucoup plus facile à utiliser.

Qu'est-ce qu'un État ?

Un état décrit ce qu'un objet est en train de faire actuellement.

Par exemple, un ennemi pourrait avoir ces états :

• Idle
• Patrol
• Chase
• Attack
• Dead

Un seul de ces états devrait généralement contrôler l'ennemi à un moment donné. Si l'ennemi est en Patrol, il ne devrait pas aussi exécuter le comportement d'attaque. S'il est en Dead, il ne devrait pas continuer à chasser le joueur.

Cela rend le gameplay plus facile à comprendre car chaque état a un objectif clair.

Au lieu de demander "qu'est-ce que l'ennemi doit faire cette image ?" d'un gros script, vous pouvez demander "dans quel état l'ennemi est-il actuellement ?"

Qu'est-ce qu'une Transition ?

Une transition est la règle qui déplace la machine à états d'un état à un autre.

Par exemple :

• Idle à Patrol lorsque l'ennemi doit commencer à se déplacer, après un minuteur.
• Patrol à Chase lorsque le joueur est détecté.
• Chase à Attack lorsque l'ennemi est suffisamment proche.
• Attack à Chase lorsque l'attaque se termine.
• Quel que soit l'état à Dead lorsque la santé atteint zéro.

La transition n'est pas le comportement lui-même. C'est la décision qui dit : "maintenant nous devrions changer d'état."

Cette séparation est importante. L'état Attack peut se concentrer sur l'attaque, tandis que la transition décide quand il est temps d'entrer ou de quitter cet état.

Pourquoi les Machines à États Hiérarchiques Aident

Cave utilise une approche de machine à états hiérarchique. Cela signifie que les états peuvent être organisés à l'intérieur d'autres états. C'est utile car de nombreux comportements partagent une idée parentale commune.

Par exemple, un ennemi pourrait être organisé comme ceci :

Alive
    Idle
    Patrol
    Chase
    Attack
Dead

Les états Idle, Patrol, Chase et Attack appartiennent tous à l'état plus large Alive. Cela rend la structure plus facile à comprendre et peut vous aider à éviter de répéter la même logique à plusieurs endroits.

Pour un projet de débutant, vous pouvez commencer avec une simple machine à états plate. Mais à mesure que votre gameplay devient plus complexe, la hiérarchie aide à garder la logique propre.

Le Composant de Machine à États

Pour utiliser une machine à états dans une scène, une entité a besoin d'un Composant de Machine à États.

Le composant connecte l'entité à un actif de Machine à États. L'actif définit les états, les transitions et la logique, tandis que le composant exécute cette logique sur l'entité pendant le gameplay.

C'est similaire à d'autres systèmes de Cave :

En pratique, cela signifie que votre entité ennemie peut avoir un Composant de Machine à États, et que ce composant peut exécuter une machine à états d'IA ennemie.

Un actif de machine à états peut avoir des propriétés, comme vous pouvez le voir en allant à l'onglet des propriétés, et ces propriétés peuvent être modifiées localement dans le composant de machine à états, vous permettant de créer des machines à états modulaires qui ont des réglages différents pour différents types d'entités.

Événements d'État

Chaque état peut réagir à trois moments importants :

Par exemple, un état Attack pourrait fonctionner comme ceci :

• On Enter : jouer l'animation d'attaque.
• On Update : attendre le moment du coup ou le rappel d'animation.
• On Exit : effacer le drapeau d'attaque.

Cela donne à chaque état l'impression d'un petit comportement autonome.

Python à l'Intérieur des États

Les machines à états peuvent utiliser Python pour la logique.

À l'intérieur du code Python de chaque État, Cave fournit des variables utiles telles que entity et scene, afin que l'état puisse contrôler l'entité qui possède le Composant de Machine à États.

Par exemple, un état pourrait jouer un son lorsqu'il est entré :

cave.playSound("Enemy Alert", volume=0.8)

Ou il pourrait lire une propriété de l'entité :

health = entity.properties.get("health", 100)

Cela garde la logique d'état proche du comportement auquel elle appartient.

Python à l'Intérieur des Transitions

Les transitions peuvent également utiliser Python. Pour la logique Python de transition, Cave utilise une variable appelée result. Si result devient True, la transition peut se produire. Par exemple, une transition vers un état Dead pourrait vérifier la santé comme ceci :

health = entity.properties.get("health", 100)
result = health <= 0

Une transition de Chase à Attack pourrait vérifier la distance si votre script d'ennemi ou ses propriétés fournissent cette valeur :

player = scene.get("Player")
playerPos = player.getTransform().getWorldPosition()
entityPos = entity.getTransform().getWorldPosition()

distanceToPlayer = (playerPos - entityPos).length()
result = distanceToPlayer < 2.0

Les données exactes dépendent de votre jeu, mais l'idée est toujours la même : la transition décide s'il est temps de passer d'un état à un autre.

ASTUCE: Pendant une transition, toutes les variables locales définies dans l'état d'où provient la transition sont disponibles pour vous. Donc dans l'exemple précédent, où nous avons calculé la distance entre l'entité et le joueur, nous pourrions stocker la transformation du joueur et la transformation de l'entité sur deux variables à l'état d'entrée de l'état d'où cette transition provient pour économiser un peu de ressources, puisque c'est alors mis en cache et nous n'aurions plus besoin d'obtenir ces données chaque image.

Blocs Logiques à l'Intérieur des Machines à États

Les machines à états peuvent également utiliser des Blocs Logiques.

C'est utile lorsque vous souhaitez construire un comportement visuellement plutôt que d'écrire du code Python. Pour de nombreuses tâches de gameplay, les Blocs Logiques sont un moyen très accessible de connecter des événements, des conditions et des actions.

Ils fonctionnent exactement de la même manière que ce qui a été expliqué ci-dessus pour le code Python à l'intérieur de l'état ou d'une transition. Les Blocs Logiques de l'État et les Blocs Logiques de la Transition sont déjà initialisés avec les blocs dont vous avez besoin pour commencer.

Vous pouvez mélanger Python et Blocs Logiques en fonction de ce qui semble le plus clair pour le comportement que vous construisez. Si un État ou une Transition a les deux, alors les deux seront exécutés et la transition se produira si l'un OU l'autre se produit.

Quand Utiliser une Machine à États

Utilisez une machine à états lorsqu'un objet a des modes de comportement clairs.

De bons exemples incluent :

• IA ennemie.
• Phases de boss.
• Portes et objets interactifs.
• Flux de missions ou de quêtes.
• Progression des cinématiques.
• États de capacité de personnage.

Vous n'aurez peut-être pas besoin d'une machine à états pour de tout petits objets à action unique. Si un ramassage ne joue qu'un son et disparaît, un petit script Python ou un ensemble de Blocs Logiques peut suffire.

Ce que Vous Devez Retenir

Une machine à états organise le gameplay en états et transitions.

Les états décrivent ce qui se passe actuellement. Les transitions décident quand passer à autre chose. On Enter, On Update et On Exit aident à garder chaque état concentré et lisible.

Pour un comportement simple, un script peut être suffisant. Pour un comportement avec plusieurs modes, une machine à états rend généralement la logique plus facile à comprendre et à étendre.