Lua Academy · Lekcja

Skryptowanie oparte na komponentach

Proszę projektować encje gry jako tabele z komponentami zachowania w Lua.

Skryptowanie oparte na komponentach to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Czym jest projektowanie oparte na komponentach?

Zamiast głębokich hierarchii klas encje są tworzone z komponentów — niewielkich, wyspecjalizowanych tabel zawierających dane i zachowanie. Encja jest po prostu zbiorem komponentów.

Encja jako tabela

Encja jest tabelą zawierającą id oraz podtabelę components. Komponenty są dodawane i usuwane w czasie działania programu.

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

Dodawanie komponentów

Dołącz komponent, ustawiając nazwany klucz w tabeli komponentów.

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

Systemy przetwarzają komponenty

System przetwarza wszystkie encje, które mają wymagany zestaw komponentów. Systemy iterują po encjach i aktualizują dane komponentów.

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

Skrypty komponentów

Dołącz funkcje Lua jako zachowanie komponentu — to prosta forma skryptowania dla poszczególnych encji.

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

Rejestr komponentów

Rejestr mapuje nazwy typów komponentów na funkcje fabrykujące, dzięki czemu komponenty można tworzyć na podstawie nazwy, na przykład z pliku poziomu.

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

Usuwanie komponentów

Ustaw komponent na nil, aby go usunąć. Encja będzie wtedy pomijana przez systemy, które go wymagają.

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

Menedżer świata i encji

Obiekt World przechowuje wszystkie encje i systemy, wykonuje iterację po systemach w każdym takcie oraz udostępnia interfejsy API do wyszukiwania encji.

Wyszukiwanie encji według komponentu

Udostępnij funkcję zapytania, która zwraca wszystkie encje mające wszystkie wskazane komponenty.

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

Prefabrykaty

Prefabrykat to szablonowa tabela komponentów. Twórz nowe encje na podstawie prefabrykatów, wykonując głęboką kopię szablonu.

Zalety w porównaniu z dziedziczeniem

Brak głębokich hierarchii.
Łączenie zachowań w czasie działania programu.
Łatwe dodawanie i usuwanie funkcji.
Konfiguracja oparta na danych.

Pytanie o projektowanie komponentów

Co robi system w projektowaniu opartym na komponentach?

Podsumowanie: skryptowanie oparte na komponentach

Encje są tabelami komponentów. Systemy przetwarzają encje z wymaganymi komponentami. Ta rozdzielona, oparta na danych architektura jest bardziej elastyczna niż głębokie hierarchie dziedziczenia i naturalnie pasuje do Lua.

Często zadawane pytania

Czy lekcja „Skryptowanie oparte na komponentach” jest bezpłatna?

Tak — pełny tekst „Skryptowanie oparte na komponentach” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Skryptowanie oparte na komponentach”?

Proszę projektować encje gry jako tabele z komponentami zachowania w Lua. Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Skryptowanie oparte na komponentach”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?

Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Systemy zdarzeń w Lua
Skryptowanie oparte na komponentach
Zachowanie AI z maszynami stanów
Konfiguracja sterowana danymi i hot-reload

← Powrót do Lua Academy