Lua Academy · Leçon

Scripts fondés sur des composants

Concevez des entités de jeu sous forme de tables contenant des composants comportementaux en Lua.

Scripts fondés sur des composants est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 conception fondée sur les composants ?

Au lieu de hiérarchies profondes de classes, les entités sont composées de composants — de petites tables ciblées contenant des données et un comportement. Une entité n'est qu'un ensemble de composants.

L'entité comme table

Une entité est une table possédant un id et une sous-table components. Les composants sont ajoutés et supprimés lors de l'exécution.

local function newEntity(id)
  return {id = id, components = {}}
end
local player = newEntity(1)

Ajouter des composants

Attachez un composant en définissant une clé nommée dans la table des composants.

player.components.position = {x=0, y=0}
player.components.health   = {hp=100, max=100}
player.components.sprite   = {image="player.png", scale=1}

Les systèmes traitent les composants

Un système traite toutes les entités qui possèdent l'ensemble requis de composants. Les systèmes parcourent les entités et mettent à jour les données des composants.

local function moveSystem(entities, dt)
  for _, e in ipairs(entities) do
    local pos = e.components.position
    local vel = e.components.velocity
    if pos and vel then
      pos.x = pos.x + vel.dx * dt
      pos.y = pos.y + vel.dy * dt
    end
  end
end

Scripts de composants

Attachez des fonctions Lua comme comportement de composant — une forme simple de script par entité.

player.components.ai = {
  update = function(self, entity, dt)
    -- move towards target
  end
}

Registre des composants

Un registre associe les noms de types de composants à des fonctions de création, ce qui permet de créer des composants par leur nom, par exemple depuis un fichier de niveau.

local registry = {}
function registry.register(name, factory)
  registry[name] = factory
end
function registry.create(name, ...)
  return registry[name](...)
end

Supprimer des composants

Définissez le composant à nil pour le supprimer. L'entité sera alors ignorée par les systèmes qui l'exigent.

player.components.health = nil  -- entity is "dead"

Gestionnaire du monde et des entités

Un objet World stocke toutes les entités et tous les systèmes, parcourt les systèmes à chaque cycle et fournit des API d'interrogation des entités.

Rechercher des entités par composant

Fournissez une fonction de requête qui renvoie toutes les entités possédant tous les composants indiqués.

local function query(world, ...)
  local required = {...}
  local result = {}
  for _, e in ipairs(world.entities) do
    local ok = true
    for _, comp in ipairs(required) do
      if not e.components[comp] then ok = false; break end
    end
    if ok then result[#result+1] = e end
  end
  return result
end

Préfabriqués

Un préfabriqué est une table modèle de composants. Instanciez de nouvelles entités à partir de préfabriqués en copiant le modèle en profondeur.

Avantages par rapport à l'héritage

Pas de hiérarchies profondes.
Comportement combiné lors de l'exécution.
Fonctionnalités faciles à ajouter ou à supprimer.
Données pilotées par des fichiers de configuration.

Question sur la conception par composants

Dans une conception fondée sur les composants, que fait un système ?

Récapitulatif : scripts fondés sur les composants

Les entités sont des tables de composants. Les systèmes traitent les entités possédant les composants requis. Cette architecture découplée et pilotée par les données est plus flexible que les hiérarchies d'héritage profondes et s'intègre naturellement à Lua.

Questions Fréquemment Posées

La leçon « Scripts fondés sur des composants » est-elle gratuite ?

Oui — le texte complet de « Scripts fondés sur des composants » 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 « Scripts fondés sur des composants » ?

Concevez des entités de jeu sous forme de tables contenant des composants comportementaux en Lua. 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 2 sur 4.

Combien de temps prend la leçon « Scripts fondés sur des composants » ?

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

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

← Retour à Lua Academy