0Pricing
Lua Academy · Leçon

Comportement de l’IA avec les machines à états

Implémentez entièrement en scripts Lua la logique d’IA des ennemis fondée sur FSM.

Comportement de l’IA avec les machines à états est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce qu'une machine à états finis ?

Une machine à états finis (FSM) définit le comportement comme un ensemble d'états reliés par des transitions déclenchées par des conditions ou des événements.

Structure d'une table FSM

Représentez une FSM sous forme de table contenant l'état actuel, une table d'états et, éventuellement, des fonctions de rappel d'entrée, de sortie et de mise à jour pour chaque état.

local function newFSM(initialState)
  return {
    current = initialState,
    states  = {},
  }
end

Définir les états

Chaque état est une table contenant éventuellement les fonctions enter, update et exit.

local fsm = newFSM("idle")
fsm.states.idle = {
  enter  = function(self) print("Enter idle") end,
  update = function(self, dt)
    if self.enemy then self:transition("chase") end
  end,
  exit   = function(self) print("Exit idle") end
}

Ajouter l'état de poursuite

L'état de poursuite suit le joueur et passe à l'attaque lorsqu'il est suffisamment proche.

fsm.states.chase = {
  enter = function(self) print("Chasing!") end,
  update = function(self, dt)
    if self.distToPlayer < 2 then
      self:transition("attack")
    elseif not self.enemy then
      self:transition("idle")
    end
  end
}

Fonction de transition

Une transition appelle exit sur l'état actuel, change d'état, puis appelle enter sur le nouvel état.

function fsm:transition(newState)
  local cur = self.states[self.current]
  if cur and cur.exit then cur:exit() end
  self.current = newState
  local next = self.states[newState]
  if next and next.enter then next:enter() end
end

Mettre à jour la FSM

À chaque cycle de jeu, appelez fsm:update(dt) pour exécuter la logique de mise à jour de l'état actuel.

function fsm:update(dt)
  local state = self.states[self.current]
  if state and state.update then
    state:update(dt)
  end
end

Machines à états hiérarchiques

Les états peuvent contenir des FSM imbriquées. Un état parent gère le comportement général (combat ou patrouille), tandis que les FSM enfants gèrent les détails propres à chaque état parent.

FSM pilotées par les données

Définissez les transitions des FSM sous forme de tables de données chargées depuis des fichiers de configuration. Les concepteurs peuvent ainsi ajuster l'IA sans modifier le code.

local transitions = {
  idle  = {seeEnemy = "chase"},
  chase = {lostEnemy = "idle", nearEnemy = "attack"},
  attack = {enemyDead = "idle"},
}

Machines à états empilées

Une pile d'états permet d'empiler des états temporaires, par exemple « étourdi », au-dessus de l'état actuel, puis de reprendre celui-ci une fois l'état temporaire terminé.

Plusieurs agents d'IA

Chaque entité ennemie possède sa propre instance de FSM, de sorte que son IA s'exécute indépendamment. Cette approche est simple avec les tables et les fermetures Lua.

Déboguer une FSM

Consignez toutes les transitions pendant le développement. Une table de trace stocke {from, to, time} pour analyser a posteriori le comportement de l'IA.

Question sur les FSM

Qu'est-ce qui déclenche une transition d'état dans une FSM ?

Récapitulatif : IA avec des machines à états

Les FSM Lua utilisent une table d'objets d'état (enter/update/exit) avec une fonction de transition. Elles séparent clairement les responsabilités de l'IA, prennent en charge une conception pilotée par les données et s'adaptent aussi bien aux comportements simples d'ennemis qu'aux arbres de comportement hiérarchiques complexes.

Questions Fréquemment Posées

La leçon « Comportement de l’IA avec les machines à états » est-elle gratuite ?

Oui — le texte complet de « Comportement de l’IA avec les machines à états » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comportement de l’IA avec les machines à états » ?

Implémentez entièrement en scripts Lua la logique d’IA des ennemis fondée sur FSM. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Comportement de l’IA avec les machines à états » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Systèmes d’événements en Lua
  2. Scripts fondés sur des composants
  3. Comportement de l’IA avec les machines à états
  4. Configuration pilotée par les données et rechargement à chaud
← Retour à Lua Academy