0Pricing
Lua Academy · Lezione

Scripting basato sui componenti

Progetti le entità di gioco come tabelle con componenti comportamentali in Lua.

Scripting basato sui componenti è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Che cos'è la progettazione basata sui componenti

Anziché utilizzare gerarchie di classi profonde, le entità sono composte da componenti: piccole tabelle focalizzate su dati e comportamento. Un'entità è semplicemente una raccolta di componenti.

L'entità come tabella

Un'entità è una tabella con un id e una sotto-tabella components. I componenti vengono aggiunti e rimossi durante l'esecuzione.

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

Aggiunta dei componenti

Colleghi un componente impostando una chiave denominata nella tabella dei componenti.

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

I sistemi elaborano i componenti

Un sistema elabora tutte le entità che possiedono un insieme richiesto di componenti. I sistemi iterano sulle entità e aggiornano i dati dei componenti.

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

Script dei componenti

Colleghi funzioni Lua come comportamento del componente: una forma semplice di scripting per ogni entità.

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

Registro dei componenti

Un registro associa i nomi dei tipi di componente a funzioni factory, consentendo di creare i componenti per nome, ad esempio a partire da un file di livello.

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

Rimozione dei componenti

Imposti il componente su nil per rimuoverlo. L'entità verrà quindi ignorata dai sistemi che lo richiedono.

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

Gestore del mondo e delle entità

Un oggetto World memorizza tutte le entità e i sistemi, itera sui sistemi a ogni tick e fornisce API per interrogare le entità.

Interrogazione delle entità per componente

Fornisca una funzione di query che restituisca tutte le entità dotate di tutti i componenti specificati.

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

Prefab

Un prefab è una tabella modello di componenti. Istanzi nuove entità dai prefab copiando in profondità il modello.

Vantaggi rispetto all'ereditarietà

  • Nessuna gerarchia profonda.
  • Comportamento combinato durante l'esecuzione.
  • Funzionalità facili da aggiungere o rimuovere.
  • Gestione guidata dai dati dei file di configurazione.

Domanda sulla progettazione dei componenti

Nella progettazione basata sui componenti, che cosa fa un System?

Riepilogo: scripting basato sui componenti

Le entità sono tabelle di componenti. I sistemi elaborano le entità con i componenti richiesti. Questa architettura disaccoppiata e guidata dai dati è più flessibile delle gerarchie di ereditarietà profonde e si adatta naturalmente a Lua.

Domande Frequenti

La lezione «Scripting basato sui componenti» è gratuita?

Sì — il testo completo di «Scripting basato sui componenti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Scripting basato sui componenti»?

Progetti le entità di gioco come tabelle con componenti comportamentali in Lua. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Scripting basato sui componenti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Sistemi di eventi in Lua
  2. Scripting basato sui componenti
  3. Comportamento dell'IA con macchine a stati
  4. Configurazione data-driven e hot reload
← Torna a Lua Academy