0Pricing
Lua Academy · Lektion

Komponentenbasierte Skripterstellung

Entwerfen Sie Spielfiguren in Lua als Tabellen mit Verhaltenskomponenten

Komponentenbasierte Skripterstellung ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist komponentenbasierter Entwurf?

Statt tiefer Klassenhierarchien werden Entitäten aus Komponenten zusammengesetzt – kleinen, klar fokussierten Tabellen mit Daten und Verhalten. Eine Entität ist lediglich eine Sammlung von Komponenten.

Entität als Tabelle

Eine Entität ist eine Tabelle mit einer id und einer Untertabelle components. Komponenten werden zur Laufzeit hinzugefügt und entfernt.

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

Komponenten hinzufügen

Hängen Sie eine Komponente an, indem Sie in der Komponententabelle einen benannten Schlüssel setzen.

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

Systeme verarbeiten Komponenten

Ein System verarbeitet alle Entitäten, die über eine bestimmte erforderliche Komponentenmenge verfügen. Systeme durchlaufen Entitäten und aktualisieren Komponentendaten.

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

Komponentenskripte

Hängen Sie Lua-Funktionen als Verhalten an Komponenten an – eine einfache Form von Scripting pro Entität.

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

Komponentenregister

Ein Register ordnet Namen von Komponententypen Factory-Funktionen zu. Dadurch können Komponenten anhand ihres Namens erstellt werden, etwa aus einer Leveldatei.

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

Komponenten entfernen

Setzen Sie die Komponente auf nil, um sie zu entfernen. Die Entität wird anschließend von Systemen ignoriert, die diese Komponente voraussetzen.

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

World- und Entitätenverwaltung

Ein World-Objekt speichert alle Entitäten und Systeme, durchläuft die Systeme in jedem Tick und stellt APIs zum Abfragen von Entitäten bereit.

Entitäten nach Komponenten abfragen

Stellen Sie eine Abfragefunktion bereit, die alle Entitäten zurückgibt, die über sämtliche angegebenen Komponenten verfügen.

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

Ein Prefab ist eine Vorlagentabelle aus Komponenten. Erstellen Sie neue Entitäten aus Prefabs, indem Sie die Vorlage tief kopieren.

Vorteile gegenüber Vererbung

  • Keine tiefen Hierarchien.
  • Verhalten wird zur Laufzeit kombiniert.
  • Funktionen lassen sich einfach hinzufügen und entfernen.
  • Daten werden aus Konfigurationsdateien gesteuert.

Frage zum Komponentendesign

Welche Aufgabe hat ein System im komponentenbasierten Entwurf?

Zusammenfassung: komponentenbasiertes Scripting

Entitäten sind Tabellen aus Komponenten. Systeme verarbeiten Entitäten mit den erforderlichen Komponenten. Diese entkoppelte, datengetriebene Architektur ist flexibler als tiefe Vererbungshierarchien und eignet sich auf natürliche Weise für Lua.

Häufig gestellte Fragen

Ist die Lektion „Komponentenbasierte Skripterstellung“ kostenlos?

Ja — der vollständige Text von „Komponentenbasierte Skripterstellung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Komponentenbasierte Skripterstellung“?

Entwerfen Sie Spielfiguren in Lua als Tabellen mit Verhaltenskomponenten Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Komponentenbasierte Skripterstellung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Ereignissysteme in Lua
  2. Komponentenbasierte Skripterstellung
  3. KI-Verhalten mit Zustandsautomaten
  4. Datengetriebene Konfiguration und Hot-Reload
← Zurück zu Lua Academy