0Pricing
Lua Academy · Lekcja

Systemy zdarzeń w Lua

Proszę budować lekki dispatcher zdarzeń z callbackami przechowywanymi w tabelach.

Systemy zdarzeń w Lua to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 1 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.

Dlaczego systemy zdarzeń?

System zdarzeń rozdziela producentów (elementy wywołujące zdarzenia) od konsumentów (elementy reagujące na nie). W Lua można go łatwo zbudować za pomocą tabel funkcji zwrotnych.

Prosty dispatcher zdarzeń

Dispatcher przechowuje listy nasłuchiwaczy przypisane do nazw zdarzeń.

local EventEmitter = {}
EventEmitter.__index = EventEmitter

function EventEmitter.new()
  return setmetatable({_listeners = {}}, EventEmitter)
end

function EventEmitter:on(event, fn)
  self._listeners[event] = self._listeners[event] or {}
  table.insert(self._listeners[event], fn)
end

function EventEmitter:emit(event, ...)
  for _, fn in ipairs(self._listeners[event] or {}) do
    fn(...)
  end
end

Korzystanie z dispatchera

Subskrybuj zdarzenia za pomocą :on i wywołuj je za pomocą :emit.

local bus = EventEmitter.new()
bus:on("playerHit", function(player, damage)
  player.hp = player.hp - damage
  print(player.name, "took", damage, "damage")
end)
bus:emit("playerHit", {name="Alice", hp=100}, 15)

Odbiorniki jednorazowe

Metoda :once opakowuje funkcję zwrotną, aby po pierwszym wywołaniu wyrejestrowała samą siebie.

function EventEmitter:once(event, fn)
  local wrapper
  wrapper = function(...)
    self:off(event, wrapper)
    fn(...)
  end
  self:on(event, wrapper)
end

Usuwanie odbiorników

Metoda :off usuwa konkretny odbiornik na podstawie jego referencji.

function EventEmitter:off(event, fn)
  local list = self._listeners[event]
  if not list then return end
  for i, f in ipairs(list) do
    if f == fn then table.remove(list, i); return end
  end
end

Kolejki zdarzeń z priorytetami

Dodaj pole priorytetu do każdego odbiornika. Posortuj listę podczas rejestracji, aby procedury obsługi o wysokim priorytecie były uruchamiane jako pierwsze.

Asynchroniczna kolejka zdarzeń

Zamiast natychmiast wywoływać odbiorniki, umieszczaj zdarzenia w kolejce i przetwarzaj je w każdej klatce lub takcie.

local queue = {}
local function postEvent(event, data)
  queue[#queue+1] = {event=event, data=data}
end
local function processEvents()
  local current = queue
  queue = {}
  for _, e in ipairs(current) do
    bus:emit(e.event, e.data)
  end
end

Zapobieganie modyfikacjom podczas emitowania

Podczas emitowania iteruj po kopii listy odbiorników, aby dodawanie lub usuwanie odbiorników w trakcie emitowania nie powodowało błędów.

Zdarzenia z przestrzeniami nazw

Używaj nazw zdarzeń z kropkami ("player.damaged", "player.healed"), aby porządkować zdarzenia według systemu.

Tabele odbiorników ze słabymi odwołaniami

Używaj tabel odbiorników ze słabymi wartościami, aby po usunięciu obiektu subskrybenta przez GC jego odbiornik był automatycznie usuwany — zapobiega to wyciekom pamięci w długo działających grach.

Integracja z główną pętlą gry

Zintegruj system zdarzeń z główną pętlą gry: zdarzenia wejściowe → zdarzenia logiki → zdarzenia renderowania, przetwarzane w tej kolejności w każdej klatce.

Pytanie o system zdarzeń

Jaka jest główna korzyść z zastosowania systemu zdarzeń?

Podsumowanie: systemy zdarzeń

Systemy zdarzeń w Lua używają tabeli nazwanych list odbiorników. Zaimplementuj on, emit, off i once, aby utworzyć kompletny dyspozytor. W produkcyjnych grach używaj kolejek asynchronicznych i słabych tabel.

Często zadawane pytania

Czy lekcja „Systemy zdarzeń w Lua” jest bezpłatna?

Tak — pełny tekst „Systemy zdarzeń w Lua” 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 „Systemy zdarzeń w Lua”?

Proszę budować lekki dispatcher zdarzeń z callbackami przechowywanymi w tabelach. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Systemy zdarzeń w Lua”?

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

  1. Systemy zdarzeń w Lua
  2. Skryptowanie oparte na komponentach
  3. Zachowanie AI z maszynami stanów
  4. Konfiguracja sterowana danymi i hot-reload
← Powrót do Lua Academy