Lua Academy · Les

Componentgebaseerd scripten

Ontwerp game-entiteiten als tables met gedragscomponenten in Lua

Les 2 van 413 stappen

Componentgebaseerd scripten is een gratis Lua Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Wat is componentgebaseerd ontwerp?

In plaats van diepe klassehiërarchieën worden entiteiten samengesteld uit componenten — kleine, gerichte tabellen met gegevens en gedrag. Een entiteit is simpelweg een verzameling componenten.

Entiteit als tabel

Een entiteit is een tabel met een id en een subtabel components. Componenten worden tijdens runtime toegevoegd en verwijderd.

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

Componenten toevoegen

Koppel een component door een benoemde sleutel in de componententabel in te stellen.

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

Systemen verwerken componenten

Een systeem verwerkt alle entiteiten die een vereiste set componenten hebben. Systemen itereren over entiteiten en werken componentgegevens bij.

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

Componentscripts

Koppel Lua-functies als gedrag aan componenten — een eenvoudige vorm van scripting per entiteit.

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

Componentenregister

Een register koppelt namen van componenttypen aan fabrieksfuncties, zodat componenten op naam kunnen worden gemaakt (bijvoorbeeld vanuit een levelbestand).

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

Componenten verwijderen

Stel het component in op nil om het te verwijderen. De entiteit wordt daarna genegeerd door systemen die het component vereisen.

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

Wereld- en entiteitenbeheerder

Een World-object slaat alle entiteiten en systemen op, itereert bij elke tick over de systemen en biedt API's om entiteiten op te vragen.

Entiteiten opvragen per component

Bied een queryfunctie die alle entiteiten retourneert die alle opgegeven componenten hebben.

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

Prefabs

Een prefab is een sjabloontabel met componenten. Maak nieuwe entiteiten vanuit prefabs door het sjabloon diep te kopiëren.

Voordelen ten opzichte van overerving

Geen diepe hiërarchieën.
Gedrag wordt tijdens runtime gecombineerd.
Functies zijn eenvoudig toe te voegen en te verwijderen.
De gegevens worden gestuurd door configuratiebestanden.

Vraag over componentontwerp

Wat doet een systeem bij componentgebaseerd ontwerp?

Beantwoord dit in de interactieve les

Samenvatting: componentgebaseerde scripting

Entiteiten zijn tabellen met componenten. Systemen verwerken entiteiten met vereiste componenten. Deze ontkoppelde, gegevensgestuurde architectuur is flexibeler dan diepe overervingshiërarchieën en werkt van nature goed in Lua.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Componentgebaseerd scripten” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Componentgebaseerd scripten”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Componentgebaseerd scripten”?

Ontwerp game-entiteiten als tables met gedragscomponenten in Lua Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Componentgebaseerd scripten”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Gebeurtenissystemen in Lua
Componentgebaseerd scripten
AI-gedrag met toestandsmachines
Datagestuurde configuratie en hot reload

← Terug naar Lua Academy