Finished automatically generated docs

Time to correct it by itself
2026-05-20 22:49:46 +02:00
parent df6cf2f3d3
commit 198d9cf477
35 changed files with 6120 additions and 73 deletions
--- a/docs/pl/reference/BUTTON.md
+++ b/docs/pl/reference/BUTTON.md
@@ -0,0 +1,249 @@
+# BUTTON
+
+Interaktywny przycisk z trzema stanami wizualnymi (normalny, najechany, wciśnięty) oraz osobnymi grafikami i dźwiękami dla każdego z nich. Przycisk można dodatkowo wyłączyć — albo całkowicie (`DISABLE`), albo z zachowaniem widoczności (`DISABLEBUTVISIBLE`).
+
+Wewnętrznie przycisk jest maszyną stanów. Każde przejście stanu automatycznie pokazuje lub ukrywa odpowiednie grafiki, odtwarza powiązany dźwięk oraz może wyemitować sygnał.
+
+## Stany przycisku
+
+| Stan | Znaczenie |
+| --- | --- |
+| `STANDARD` | spoczynek — pokazywana jest grafika z `GFXSTANDARD`. |
+| `HOVERED` | kursor jest nad obszarem przycisku — pokazywana jest grafika z `GFXONMOVE` (jeśli ustawiona, w przeciwnym razie nadal `GFXSTANDARD`). |
+| `PRESSED` | przycisk jest aktualnie wciśnięty — pokazywana jest grafika z `GFXONCLICK` (jeśli ustawiona, w przeciwnym razie nadal `GFXSTANDARD`). |
+| `DISABLED` | przycisk wyłączony i ukryty. |
+| `DISABLED_BUT_VISIBLE` | przycisk wyłączony, ale pokazywana jest grafika z `GFXSTANDARD`. |
+
+## Pola
+
+### DRAGGABLE
+
+```
+BOOL DRAGGABLE
+```
+
+Określa, czy przycisk można przeciągać.
+
+### ENABLE
+
+```
+BOOL ENABLE
+```
+
+Określa, czy przycisk ma być włączony po inicjalizacji. Wartość `FALSE` umieszcza przycisk w stanie [`DISABLED`](#stany-przycisku).
+
+### GFXONCLICK
+
+```
+STRING GFXONCLICK
+```
+
+Nazwa zmiennej [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md) pokazywanej w stanie [`PRESSED`](#stany-przycisku). Pole opcjonalne — jeżeli nie zostanie ustawione, w stanie `PRESSED` nadal wyświetlana jest grafika z [`GFXSTANDARD`](#gfxstandard).
+
+### GFXONMOVE
+
+```
+STRING GFXONMOVE
+```
+
+Nazwa zmiennej [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md) pokazywanej w stanie [`HOVERED`](#stany-przycisku). Pole opcjonalne.
+
+### GFXSTANDARD
+
+```
+STRING GFXSTANDARD
+```
+
+Nazwa zmiennej [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md) wyświetlanej w stanie spoczynku. Jeżeli pole [`ENABLE`](#enable) zostało ustawione na `FALSE`, grafika jest automatycznie ukrywana po inicjalizacji — z jednym wyjątkiem: jeżeli powiązana animacja jest właśnie w trakcie odtwarzania, pozostaje widoczna (przykład: pochodnia w `16BLAWA` w *Reksio i Skarb Piratów*). W takim przypadku ustawienie [`TOCANVAS`](ANIMO.md#tocanvas) na powiązanej grafice nie ma znaczenia.
+
+### RECT
+
+```
+INTEGER, INTEGER, INTEGER, INTEGER RECT
+STRING RECT
+```
+
+Obszar reagujący na kursor. Pole może być podane na dwa sposoby:
+
+- Cztery liczby całkowite `xLeft,yBottom,xRight,yTop` definiujące prostokąt na ekranie.
+- Nazwa zmiennej typu [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md), z której pobierany jest bieżący prostokąt graficzny.
+
+Jeżeli pole nie zostanie ustawione, używany jest prostokąt zmiennej wskazanej przez [`GFXSTANDARD`](#gfxstandard).
+
+### SNDONCLICK
+
+```
+STRING SNDONCLICK
+```
+
+Nazwa zmiennej [`SOUND`](SOUND.md) odtwarzanej przy przejściu w stan [`PRESSED`](#stany-przycisku).
+
+### SNDONMOVE
+
+```
+STRING SNDONMOVE
+```
+
+Nazwa zmiennej [`SOUND`](SOUND.md) odtwarzanej przy przejściu w stan [`HOVERED`](#stany-przycisku).
+
+### SNDSTANDARD
+
+```
+STRING SNDSTANDARD
+```
+
+Nazwa zmiennej [`SOUND`](SOUND.md) odtwarzanej przy powrocie do stanu [`STANDARD`](#stany-przycisku).
+
+### VISIBLE
+
+```
+BOOL VISIBLE
+```
+
+Pole zapisywane w danych skryptowych, ale nieobserwowane przez silnik — z testów wynika, że jego wartość nie wpływa na żadne zachowanie przycisku.
+
+## Metody
+
+### DISABLE
+
+```
+void DISABLE()
+```
+
+Wyłącza przycisk i ukrywa powiązane z nim grafiki ustawione przez [`GFXSTANDARD`](#gfxstandard), [`GFXONMOVE`](#gfxonmove) i [`GFXONCLICK`](#gfxonclick). Grafiki podpięte przez [`RECT`](#rect) pozostają bez zmian.
+
+**Przykłady**
+
+```
+B_GLOBAL_PAUSE^DISABLE();
+```
+
+### DISABLEBUTVISIBLE
+
+```
+void DISABLEBUTVISIBLE()
+```
+
+Wyłącza przycisk, ale pozostawia widoczną grafikę z [`GFXSTANDARD`](#gfxstandard) (analogicznie do `DISABLE`, ale stan końcowy to [`DISABLED_BUT_VISIBLE`](#stany-przycisku)).
+
+**Przykłady**
+
+```
+BTNBONE^DISABLEBUTVISIBLE();
+BTNFORGOT^DISABLEBUTVISIBLE();
+```
+
+### ENABLE
+
+```
+void ENABLE()
+```
+
+Włącza przycisk i przywraca widoczność grafice z [`GFXSTANDARD`](#gfxstandard). Wywołanie na już włączonym przycisku nie ma efektu.
+
+**Przykłady**
+
+```
+B_GLOBAL_PAUSE^ENABLE();
+BTNEXIT^ENABLE();
+```
+
+### SETPRIORITY
+
+```
+void SETPRIORITY(INTEGER posZ)
+```
+
+Ustawia priorytet rysowania (pozycję w osi Z) dla wszystkich trzech grafik powiązanych z przyciskiem ([`GFXSTANDARD`](#gfxstandard), [`GFXONMOVE`](#gfxonmove), [`GFXONCLICK`](#gfxonclick)). Wyższa wartość oznacza rysowanie później (z wierzchu).
+
+**Parametry**
+
+- `posZ` — nowa wartość priorytetu.
+
+**Przykłady**
+
+```
+B_GLOBAL_PAUSE^SETPRIORITY(5001);
+BTNNULLFADE^SETPRIORITY(40000);
+```
+
+### SETRECT
+
+```
+void SETRECT(STRING varName)
+void SETRECT(INTEGER xLeft, INTEGER yBottom, INTEGER xRight, INTEGER yTop)
+```
+
+Ustawia obszar reagujący na kursor. Metoda ma dwie formy: pierwsza pobiera prostokąt z zadanej zmiennej [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md), druga definiuje go bezpośrednio przez koordynaty.
+
+**Parametry**
+
+- `varName` — nazwa zmiennej graficznej **(forma 1)**.
+- `xLeft`, `yBottom`, `xRight`, `yTop` — koordynaty prostokąta **(forma 2)**.
+
+**Przykłady**
+
+```
+EXITPROGAM^SETRECT("ANNEXIT");
+*STMP0^SETRECT([ITMPX+[ITMPDX*_I_]],[ITMPY+[ITMPDY*_I_]],[ITMPX+15+[ITMPDX*_I_]],[ITMPY+15+[ITMPDY*_I_]]);
+```
+
+### SETSTD
+
+```
+void SETSTD(STRING varName)
+void SETSTD(STRING varName, BOOL flag)
+```
+
+Ustawia grafikę standardową przycisku (pole [`GFXSTANDARD`](#gfxstandard)) i zeruje priorytet nowej grafiki. W skryptach gier występuje również forma dwuargumentowa z dodatkową flagą boolowską — zawsze wywoływana z wartością `FALSE`, znaczenie tego argumentu nie zostało ustalone.
+
+**Parametry**
+
+- `varName` — nazwa nowej zmiennej standardowej (pusty ciąg `""` czyści powiązanie).
+- `flag` — flaga konfiguracyjna **(forma 2, znaczenie nieustalone)**.
+
+**Przykłady**
+
+```
+BTNEXIT^SETSTD("ANNOBJECT2");
+B_GLOBAL_PAUSE^SETSTD("",FALSE);
+BTNBAD^SETSTD("ZLY",FALSE);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONFOCUSON
+
+Wywoływany przy przejściu ze stanu [`STANDARD`](#stany-przycisku) do [`HOVERED`](#stany-przycisku) — czyli gdy kursor wjedzie na przycisk.
+
+### ONFOCUSOFF
+
+Wywoływany przy przejściu z [`HOVERED`](#stany-przycisku) do [`STANDARD`](#stany-przycisku) — gdy kursor opuści przycisk.
+
+### ONCLICKED
+
+Wywoływany przy przejściu w stan [`PRESSED`](#stany-przycisku) (wciśnięcie przycisku myszy).
+
+### ONRELEASED
+
+Wywoływany przy przejściu z [`PRESSED`](#stany-przycisku) do [`HOVERED`](#stany-przycisku) — gdy przycisk myszy zostanie zwolniony nad obszarem przycisku.
+
+### ONACTION
+
+Wywoływany razem z [`ONRELEASED`](#onreleased) — sygnał potwierdzający, że nastąpiło kliknięcie (wciśnięcie i zwolnienie nad obszarem przycisku).
+
+### ONSTARTDRAGGING
+
+Wywoływany po rozpoczęciu przeciągania przycisku (dostępne tylko dla przycisków z polem [`DRAGGABLE`](#draggable) ustawionym na `TRUE`).
+
+### ONENDDRAGGING
+
+Wywoływany po zakończeniu przeciągania przycisku.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/CANVAS_OBSERVER.md
+++ b/docs/pl/reference/CANVAS_OBSERVER.md
@@ -0,0 +1,243 @@
+# CANVAS_OBSERVER
+
+Punkt dostępu do operacji na kanwie — wspólnym obszarze rysowania, na którym silnik wyświetla wszystkie widoczne obiekty graficzne. Udostępnia metody do dodawania i usuwania grafik z ekranu, pobierania nazwy obiektu pod kursorem, ustawiania tła, robienia zrzutów ekranu oraz emitowania sygnałów przy zmianie fokusu okna gry.
+
+Zazwyczaj w scenie istnieje pojedyncza instancja typu `CANVAS_OBSERVER`, do której wszystkie skrypty odwołują się jak do obiektu globalnego.
+
+## Metody
+
+### ADD
+
+```
+void ADD(STRING varName)
+void ADD(STRING varName, INTEGER priority)
+```
+
+Dodaje na kanwę zmienną [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md) — ustawia jej widoczność na `TRUE` i opcjonalnie nadaje priorytet rysowania (domyślnie `1000`).
+
+**Parametry**
+
+- `varName` — nazwa zmiennej graficznej.
+- `priority` — (opcjonalnie) priorytet rysowania (pozycja w osi Z).
+
+**Przykłady**
+
+```
+CANVASOBSERVER^ADD("ANNMKORBA2");
+CANVASOBSERVER^ADD("ANNMPRZEGRYZA");
+```
+
+### ENABLENOTIFY
+
+```
+void ENABLENOTIFY(BOOL enable)
+```
+
+Włącza lub wyłącza emitowanie sygnałów o zmianie fokusu okna gry ([`ONWINDOWFOCUSON`](#onwindowfocuson), [`ONWINDOWFOCUSOFF`](#onwindowfocusoff)).
+
+**Parametry**
+
+- `enable` — `TRUE` włącza notyfikacje, `FALSE` je wyłącza.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^ENABLENOTIFY(TRUE);
+```
+
+### GETBPP
+
+```
+INTEGER GETBPP()
+```
+
+Zwraca głębię koloru kanwy w bitach na piksel. Oryginalny silnik BlooMoo działa w trybie 16 bpp (RGB565) — metoda zawsze zwraca `16`.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — głębia koloru w bitach (`16`).
+
+### GETGRAPHICSAT
+
+```
+STRING GETGRAPHICSAT(INTEGER posX, INTEGER posY, BOOL onlyVisible, INTEGER minZ, INTEGER maxZ)
+STRING GETGRAPHICSAT(INTEGER posX, INTEGER posY, BOOL onlyVisible, INTEGER minZ, INTEGER maxZ, BOOL ignoreAlpha)
+```
+
+Zwraca nazwę zmiennej graficznej znajdującej się pod punktem `(posX, posY)`. Przeszukuje wyłącznie bieżącą scenę. Wyszukiwanie zaczyna od grafik o najwyższym priorytecie. Jeśli żaden obiekt nie spełnia warunków, zwracane jest `"NULL"`.
+
+**Parametry**
+
+- `posX`, `posY` — koordynaty sprawdzanego punktu.
+- `onlyVisible` — gdy `TRUE`, brane są pod uwagę tylko widoczne grafiki.
+- `minZ`, `maxZ` — zakres priorytetu (osi Z) ograniczający wyszukiwanie.
+- `ignoreAlpha` — (opcjonalnie) gdy `TRUE`, sprawdzany jest tylko prostokąt grafiki; gdy `FALSE` (lub pominięte), test uwzględnia kanał alfa piksela.
+
+**Zwraca**: [`STRING`](STRING.md) — nazwa znalezionego obiektu lub `"NULL"`.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^GETGRAPHICSAT(MOUSE^GETPOSX(),MOUSE^GETPOSY(),TRUE,2998,2998,FALSE);
+CANVASOBSERVER^GETGRAPHICSAT(VARICURSORX,VARICURSORY,TRUE,40,40,TRUE);
+```
+
+### GETGRAPHICSAT2
+
+```
+STRING GETGRAPHICSAT2(INTEGER posX, INTEGER posY, BOOL onlyVisible, INTEGER minZ, INTEGER maxZ)
+STRING GETGRAPHICSAT2(INTEGER posX, INTEGER posY, BOOL onlyVisible, INTEGER minZ, INTEGER maxZ, BOOL ignoreAlpha)
+```
+
+Wariant [`GETGRAPHICSAT`](#getgraphicsat) przeszukujący nie tylko bieżącą scenę, ale również nadrzędne kontenery (epizod, root).
+
+### MOVEBKG
+
+```
+void MOVEBKG(INTEGER deltaX, INTEGER deltaY)
+```
+
+Przesuwa tło o zadane wartości w osiach X i Y (względem aktualnej pozycji).
+
+**Parametry**
+
+- `deltaX`, `deltaY` — wektor przesunięcia w pikselach.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^MOVEBKG(0,ARRAYDY^GET(0));
+CANVASOBSERVER^MOVEBKG(ISCROLLMOVEX,ISCROLLMOVEY);
+```
+
+### PASTE
+
+```
+void PASTE(STRING varName, INTEGER posX, INTEGER posY)
+```
+
+Wkleja na kanwę kopię bieżącej zawartości grafiki [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md) w postaci statycznej, niemodyfikowalnej tekstury w punkcie `(posX, posY)`. Operacja nie wpływa na samą zmienną źródłową.
+
+**Parametry**
+
+- `varName` — nazwa zmiennej graficznej.
+- `posX`, `posY` — pozycja wklejenia.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^PASTE("ANNBUM",[I1-IPLANPOSX],[I2-IPLANPOSY]);
+CANVASOBSERVER^PASTE("IMG1",0,0);
+```
+
+### REDRAW
+
+```
+void REDRAW()
+```
+
+W oryginalnym silniku oznacza kanwę jako wymagającą ponownego rysowania. W praktyce silnik i tak rysuje całość każdą klatkę, więc metoda zachowuje się jak no-op.
+
+### REFRESH
+
+```
+void REFRESH()
+```
+
+Wymusza ponowne narysowanie wszystkich obiektów [`IMAGE`](IMAGE.md) w bieżącej scenie — wewnętrznie wywołuje na nich metodę [`INVALIDATE`](IMAGE.md#invalidate).
+
+### REMOVE
+
+```
+void REMOVE(STRING varName1, [STRING varName2, ...])
+```
+
+Ukrywa wymienione obiekty graficzne na kanwie (ustawia ich widoczność na `FALSE`). Metoda przyjmuje dowolną liczbę argumentów.
+
+**Parametry**
+
+- `varName1, varName2, …` — kolejne nazwy zmiennych graficznych do ukrycia.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^REMOVE("ZLY");
+CANVASOBSERVER^REMOVE("ANNAUTOR","ANNAUTOL","ANNAUTORMASK","ANNAUTOLMASK");
+```
+
+### SAVE
+
+```
+void SAVE(STRING imgFileName, DOUBLE xScaleFactor, DOUBLE yScaleFactor)
+void SAVE(STRING imgFileName, DOUBLE xScaleFactor, DOUBLE yScaleFactor, INTEGER xLeft, INTEGER yTop, INTEGER xRight, INTEGER yBottom)
+```
+
+Zapisuje aktualny widok kanwy do pliku `.IMG`. Forma siedmioargumentowa pozwala wyciąć prostokąt kanwy przed skalowaniem.
+
+**Parametry**
+
+- `imgFileName` — ścieżka docelowego pliku `.IMG`.
+- `xScaleFactor`, `yScaleFactor` — współczynniki skalowania w osiach X i Y.
+- `xLeft`, `yTop`, `xRight`, `yBottom` — (opcjonalnie) prostokąt do wycięcia przed skalowaniem.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^SAVE("$COMMON\PAGE.IMG",1,1);
+CANVASOBSERVER^SAVE("$COMMON\ZOOM.IMG",2,2,$1,$2,$3,$4);
+CANVASOBSERVER^SAVE(["$COMMON\SAVE_BD\BD_SCR"+VARISLOTNO+".IMG"],0.5,0.5);
+```
+
+### SETBACKGROUND
+
+```
+void SETBACKGROUND(STRING imageName)
+```
+
+Ustawia obraz tła kanwy. Argument może być nazwą istniejącej zmiennej [`IMAGE`](IMAGE.md) albo ścieżką do pliku `.IMG` — w drugim przypadku silnik utworzy ukryty obiekt [`IMAGE`](IMAGE.md) z plikiem.
+
+**Parametry**
+
+- `imageName` — nazwa zmiennej [`IMAGE`](IMAGE.md) lub ścieżka do pliku `.IMG`.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^SETBACKGROUND(SOBJECT|NAME);
+CANVASOBSERVER^SETBACKGROUND("LOGO.IMG");
+```
+
+### SETBKGPOS
+
+```
+void SETBKGPOS(INTEGER posX, INTEGER posY)
+```
+
+Ustawia bezwzględną pozycję tła w osiach X i Y.
+
+**Parametry**
+
+- `posX`, `posY` — nowa pozycja tła.
+
+**Przykłady**
+
+```
+CANVASOBSERVER^SETBKGPOS([VARI_BKGX-VARI_BKGXOFFSET],[VARI_BKGY-VARI_BKGYOFFSET]);
+CANVASOBSERVER^SETBKGPOS(VARI_TMPX,0);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONWINDOWFOCUSON
+
+Wywoływany po uzyskaniu fokusu przez okno gry (np. powrót z minimalizacji). Emisja działa tylko, gdy notyfikacje są włączone metodą [`ENABLENOTIFY`](#enablenotify).
+
+### ONWINDOWFOCUSOFF
+
+Wywoływany po utracie fokusu przez okno gry (np. przełączenie na inną aplikację). Emisja działa tylko, gdy notyfikacje są włączone.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/CNVLOADER.md
+++ b/docs/pl/reference/CNVLOADER.md
@@ -0,0 +1,55 @@
+# CNVLOADER
+
+Dynamiczny ładowacz plików `.CNV` w trakcie działania silnika. W przeciwieństwie do [`CLASS`](CLASS.md), który definiuje izolowany kontekst per-instancja, `CNVLOADER` doładowuje zmienne ze wskazanego pliku bezpośrednio do bieżącego kontekstu — zachowują się tak, jakby były tam zdefiniowane od początku.
+
+Jeden obiekt `CNVLOADER` może mieć jednocześnie załadowanych wiele plików `.CNV`. Każde wywołanie [`RELEASE`](#release) zwalnia jeden konkretny plik.
+
+## Metody
+
+### LOAD
+
+```
+void LOAD(STRING cnvFile)
+```
+
+Ładuje wskazany plik `.CNV`. Zmienne zdefiniowane w pliku zostają dodane do bieżącego kontekstu. Próba ponownego załadowania pliku już raz załadowanego jest ignorowana.
+
+**Parametry**
+
+- `cnvFile` — ścieżka do pliku `.CNV` (rozwiązywana przez VFS silnika).
+
+**Przykłady**
+
+```
+CNVLOADER^LOAD(VARSTEMP0);
+CNVLOADER^LOAD([G_SCUTSCENE+".CNV"]);
+```
+
+### RELEASE
+
+```
+void RELEASE(STRING cnvFile)
+```
+
+Zwalnia wcześniej załadowany plik — usuwa z bieżącego kontekstu wszystkie zmienne, które do niego należały. Wywołanie z plikiem, który nie został wcześniej załadowany, nie ma efektu.
+
+**Parametry**
+
+- `cnvFile` — ścieżka do uprzednio załadowanego pliku.
+
+**Przykłady**
+
+```
+CNVLOADER^RELEASE([G_SCUTSCENE+".CNV"]);
+CNVLOADER^RELEASE("WYNURZENIE.CNV");
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/DATABASE.md
+++ b/docs/pl/reference/DATABASE.md
@@ -0,0 +1,152 @@
+# DATABASE
+
+Baza danych w postaci tabeli — zbiór wierszy o jednolitym schemacie. Schemat definiuje powiązana zmienna [`STRUCT`](STRUCT.md): jej pole [`FIELDS`](STRUCT.md#fields) wyznacza kolumny tabeli oraz typy danych w poszczególnych kolumnach.
+
+Dostęp do wierszy realizowany jest sekwencyjnie poprzez kursor. Bieżąca pozycja kursora jest zmieniana metodami [`SELECT`](#select) (bezpośrednio na indeks), [`NEXT`](#next) (kolejny wiersz) i [`FIND`](#find) (po wartości w kolumnie). Dane zapisywane są w plikach `.DTA` w formacie z separatorem `|` — można je ładować ([`LOAD`](#load)) i zapisywać ([`SAVE`](#save)).
+
+## Pola
+
+### MODEL
+
+```
+STRING MODEL
+```
+
+Nazwa zmiennej typu [`STRUCT`](STRUCT.md) definiującej schemat bazy. Pole obowiązkowe — metoda [`LOAD`](#load) wymaga, by schemat został wcześniej zsynchronizowany ze [`STRUCT`](STRUCT.md).
+
+## Metody
+
+### FIND
+
+```
+INTEGER FIND(STRING columnName, mixed columnValue, INTEGER defaultIndex)
+```
+
+Wyszukuje pierwszy wiersz, w którym kolumna o nazwie `columnName` ma wartość `columnValue`. Zwraca jego indeks lub `defaultIndex`, jeżeli żaden wiersz nie pasuje.
+
+**Parametry**
+
+- `columnName` — nazwa przeszukiwanej kolumny.
+- `columnValue` — szukana wartość.
+- `defaultIndex` — indeks zwracany, jeżeli nie znaleziono dopasowania.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — indeks znalezionego wiersza lub `defaultIndex`.
+
+**Przykłady**
+
+```
+DBOBJECTS^FIND("IDNAME",VARSTAKENAME,0);
+DBOBJECTS^FIND("TYPE",102,0);
+DBDIALOGI^FIND("ID",SDIALOGNAME,IDIALOGINDEKS);
+```
+
+### GETROWSNO
+
+```
+INTEGER GETROWSNO()
+```
+
+Zwraca liczbę wierszy w bazie.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — liczba wierszy.
+
+**Przykłady**
+
+```
+DBOBJECTS^GETROWSNO();
+```
+
+### LOAD
+
+```
+void LOAD(STRING dtaName)
+```
+
+Ładuje zawartość bazy z pliku `.DTA`. Każda linia pliku to jeden wiersz; kolumny w wierszu rozdzielone są znakiem `|`. Wywołanie metody bez wcześniej zdefiniowanego schematu ([`MODEL`](#model)) jest przerywane z komunikatem błędu.
+
+**Parametry**
+
+- `dtaName` — ścieżka do pliku `.DTA`.
+
+**Przykłady**
+
+```
+DBOBJECTS^LOAD(VARSCURRARCADE);
+DBITEMS^LOAD("$COMMON\ITEMS0.DTA");
+```
+
+### NEXT
+
+```
+void NEXT()
+```
+
+Przesuwa kursor do kolejnego wiersza.
+
+**Przykłady**
+
+```
+DBSCENE^NEXT();
+```
+
+### REMOVEALL
+
+```
+void REMOVEALL()
+```
+
+Usuwa wszystkie wiersze z bazy. Schemat ([`MODEL`](#model)) pozostaje bez zmian.
+
+**Przykłady**
+
+```
+DBITEMS^REMOVEALL();
+```
+
+### SAVE
+
+```
+void SAVE(STRING dtaName)
+```
+
+Zapisuje aktualną zawartość bazy do pliku `.DTA` w tym samym formacie, którego oczekuje [`LOAD`](#load) (wiersze rozdzielone znakiem nowej linii, kolumny — znakiem `|`).
+
+**Parametry**
+
+- `dtaName` — ścieżka docelowego pliku `.DTA`.
+
+**Przykłady**
+
+```
+DBOBJECTS^SAVE(VARSCURRARCADE);
+DBLEVEL^SAVE(["$COMMON\SAVE_BD\BD_CLEV"+VARIACTIVESLOT+".FLD"]);
+```
+
+### SELECT
+
+```
+void SELECT(INTEGER rowIndex)
+```
+
+Ustawia kursor na wiersz o podanym indeksie (liczonym od zera).
+
+**Parametry**
+
+- `rowIndex` — indeks docelowego wiersza.
+
+**Przykłady**
+
+```
+DBOBJECTS^SELECT(0);
+DBOBJECTS^SELECT(VARITER);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/EXPRESSION.md
+++ b/docs/pl/reference/EXPRESSION.md
@@ -0,0 +1,51 @@
+# EXPRESSION
+
+Wyrażenie arytmetyczne dwuargumentowe. Zmienna pełni rolę nazwanej formuły — odczyt jej wartości każdorazowo oblicza `OPERAND1 OPERATOR OPERAND2` w bieżącym kontekście, więc wynik aktualizuje się automatycznie, gdy zmieniają się zmienne wejściowe.
+
+Operandy mogą być literałami liczbowymi, nazwami zmiennych lub wyrażeniami w nawiasach kwadratowych (zobacz [Arytmetyka](../engine/arithmetic.md)). Sam typ `EXPRESSION` nie udostępnia żadnych metod skryptowych.
+
+## Pola
+
+### OPERAND1
+
+```
+STRING OPERAND1
+```
+
+Lewy operand wyrażenia.
+
+### OPERAND2
+
+```
+STRING OPERAND2
+```
+
+Prawy operand wyrażenia.
+
+### OPERATOR
+
+```
+STRING OPERATOR
+```
+
+Operator binarny stosowany do operandów. Akceptowane wartości:
+
+| Wartość | Operacja |
+| --- | --- |
+| `ADD` | dodawanie |
+| `SUB` | odejmowanie |
+| `MUL` | mnożenie |
+| `DIV` | dzielenie |
+| `MOD` | reszta z dzielenia |
+
+Reguły typu wyniku (liczba całkowita vs zmiennoprzecinkowa) są takie same jak dla zwykłej arytmetyki w skryptach — zobacz [Arytmetyka — reguła typowania](../engine/arithmetic.md#regula-typowania).
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/GROUP.md
+++ b/docs/pl/reference/GROUP.md
@@ -0,0 +1,166 @@
+# GROUP
+
+Grupa zmiennych, do której można wysyłać zbiorowe wywołania metod. Każda metoda wywołana na obiekcie typu `GROUP` — która nie należy do własnego API grupy — jest delegowana do każdego elementu po kolei. Jeżeli dany element nie implementuje wywołanej metody, jest pomijany cicho (bez błędu).
+
+Grupa utrzymuje wewnętrzny **marker** wskazujący jeden z elementów. Pozycja markera jest modyfikowana metodami [`NEXT`](#next), [`PREV`](#prev) i [`RESETMARKER`](#resetmarker). Markerem można posłużyć się do sekwencyjnego przechodzenia po elementach grupy.
+
+Wartość zmiennej (`value`) typu `GROUP` to liczba elementów w grupie.
+
+## Metody
+
+### \[nazwa metody\]
+
+```
+void <methodName>(mixed param1, ..., mixed paramN)
+```
+
+Każda metoda spoza własnego API grupy jest delegowana do wszystkich elementów grupy z tymi samymi argumentami. Elementy, które nie implementują takiej metody, są pomijane.
+
+**Przykłady**
+
+```
+GRPHIDE^HIDE();
+GRPMOVE^SETPOSITION(VARX,VARY);
+```
+
+### ADD
+
+```
+void ADD(STRING varName1, [STRING varName2, ...])
+```
+
+Dodaje do grupy jeden lub więcej elementów po nazwie zmiennej. Próba ponownego dodania elementu już obecnego w grupie jest ignorowana.
+
+**Parametry**
+
+- `varName1, varName2, …` — kolejne nazwy zmiennych do dodania.
+
+**Przykłady**
+
+```
+GRPHIDE^ADD("ANNREX");
+GRPMOVE^ADD("ANNBODY1","ANNWAND1","ANNHEAD1");
+GALL^ADD(["ANNPOLA_"+ICLONENO]);
+```
+
+### ADDCLONES
+
+```
+void ADDCLONES(STRING varName, INTEGER firstCloneIndex, INTEGER lastCloneIndex)
+```
+
+Dodaje do grupy zakres klonów zmiennej — od `firstCloneIndex` do `lastCloneIndex` włącznie. Klony są referencjami po nazwie wygenerowanej według wzorca silnika (sufiks indeksu).
+
+**Parametry**
+
+- `varName` — nazwa zmiennej bazowej.
+- `firstCloneIndex` — indeks pierwszego klona.
+- `lastCloneIndex` — indeks ostatniego klona.
+
+**Przykłady**
+
+```
+GBKG^ADDCLONES("ANNPLANNAK",0,[I1-1]);
+GTRASA^ADDCLONES("ANNSKRZYNIA",1,ITMPCLONENO);
+GRPLANS^ADDCLONES("IMGPLAN1",1,10);
+```
+
+### GETSIZE
+
+```
+INTEGER GETSIZE()
+```
+
+Zwraca liczbę elementów w grupie.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — rozmiar grupy.
+
+**Przykłady**
+
+```
+GRPHIDE^GETSIZE();
+```
+
+### NEXT
+
+```
+mixed NEXT()
+```
+
+Przesuwa marker o jedno w prawo (do następnego elementu, ograniczony wartością ostatniego indeksu) i zwraca referencję do elementu wskazywanego po przesunięciu.
+
+**Zwraca**: referencja do elementu pod nowym markerem.
+
+**Przykłady**
+
+```
+GENEMIES^NEXT();
+GBAZUK^NEXT();
+```
+
+### PREV
+
+```
+mixed PREV()
+```
+
+Przesuwa marker o jedno w lewo (do poprzedniego elementu, ograniczony zerem) i zwraca referencję do elementu pod nowym markerem.
+
+**Zwraca**: referencja do elementu pod nowym markerem.
+
+### REMOVE
+
+```
+void REMOVE(STRING varName)
+```
+
+Usuwa z grupy element o podanej nazwie. Jeżeli marker wskazywał na element poza nowym zakresem, zostaje przesunięty na ostatni dostępny element (lub `-1`, jeśli grupa stała się pusta).
+
+**Parametry**
+
+- `varName` — nazwa zmiennej do usunięcia.
+
+**Przykłady**
+
+```
+GOBJ^REMOVE(S1);
+GOBJ^REMOVE("ANNTNTR");
+```
+
+### REMOVEALL
+
+```
+void REMOVEALL()
+```
+
+Czyści grupę z wszystkich elementów i resetuje marker.
+
+**Przykłady**
+
+```
+GRPHIDE^REMOVEALL();
+```
+
+### RESETMARKER
+
+```
+void RESETMARKER()
+```
+
+Ustawia marker na pierwszy element grupy (indeks `0`). Dla pustej grupy marker przyjmuje wartość `-1`.
+
+**Przykłady**
+
+```
+GENEMIES^RESETMARKER();
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/INERTIA.md
+++ b/docs/pl/reference/INERTIA.md
@@ -0,0 +1,300 @@
+# INERTIA
+
+Interfejs do wbudowanego silnika fizycznego 2D o tej samej nazwie (Inertia). Zarządza ciałami sztywnymi: tworzeniem obiektów, ich wiązaniem z animacjami, polem grawitacji, prędkościami, tłumieniem i przykładaniem sił. Wykorzystany w *Reksio i Kretes w Akcji*.
+
+Każdy obiekt fizyczny ma identyfikator (`objectId`) — wartość całkowitą używaną przez większość metod do wskazania ciała. Plik definiujący świat fizyczny ma rozszerzenie [`.INE`](../engine/index.md) i jest ładowany jednorazowo metodą [`LOAD`](#load).
+
+## Metody
+
+### ADDFORCE
+
+```
+void ADDFORCE(INTEGER objectId, INTEGER forceX, INTEGER forceY)
+```
+
+Przykłada siłę do obiektu w osiach X i Y.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `forceX`, `forceY` — składowe siły.
+
+**Przykłady**
+
+```
+EXTWORLD^ADDFORCE(1,-500,0);
+EXTWORLD^ADDFORCE(1,0,-50);
+```
+
+### CREATESPHERE
+
+```
+void CREATESPHERE(INTEGER objectId, INTEGER posX, INTEGER posY, INTEGER radius)
+```
+
+Tworzy w silniku fizycznym sferę o podanej pozycji środka i promieniu, przypisując jej wskazany identyfikator.
+
+**Parametry**
+
+- `objectId` — identyfikator nowego obiektu.
+- `posX`, `posY` — pozycja środka sfery.
+- `radius` — promień sfery.
+
+**Przykłady**
+
+```
+EXTWORLD^CREATESPHERE(5,10,10,10);
+```
+
+### DELETEBODY
+
+```
+void DELETEBODY(INTEGER objectId)
+```
+
+Usuwa obiekt z silnika fizycznego.
+
+**Parametry**
+
+- `objectId` — identyfikator usuwanego obiektu.
+
+**Przykłady**
+
+```
+EXTWORLD^DELETEBODY(IHANDLEDEL);
+EXTWORLD^DELETEBODY(IRAKIETAOBJ);
+```
+
+### GETPOSITIONX
+
+```
+INTEGER GETPOSITIONX(INTEGER objectId)
+```
+
+Zwraca aktualną pozycję X obiektu o podanym identyfikatorze.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata X.
+
+### GETPOSITIONY
+
+```
+INTEGER GETPOSITIONY(INTEGER objectId)
+```
+
+Zwraca aktualną pozycję Y obiektu o podanym identyfikatorze.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata Y.
+
+### GETSPEED
+
+```
+DOUBLE GETSPEED(INTEGER objectId)
+```
+
+Zwraca prędkość obiektu o podanym identyfikatorze (długość wektora prędkości liniowej).
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+
+**Zwraca**: [`DOUBLE`](DOUBLE.md) — wartość prędkości.
+
+### LINK
+
+```
+void LINK(INTEGER objectId, STRING animoName, BOOL flag1, BOOL flag2)
+```
+
+Wiąże obiekt fizyczny z animacją [`ANIMO`](ANIMO.md) — pozycja animacji jest aktualizowana na podstawie symulacji fizyki. Znaczenie obu flag boolowskich nie zostało jeszcze ustalone (w grach zawsze podawane są jako `TRUE`).
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu fizycznego.
+- `animoName` — nazwa zmiennej [`ANIMO`](ANIMO.md).
+- `flag1`, `flag2` — flagi konfiguracyjne (znaczenie nieustalone).
+
+**Przykłady**
+
+```
+EXTWORLD^LINK(1,"ANNSZCZUREK",TRUE,TRUE);
+EXTWORLD^LINK(IOBIEKT,["ANNSTRZAL_"+ISTRZAL],TRUE,TRUE);
+```
+
+### LOAD
+
+```
+void LOAD(STRING path)
+```
+
+Ładuje plik `.INE` z definicją świata fizycznego.
+
+**Parametry**
+
+- `path` — ścieżka do pliku `.INE`.
+
+**Przykłady**
+
+```
+EXTWORLD^LOAD("WORLD.INE");
+```
+
+### RESETTIMER
+
+```
+void RESETTIMER()
+```
+
+Resetuje wewnętrzny zegar symulacji.
+
+**Przykłady**
+
+```
+EXTWORLD^RESETTIMER();
+```
+
+### SETGRAVITY
+
+```
+void SETGRAVITY(DOUBLE gravityX, DOUBLE gravityY)
+```
+
+Ustawia globalny wektor grawitacji. Wartość `(0, 0)` wyłącza grawitację.
+
+**Parametry**
+
+- `gravityX`, `gravityY` — składowe grawitacji.
+
+**Przykłady**
+
+```
+EXTWORLD^SETGRAVITY(0,0);
+```
+
+### SETLINEARDAMPING
+
+```
+void SETLINEARDAMPING(INTEGER objectId, INTEGER linearDamping)
+```
+
+Ustawia tłumienie liniowe (stopniowe spowalnianie prędkości liniowej) dla obiektu.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `linearDamping` — wartość tłumienia.
+
+**Przykłady**
+
+```
+EXTWORLD^SETLINEARDAMPING(1,300);
+```
+
+### SETMATERIAL
+
+```
+void SETMATERIAL(INTEGER objectId, STRING material)
+```
+
+Ustawia materiał obiektu. Materiały kontrolują, w jaki sposób obiekty reagują na kontakt (sztywność, sprężystość, tarcie). W skryptach gier spotykana jest m.in. nazwa `"TRIGGER"`, dla której silnik wywołuje na powiązanej animacji sygnał `ONSIGNAL^TRIGGER`.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `material` — nazwa materiału.
+
+**Przykłady**
+
+```
+EXTWORLD^SETMATERIAL(IOBIEKT,"TRIGGER");
+```
+
+### SETPOSITION
+
+```
+void SETPOSITION(INTEGER objectId, INTEGER posX, INTEGER posY)
+```
+
+Ustawia bezwzględną pozycję obiektu w świecie fizycznym.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `posX`, `posY` — nowa pozycja.
+
+**Przykłady**
+
+```
+EXTWORLD^SETPOSITION(IOBIEKT,[ANNSZCZUREK^GETCENTERX()+70],[ANNSZCZUREK^GETCENTERY()-1]);
+EXTWORLD^SETPOSITION(IRAKIETAOBJ,ANNDODATKI_7^GETPOSITIONX(),ANNDODATKI_7^GETPOSITIONY());
+```
+
+### SETVELOCITY
+
+```
+void SETVELOCITY(INTEGER objectId, INTEGER speedX, INTEGER speedY)
+```
+
+Ustawia prędkość obiektu w osiach X i Y.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `speedX`, `speedY` — składowe prędkości.
+
+**Przykłady**
+
+```
+EXTWORLD^SETVELOCITY(1,0,0);
+EXTWORLD^SETVELOCITY(IOBIEKT,8,0);
+```
+
+### TICK
+
+```
+void TICK()
+```
+
+Wykonuje pojedynczy krok symulacji. Bez wywołania `TICK` świat fizyczny pozostaje zamrożony — typowo wywoływane z sygnału [`ONTICK`](TIMER.md#ontick) [`TIMER`](TIMER.md).
+
+**Przykłady**
+
+```
+EXTWORLD^TICK();
+```
+
+### UNLINK
+
+```
+void UNLINK(INTEGER objectId)
+```
+
+Zrywa powiązanie obiektu z animacją utworzone metodą [`LINK`](#link).
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+
+**Przykłady**
+
+```
+EXTWORLD^UNLINK(IID);
+EXTWORLD^UNLINK(1);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/MATRIX.md
+++ b/docs/pl/reference/MATRIX.md
@@ -0,0 +1,438 @@
+# MATRIX
+
+Plansza złożona z prostokątnej siatki pól z prostym systemem fizyki kamieni i prymitywnym wyznaczaniem ruchu przeciwników. Zaprojektowany pod jeden, konkretny przypadek użycia — minigrę z podkopem (sekcje Kretesa w *Reksio i Ufo*: mur na Indorze oraz podkop do więzienia na Kuranie).
+
+Dane planszy są przechowywane jako jednowymiarowa tablica liczb całkowitych — adres pola wyznacza się ze wzoru `index = y * width + x`. Stąd obecność metod konwertujących indeks na pozycję 2D i odwrotnie.
+
+## Kody pól {#kody-pol}
+
+Wartości używane przez metody [`GET`](#get), [`GETCELLSNO`](#getcellsno), [`SET`](#set), [`SETROW`](#setrow) i wewnętrzny system fizyki:
+
+| Kod | Znaczenie |
+| --- | --- |
+| `0` | puste pole |
+| `1` | grunt |
+| `2` | kamień |
+| `3` | laska dynamitu |
+| `4` | wyburzalna ściana |
+| `5` | przeciwnik |
+| `6` | nierozbijalna ściana |
+| `7` | odpalona laska dynamitu |
+| `8` | pole w zasięgu eksplozji |
+| `9` | wyjście |
+| `99` | pozycja Kretesa |
+
+## Kody kierunku ruchu {#kody-kierunku-ruchu}
+
+Wartości używane przez [`TICK`](#tick), [`NEXT`](#next) i [`CALCENEMYMOVEDIR`](#calcenemymovedir):
+
+| Kod | Kierunek |
+| --- | --- |
+| `0` | w lewo |
+| `1` | w górę |
+| `2` | w prawo |
+| `3` | w dół |
+
+Wewnętrzny system fizyki używa dodatkowych kodów zwracanych przez [`TICK`](#tick) i odczytywanych przez [`NEXT`](#next):
+
+| Kod | Operacja |
+| --- | --- |
+| `1` | kamień spada w dół |
+| `2` | kamień spada w lewo po skosie |
+| `3` | kamień spada w prawo po skosie |
+| `4` | kamień z przeciwnikiem eksplodują |
+
+## Pola
+
+### BASEPOS
+
+```
+INTEGER, INTEGER BASEPOS
+```
+
+Pozycja lewego górnego rogu planszy na ekranie w pikselach (`X,Y`).
+
+### CELLHEIGHT
+
+```
+INTEGER CELLHEIGHT
+```
+
+Wysokość pojedynczego pola w pikselach.
+
+### CELLWIDTH
+
+```
+INTEGER CELLWIDTH
+```
+
+Szerokość pojedynczego pola w pikselach.
+
+### SIZE
+
+```
+INTEGER, INTEGER SIZE
+```
+
+Wymiary planszy w polach (`szerokość,wysokość`). Wartość wyznacza również rozmiar wewnętrznej tablicy z kodami pól.
+
+## Metody
+
+### CALCENEMYMOVEDEST
+
+```
+INTEGER CALCENEMYMOVEDEST(INTEGER oldCell, INTEGER direction)
+```
+
+Wylicza indeks pola, na które przeciwnik przejdzie z pola `oldCell` przy ruchu w kierunku `direction`. Jeśli pole docelowe znajduje się poza planszą lub nie jest puste, zwracany jest niezmieniony `oldCell`.
+
+**Parametry**
+
+- `oldCell` — bieżąca pozycja przeciwnika (indeks pola).
+- `direction` — kierunek ruchu (`0`–`3`, zobacz [Kody kierunku ruchu](#kody-kierunku-ruchu)).
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — indeks pola docelowego.
+
+**Przykłady**
+
+```
+MAT^CALCENEMYMOVEDEST(IENOLDCELL,IENNEWDIR);
+```
+
+### CALCENEMYMOVEDIR
+
+```
+INTEGER CALCENEMYMOVEDIR(INTEGER oldCell, INTEGER oldDir)
+```
+
+Wylicza kierunek ruchu przeciwnika. Algorytm preferuje skręt w lewo: w pierwszej kolejności sprawdzany jest kierunek `(oldDir+3) MOD 4`, następnie `oldDir`, dalej w prawo i wreszcie do tyłu. Zwracany jest pierwszy kierunek, dla którego pole docelowe jest puste; jeżeli żaden nie jest dostępny — preferowany skręt w lewo.
+
+**Parametry**
+
+- `oldCell` — bieżąca pozycja przeciwnika.
+- `oldDir` — kierunek ruchu z poprzedniego kroku.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — nowy kierunek ruchu.
+
+**Przykłady**
+
+```
+MAT^CALCENEMYMOVEDIR(IENOLDCELL,IENOLDDIR);
+```
+
+### CANHEROGOTO
+
+```
+BOOL CANHEROGOTO(INTEGER cellNo)
+```
+
+Sprawdza, czy główny bohater może wejść na podane pole. Pole jest przejezdne, jeżeli nie zawiera słabej ściany, mocnej ściany, przeciwnika ani kamienia, a także nie należy do obszaru bramy ustawionej metodą [`SETGATE`](#setgate).
+
+**Parametry**
+
+- `cellNo` — indeks sprawdzanego pola.
+
+**Zwraca**: [`BOOL`](BOOL.md) — `TRUE`, jeżeli pole jest przejezdne.
+
+**Przykłady**
+
+```
+MAT^CANHEROGOTO(I_0);
+```
+
+### GET
+
+```
+INTEGER GET(INTEGER cellNo)
+```
+
+Zwraca kod pola o podanym indeksie. Dla indeksów spoza zakresu zwraca `0`.
+
+**Parametry**
+
+- `cellNo` — indeks pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — kod pola (zobacz [Kody pól](#kody-pol)).
+
+**Przykłady**
+
+```
+MAT^GET(I_ITERATOR);
+MAT^GET(I_MOLE_FIELD_CURR);
+```
+
+### GETCELLOFFSET
+
+```
+INTEGER GETCELLOFFSET(INTEGER x, INTEGER y)
+```
+
+Zwraca indeks pola na podstawie współrzędnych `(x, y)`. Dla współrzędnych spoza planszy zwracane jest `-1`.
+
+**Parametry**
+
+- `x`, `y` — koordynaty pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — indeks pola lub `-1`.
+
+**Przykłady**
+
+```
+MAT^GETCELLOFFSET(ISSRCX,ISSRCY);
+MAT^GETCELLOFFSET(ISTRGX,ISTRGY);
+```
+
+### GETCELLPOSX
+
+```
+INTEGER GETCELLPOSX(INTEGER cellNo)
+```
+
+Zwraca pozycję X pola w pikselach (`BASEPOS.X + col * CELLWIDTH`).
+
+**Parametry**
+
+- `cellNo` — indeks pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata X w pikselach.
+
+### GETCELLPOSY
+
+```
+INTEGER GETCELLPOSY(INTEGER cellNo)
+```
+
+Zwraca pozycję Y pola w pikselach (`BASEPOS.Y + row * CELLHEIGHT`).
+
+**Parametry**
+
+- `cellNo` — indeks pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata Y w pikselach.
+
+### GETCELLSNO
+
+```
+INTEGER GETCELLSNO(INTEGER cellCode)
+```
+
+Zwraca liczbę pól z podanym kodem.
+
+**Parametry**
+
+- `cellCode` — kod pola, którego wystąpienia mają zostać policzone.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — liczba pól o podanym kodzie.
+
+**Przykłady**
+
+```
+MAT^GETCELLSNO(IC_FIELD_CODE_EXIT);
+MAT^GETCELLSNO(IC_FIELD_CODE_ENEMY);
+```
+
+### GETFIELDPOSX
+
+```
+INTEGER GETFIELDPOSX(INTEGER cellNo)
+```
+
+Alias [`GETCELLPOSX`](#getcellposx) używany w *Reksio i Ufo* z silnikiem Piklib 7.1. W Piklib 8 metoda nie jest już udostępniana — próba jej wywołania w nowszej wersji powoduje awarię silnika.
+
+**Parametry**
+
+- `cellNo` — indeks pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata X w pikselach.
+
+### GETFIELDPOSY
+
+```
+INTEGER GETFIELDPOSY(INTEGER cellNo)
+```
+
+Alias [`GETCELLPOSY`](#getcellposy) używany w *Reksio i Ufo* z silnikiem Piklib 7.1. W Piklib 8 metoda nie jest już udostępniana — próba jej wywołania w nowszej wersji powoduje awarię silnika.
+
+**Parametry**
+
+- `cellNo` — indeks pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata Y w pikselach.
+
+### GETOFFSET
+
+```
+INTEGER GETOFFSET(INTEGER x, INTEGER y)
+```
+
+Alias [`GETCELLOFFSET`](#getcelloffset) używany w *Reksio i Ufo* z silnikiem Piklib 7.1. W Piklib 8 metoda została zastąpiona przez `GETCELLOFFSET`.
+
+**Parametry**
+
+- `x`, `y` — koordynaty pola.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — indeks pola lub `-1`.
+
+### ISGATEEMPTY
+
+```
+BOOL ISGATEEMPTY()
+```
+
+Sprawdza, czy wszystkie pola w obszarze bramy ustawionej metodą [`SETGATE`](#setgate) mają kod `0` (puste). Jeśli brama nie została ustawiona, zwracane jest `FALSE`.
+
+**Zwraca**: [`BOOL`](BOOL.md) — `TRUE`, jeżeli wszystkie pola bramy są puste.
+
+**Przykłady**
+
+```
+MAT^ISGATEEMPTY();
+```
+
+### ISINGATE
+
+```
+BOOL ISINGATE(INTEGER cellNo)
+```
+
+Sprawdza, czy pole o podanym indeksie należy do obszaru bramy ustawionej metodą [`SETGATE`](#setgate).
+
+**Parametry**
+
+- `cellNo` — indeks pola.
+
+**Zwraca**: [`BOOL`](BOOL.md) — `TRUE`, jeżeli pole znajduje się w obszarze bramy.
+
+### MOVE
+
+```
+void MOVE(INTEGER oldCell, INTEGER newCell)
+```
+
+Przesuwa zawartość pola źródłowego na pole docelowe; pole źródłowe pozostaje puste (kod `0`).
+
+**Parametry**
+
+- `oldCell` — indeks pola źródłowego.
+- `newCell` — indeks pola docelowego.
+
+**Przykłady**
+
+```
+MAT^MOVE(I_0,I_1);
+```
+
+### NEXT
+
+```
+INTEGER NEXT()
+```
+
+Wykonuje kolejny zaplanowany ruch z kolejki wygenerowanej przez [`TICK`](#tick). Pole źródłowe jest czyszczone, a pole docelowe otrzymuje kod kamienia. Po wykonaniu ruchu emitowany jest sygnał [`ONNEXT`](#onnext) (dla wszystkich ruchów oprócz ostatniego) lub [`ONLATEST`](#onlatest) (dla ostatniego ruchu z kolejki).
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — `0`, jeżeli kolejka jest pusta; `1` przy zwykłym ruchu kamienia; `2`, jeśli kamień wylądował dwa pola nad Kretesem (kolizja).
+
+**Przykłady**
+
+```
+MAT^NEXT();
+```
+
+### SET
+
+```
+void SET(INTEGER cellNo, INTEGER cellCode)
+void SET(INTEGER x, INTEGER y, INTEGER cellCode)
+```
+
+Ustawia kod pola. Metoda ma dwie formy: pierwsza przyjmuje gotowy indeks pola, druga — współrzędne `(x, y)`.
+
+**Parametry**
+
+- `cellNo` — indeks pola **(forma 1)**.
+- `x`, `y` — koordynaty pola **(forma 2)**.
+- `cellCode` — nowa wartość pola (zobacz [Kody pól](#kody-pol)).
+
+**Przykłady**
+
+```
+MAT^SET(I_MOLE_FIELD_CURR,IC_FIELD_CODE_EMPTY);
+MAT^SET([I_FIELD_INDEX%I_LEVEL_WIDTH],[I_FIELD_INDEX@I_LEVEL_WIDTH],IC_FIELD_CODE_EMPTY);
+```
+
+### SETGATE
+
+```
+void SETGATE(INTEGER startX, INTEGER startY, INTEGER endX, INTEGER endY)
+```
+
+Wyznacza prostokątny obszar bramy określony przez współrzędne początkowego i końcowego pola (włącznie). Brama wpływa na działanie metod [`CANHEROGOTO`](#canherogoto), [`ISGATEEMPTY`](#isgateempty) oraz [`ISINGATE`](#isingate).
+
+**Parametry**
+
+- `startX`, `startY` — koordynaty lewego górnego rogu obszaru bramy.
+- `endX`, `endY` — koordynaty prawego dolnego rogu obszaru bramy.
+
+**Przykłady**
+
+```
+MAT^SETGATE(3,1,16,4);
+```
+
+### SETROW
+
+```
+void SETROW(INTEGER row, INTEGER cellCode1, [INTEGER cellCode2, ...])
+```
+
+Ustawia kody pól w podanym wierszu. Kolejne argumenty są wpisywane do pól od kolumny `0` w prawo; nadmiarowe argumenty (więcej niż szerokość planszy) są ignorowane.
+
+**Parametry**
+
+- `row` — indeks wiersza.
+- `cellCode1`, `cellCode2`, … — kolejne kody pól w wierszu.
+
+**Przykłady**
+
+```
+MAT^SETROW(0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6);
+MAT^SETROW(1,6,6,6,2,2,2,2,2,2,2,2,2,2,2,2,2,2,6,6,6);
+```
+
+### TICK
+
+```
+void TICK()
+```
+
+Wykonuje jedno tyknięcie wewnętrznego systemu fizyki. Plansza jest skanowana od dołu do góry, od lewej do prawej. Dla każdego kamienia sprawdzane są kolejno:
+
+1. Czy pod kamieniem jest puste pole — zaplanowanie ruchu w dół.
+2. Czy pod kamieniem znajduje się przeciwnik — zaplanowanie eksplozji.
+3. Czy obok kamienia leży inny kamień, a pola na ukos w lewo lub w prawo są puste — zaplanowanie zsuwu po skosie.
+
+Ruchy są zapisywane do wewnętrznej kolejki i wykonywane kolejno przez wywołania [`NEXT`](#next). Każdy wpis zawiera koordynatę X i Y pola źródłowego oraz kod operacji.
+
+**Przykłady**
+
+```
+MAT^TICK();
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONNEXT
+
+Wywoływany przez [`NEXT`](#next) po wykonaniu ruchu, który nie był ostatnim w bieżącej kolejce. Argumentami sygnału są: koordynata X (`$1`), koordynata Y (`$2`) i kod operacji (`$3`) pola źródłowego.
+
+### ONLATEST
+
+Wywoływany przez [`NEXT`](#next) po wykonaniu ostatniego ruchu z bieżącej kolejki. Argumenty sygnału są identyczne jak w [`ONNEXT`](#onnext).
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/PATTERN.md
+++ b/docs/pl/reference/PATTERN.md
@@ -0,0 +1,147 @@
+# PATTERN
+
+Plansza złożona z siatki "kafelków" o określonych wymiarach i wielowarstwowej strukturze. Wykorzystywana m.in. w etapach z lataniem na Smokręcie (*Reksio i Wehikuł Czasu*) oraz na miotle (*Reksio i Czarodzieje*) — prawdopodobnie do zapisu mapy przewijającego się poziomu. Analiza tego typu jest w toku.
+
+## Pola
+
+### GRIDX
+
+```
+INTEGER GRIDX
+```
+
+Szerokość pojedynczego kafelka siatki w pikselach.
+
+### GRIDY
+
+```
+INTEGER GRIDY
+```
+
+Wysokość pojedynczego kafelka siatki w pikselach.
+
+### HEIGHT
+
+```
+INTEGER HEIGHT
+```
+
+Wysokość planszy.
+
+### LAYERS
+
+```
+INTEGER LAYERS
+```
+
+Liczba warstw planszy.
+
+### PRIORITY
+
+```
+INTEGER PRIORITY
+```
+
+Priorytet rysowania planszy (pozycja w osi Z).
+
+### TOCANVAS
+
+```
+BOOL TOCANVAS
+```
+
+Określa, czy plansza ma być rysowana na kanwie.
+
+### VISIBLE
+
+```
+BOOL VISIBLE
+```
+
+Określa, czy plansza jest widoczna.
+
+### WIDTH
+
+```
+INTEGER WIDTH
+```
+
+Szerokość planszy.
+
+## Metody
+
+### ADD
+
+```
+void ADD(STRING tileId, INTEGER posX, INTEGER posY, STRING animoName, [INTEGER layer])
+```
+
+Dodaje na planszę obiekt graficzny.
+
+**Parametry**
+
+- `tileId` — identyfikator kafelka.
+- `posX`, `posY` — koordynaty kafelka.
+- `animoName` — nazwa zmiennej [`ANIMO`](ANIMO.md) wyświetlanej na kafelku.
+- `layer` — (opcjonalnie) numer warstwy.
+
+**Przykłady**
+
+```
+PATBOARD^ADD(["E"+_I_],VARX,VARY,VARSTRING0,0);
+PATTERNFOREST^ADD([VARSTRING0+"_"+_I_],VARINT1,VARINT2,VARSTRING1,VARINT3);
+```
+
+### GETGRAPHICSAT
+
+```
+STRING GETGRAPHICSAT(INTEGER posX, INTEGER posY, BOOL onlyVisible, BOOL ignoreAlpha, INTEGER minZ, [INTEGER maxZ])
+```
+
+Zwraca nazwę kafelka pod punktem `(posX, posY)`. Zachowuje się analogicznie do [`CANVAS_OBSERVER.GETGRAPHICSAT`](CANVAS_OBSERVER.md#getgraphicsat), z tą różnicą, że przeszukuje wyłącznie kafelki tej planszy.
+
+**Parametry**
+
+- `posX`, `posY` — koordynaty sprawdzanego punktu.
+- `onlyVisible` — gdy `TRUE`, brane są pod uwagę tylko widoczne kafelki.
+- `ignoreAlpha` — gdy `TRUE`, sprawdzany jest tylko prostokąt; gdy `FALSE`, test uwzględnia kanał alfa piksela.
+- `minZ` — minimalna warstwa.
+- `maxZ` — (opcjonalnie) maksymalna warstwa.
+
+**Zwraca**: [`STRING`](STRING.md) — nazwa kafelka lub `"NULL"`.
+
+**Przykłady**
+
+```
+PATTERNMASKKRET^GETGRAPHICSAT([ANNKRET^GETCENTERX()+20],ANNKRET^GETCENTERY(),TRUE,FALSE,0,1);
+PATTERNFIRE^GETGRAPHICSAT(ANNCOLLUP^GETCENTERX(),ANNCOLLUP^GETCENTERY(),FALSE,FALSE,0);
+```
+
+### MOVE
+
+```
+void MOVE(INTEGER offsetX, INTEGER offsetY)
+```
+
+Przesuwa planszę o zadane wartości w osiach X i Y.
+
+**Parametry**
+
+- `offsetX`, `offsetY` — wektor przesunięcia.
+
+**Przykłady**
+
+```
+PATBOARD^MOVE(0,-3000);
+PATTERNBKG^MOVE(VARINT0,0);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/STATICFILTER.md
+++ b/docs/pl/reference/STATICFILTER.md
@@ -0,0 +1,110 @@
+# STATICFILTER
+
+Filtr graficzny — efekt nakładany na zmienne [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md). Każda instancja filtra ma jeden rodzaj efektu (pole [`ACTION`](#action)) i zbiór parametrów ustawianych metodą [`SETPROPERTY`](#setproperty). Filtr wiąże się z konkretną grafiką przez [`LINK`](#link) — od tego momentu wszystkie zmiany właściwości będą wpływały na widok grafiki w czasie rzeczywistym.
+
+Jeden obiekt `STATICFILTER` można powiązać równocześnie z wieloma grafikami.
+
+## Pola
+
+### ACTION
+
+```
+STRING ACTION
+```
+
+Rodzaj efektu filtra. Dostępne wartości (na podstawie `sub_100A4490` w bibliotece Piklib8):
+
+| Wartość | Efekt |
+| --- | --- |
+| `COLORCHANNEL` | manipulacja kanałami RGB |
+| `GRAYSCALE` | konwersja na odcienie szarości |
+| `BLUR` | rozmycie |
+| `ROTATE` | obrót |
+| `SCALE` | skalowanie |
+| `NEGATIVE` | negatyw |
+| `RANDOMJITTER` | losowe drgania pikseli |
+| `WAVES` | efekt fali |
+
+## Metody
+
+### LINK
+
+```
+void LINK(STRING objectName)
+```
+
+Wiąże filtr ze zmienną [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md). Bieżące ustawienia parametrów filtra zostają przekazane do nowo utworzonego efektu i zaczynają działać natychmiast.
+
+**Parametry**
+
+- `objectName` — nazwa zmiennej graficznej.
+
+**Przykłady**
+
+```
+FJITTER^LINK("IMGZOOM");
+FROTATE^LINK(ARRCARS^GET(0));
+```
+
+### SETPROPERTY
+
+```
+void SETPROPERTY(STRING propertyName, mixed value)
+```
+
+Ustawia parametr filtra. Akceptowane nazwy parametrów zależą od wybranej akcji ([`ACTION`](#action)):
+
+| Parametr | Typ | Filtry |
+| --- | --- | --- |
+| `CANUNDO` | [`BOOL`](BOOL.md) | wszystkie |
+| `CURRENTFRAME` | [`BOOL`](BOOL.md) | wszystkie |
+| `CHANNELS` | [`STRING`](STRING.md) | `COLORCHANNEL` |
+| `MAXJITTER` | [`INTEGER`](INTEGER.md) | `RANDOMJITTER` |
+| `BLUR` | [`INTEGER`](INTEGER.md) | `BLUR` |
+| `ANGLE` | [`INTEGER`](INTEGER.md) | `ROTATE` |
+| `BYCENTER` | [`BOOL`](BOOL.md) | `ROTATE`, `SCALE` |
+| `FACTORX` | [`INTEGER`](INTEGER.md) | `SCALE` |
+| `FACTORY` | [`INTEGER`](INTEGER.md) | `SCALE` |
+
+**Parametry**
+
+- `propertyName` — nazwa ustawianego parametru.
+- `value` — nowa wartość parametru.
+
+**Przykłady**
+
+```
+FCOLOR^SETPROPERTY("CANUNDO","TRUE");
+FCOLOR^SETPROPERTY("CHANNELS","B");
+FJITTER^SETPROPERTY("MAXJITTER",7);
+FROTATE^SETPROPERTY("ANGLE",IKONANGLE);
+```
+
+### UNLINK
+
+```
+void UNLINK(STRING objectName)
+```
+
+Zrywa powiązanie filtra ze zmienną graficzną — usuwa efekt z grafiki.
+
+**Parametry**
+
+- `objectName` — nazwa zmiennej graficznej.
+
+**Przykłady**
+
+```
+FROTATE^UNLINK("ANNKON");
+FROTATE^UNLINK(ARRCARS^GET(VARPLAYER));
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/STRUCT.md
+++ b/docs/pl/reference/STRUCT.md
@@ -0,0 +1,63 @@
+# STRUCT
+
+Struktura danych z nazwanymi, typowanymi polami. W skryptach silnika wykorzystywana wyłącznie razem z [`DATABASE`](DATABASE.md) — opisuje schemat wiersza bazy danych i przechowuje wartości aktualnie wskazywanego rekordu po wywołaniu [`SET`](#set).
+
+## Pola
+
+### FIELDS
+
+```
+STRING FIELDS
+```
+
+Schemat struktury jako lista pól oddzielonych przecinkiem. Każde pole ma format `NAZWA<TYP>`, gdzie `NAZWA` to nazwa pola, a `TYP` to nazwa typu danych. Dopuszczalne typy: `STRING`, `INTEGER`, `DOUBLE`, `BOOLEAN`. Typy są rozpoznawane bez rozróżniania wielkości liter; nieznana nazwa typu jest traktowana jak `STRING`.
+
+## Metody
+
+### GETFIELD
+
+```
+<type> GETFIELD(INTEGER fieldIndex)
+```
+
+Zwraca wartość pola o podanym indeksie (liczonym od zera). Typ zwracanej wartości wynika ze schematu — pole zadeklarowane jako `<INTEGER>` zwraca [`INTEGER`](INTEGER.md), jako `<DOUBLE>` — [`DOUBLE`](DOUBLE.md), jako `<BOOLEAN>` — [`BOOL`](BOOL.md), w pozostałych przypadkach [`STRING`](STRING.md). Dla indeksu spoza zakresu zwracana jest wartość pusta. Jeśli struktura nie została wcześniej zsynchronizowana z [`DATABASE`](DATABASE.md), wszystkie pola mają wartość pustą.
+
+**Parametry**
+
+- `fieldIndex` — indeks pola (`0`-bazowany).
+
+**Zwraca**: wartość pola w typie zadeklarowanym w schemacie.
+
+**Przykłady**
+
+```
+STLEVEL^GETFIELD(0);
+```
+
+### SET
+
+```
+void SET(STRING cursorName)
+```
+
+Synchronizuje strukturę z bieżącym wierszem wskazywanym przez kursor [`DATABASE`](DATABASE.md). Surowe wartości z kursora są konwertowane do typów zadeklarowanych w schemacie pola [`FIELDS`](#fields).
+
+**Parametry**
+
+- `cursorName` — nazwa zmiennej kursora skojarzonego z bazą danych.
+
+**Przykłady**
+
+```
+SOBJECT^SET("DBOBJECTS_CURSOR");
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/TIMER.md
+++ b/docs/pl/reference/TIMER.md
@@ -0,0 +1,138 @@
+# TIMER
+
+Cykliczny licznik czasu emitujący sygnał [`ONTICK`](#ontick) co `ELAPSE` milisekund. Pozwala uruchamiać kod skryptu w regularnych odstępach — bez timera nie da się w silniku zrealizować nic, co wymaga upływu czasu (animowanie wartości, opóźnienia, regeneracja).
+
+Wartość zmiennej (`value`) typu `TIMER` to liczba dotychczas wykonanych tyknięć.
+
+## Pola
+
+### ELAPSE
+
+```
+INTEGER ELAPSE
+```
+
+Długość cyklu timera w milisekundach. Dla wartości `0` lub mniejszej timer nie tyka, nawet jeżeli jest włączony.
+
+### ENABLED
+
+```
+BOOL ENABLED
+```
+
+Określa, czy timer ma działać po inicjalizacji. Domyślnie `TRUE`.
+
+### TICKS
+
+```
+INTEGER TICKS
+```
+
+Limit cykli — po wyemitowaniu tylu tyknięć timer wyłącza się automatycznie (`ENABLED = FALSE`). Wartość `0` oznacza brak limitu (timer tyka bez końca).
+
+## Metody
+
+### DISABLE
+
+```
+void DISABLE()
+```
+
+Wyłącza timer. Sygnał [`ONTICK`](#ontick) przestaje być emitowany; bieżąca liczba tyknięć nie zostaje wyzerowana.
+
+**Przykłady**
+
+```
+TIMER1^DISABLE();
+```
+
+### ENABLE
+
+```
+void ENABLE()
+```
+
+Włącza timer i ustawia punkt odniesienia odmierzania na *teraz*. Pierwszy tick po wywołaniu zostanie wyemitowany po upływie pełnego `ELAPSE`, niezależnie od tego, ile czasu minęło od ostatniego wyłączenia.
+
+**Przykłady**
+
+```
+TIMCNV^ENABLE();
+TIMER2^ENABLE();
+```
+
+### GETTICKS
+
+```
+INTEGER GETTICKS()
+```
+
+Zwraca liczbę dotychczas wykonanych tyknięć (zmierzoną od ostatniego wywołania [`RESET`](#reset) lub od inicjalizacji).
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — liczba tyknięć.
+
+**Przykłady**
+
+```
+TIMER1^GETTICKS();
+```
+
+### RESET
+
+```
+void RESET()
+```
+
+Zeruje licznik tyknięć i ustawia punkt odniesienia odmierzania na *teraz*.
+
+**Przykłady**
+
+```
+TIMER1^RESET();
+```
+
+### SET
+
+```
+void SET(INTEGER ticks)
+```
+
+Ustawia limit tyknięć w polu [`TICKS`](#ticks). Wartość `0` znosi limit (timer tyka bez końca).
+
+**Parametry**
+
+- `ticks` — nowy limit cykli.
+
+### SETELAPSE
+
+```
+void SETELAPSE(INTEGER timeMs)
+```
+
+Ustawia długość cyklu timera w milisekundach i ustawia punkt odniesienia odmierzania na *teraz*.
+
+**Parametry**
+
+- `timeMs` — nowa długość cyklu (w milisekundach).
+
+**Przykłady**
+
+```
+TIMERSEQ^SETELAPSE(RANDOM^GET(30000,10000));
+TIMERPIECHUR^SETELAPSE(ARRAYPIECHURZYPARAM^GET(0));
+TIMER1^SETELAPSE(VARTIMEUFO);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONTICK
+
+Wywoływany po każdym pełnym cyklu o długości [`ELAPSE`](#elapse), o ile timer jest włączony. Argumentem (`$1`) jest aktualna liczba tyknięć (`currentTickCount`).
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/VECTOR.md
+++ b/docs/pl/reference/VECTOR.md
@@ -0,0 +1,160 @@
+# VECTOR
+
+N-wymiarowy wektor liczb zmiennoprzecinkowych. W praktyce wykorzystywany do reprezentowania współrzędnych dwu- lub trójwymiarowych — w grach z silnika spotykany m.in. w minigrach z fizyką (odbicia, normalizacja kierunku ruchu).
+
+Wartość zmiennej (`value`) typu `VECTOR` to długość euklidesowa wektora, czyli `sqrt(x1² + x2² + … + xN²)`.
+
+## Pola
+
+### SIZE
+
+```
+INTEGER SIZE
+```
+
+Liczba współrzędnych wektora. Wartości w grach to zwykle `2` lub `3`.
+
+### VALUE
+
+```
+DOUBLE, DOUBLE, [DOUBLE...] VALUE
+```
+
+Lista wartości startowych poszczególnych współrzędnych. Liczba pozycji powinna odpowiadać polu [`SIZE`](#size).
+
+## Metody
+
+### ADD
+
+```
+void ADD(STRING|VECTOR vectorName)
+```
+
+Dodaje do bieżącego wektora wartości drugiego wektora pozycyjnie. Wynik jest zapisywany w wektorze, na którym wywołano metodę.
+
+**Parametry**
+
+- `vectorName` — wektor dodawany; przekazany jako [`STRING`](STRING.md) (nazwa) lub bezpośrednio jako `VECTOR`.
+
+**Przykłady**
+
+```
+VTEMP2^ADD("VTOCENTER");
+VTEMP2^ADD(VTOCENTER);
+```
+
+### ASSIGN
+
+```
+void ASSIGN(DOUBLE x1, DOUBLE x2, [DOUBLE...])
+```
+
+Przypisuje wektorowi nowe wartości współrzędnych. Liczba argumentów wyznacza, ile współrzędnych zostanie nadpisanych — pozostałe (jeśli wektor był większy) zachowują swoje wcześniejsze wartości. Jeśli liczba argumentów przekracza bieżącą długość wektora, wektor zostaje rozszerzony.
+
+**Parametry**
+
+- `x1, x2, …` — kolejne nowe wartości współrzędnych.
+
+**Przykłady**
+
+```
+VTEMP1^ASSIGN(0.0,0.0);
+VTEMP1^ASSIGN(ARRDIRX^GET(VARPLAYER),ARRDIRY^GET(VARPLAYER));
+VNORMAL^ASSIGN([ARRPOSX^GET(VARPLAYER)+ARRHWIDTH^GET(VARPLAYER)],[ARRPOSY^GET(VARPLAYER)+ARRHHEIGHT^GET(VARPLAYER)]);
+```
+
+### GET
+
+```
+DOUBLE GET(INTEGER index)
+```
+
+Zwraca wartość współrzędnej o podanym indeksie (liczonym od zera). Dla indeksów spoza zakresu zwracana jest wartość `0.0`.
+
+**Parametry**
+
+- `index` — indeks współrzędnej (`0`-bazowany).
+
+**Zwraca**: [`DOUBLE`](DOUBLE.md) — wartość współrzędnej lub `0.0`.
+
+**Przykłady**
+
+```
+VTEMP1^GET(0);
+VTEMP1^GET(1);
+```
+
+### LEN
+
+```
+DOUBLE LEN()
+```
+
+Zwraca długość euklidesową wektora.
+
+**Zwraca**: [`DOUBLE`](DOUBLE.md) — długość wektora.
+
+### MUL
+
+```
+void MUL(DOUBLE scalar)
+```
+
+Mnoży każdą współrzędną wektora przez skalar.
+
+**Parametry**
+
+- `scalar` — mnożnik.
+
+**Przykłady**
+
+```
+VTEMP1^MUL(10.0);
+VTEMP1^MUL(ARRSPEED^GET(VARPLAYER));
+VTEMP2^MUL(-1);
+```
+
+### NORMALIZE
+
+```
+void NORMALIZE()
+```
+
+Normalizuje wektor do długości `1` (dzieli każdą współrzędną przez aktualną długość). Wywołanie na wektorze zerowym nie zmienia jego wartości.
+
+**Przykłady**
+
+```
+VNORMAL^NORMALIZE();
+VTEMP1^NORMALIZE();
+```
+
+### REFLECT
+
+```
+void REFLECT(STRING|VECTOR normalVector, STRING|VECTOR resultVector)
+```
+
+Oblicza odbicie bieżącego wektora względem wektora normalnego i zapisuje wynik do wektora docelowego. Bieżący wektor pozostaje niezmieniony.
+
+**Parametry**
+
+- `normalVector` — wektor normalny do powierzchni, względem której następuje odbicie.
+- `resultVector` — wektor, do którego zostanie zapisany wynik.
+
+**Przykłady**
+
+```
+VINCIDENT^REFLECT("VNORMAL","VREFLECT");
+VINCIDENT^REFLECT(VNORMAL,VREFLECT);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/VIRTUALGRAPHICSOBJECT.md
+++ b/docs/pl/reference/VIRTUALGRAPHICSOBJECT.md
@@ -0,0 +1,213 @@
+# VIRTUALGRAPHICSOBJECT
+
+Wirtualny obiekt graficzny — pełni rolę proxy lub kompozytu dla rzeczywistego obiektu wskazanego polem [`SOURCE`](#source). Pozwala traktować inny element graficzny jak osobną encję z własną pozycją, priorytetem, maską i flagami kolizji.
+
+W skryptach gier ten typ pojawia się punktowo — głównie w *Reksio i Czarodzieje* (`common\classes\SinglePuzzle.class`).
+
+## Pola
+
+### ASBUTTON
+
+```
+BOOL ASBUTTON
+```
+
+Określa, czy obiekt ma być traktowany jako klikalny przycisk.
+
+### MASK
+
+```
+STRING MASK
+```
+
+Nazwa zmiennej graficznej używanej jako maska wycinająca przy renderowaniu obiektu.
+
+### MONITORCOLLISION
+
+```
+BOOL MONITORCOLLISION
+```
+
+Włącza monitorowanie kolizji z innymi obiektami graficznymi.
+
+### MONITORCOLLISIONALPHA
+
+```
+BOOL MONITORCOLLISIONALPHA
+```
+
+Włącza monitorowanie kolizji z uwzględnieniem kanału przezroczystości — kolizja jest wykrywana tylko, gdy nakładające się piksele są nieprzezroczyste.
+
+### PRIORITY
+
+```
+INTEGER PRIORITY
+```
+
+Priorytet rysowania (pozycja w osi Z).
+
+### SOURCE
+
+```
+STRING SOURCE
+```
+
+Nazwa zmiennej graficznej, której zawartość jest renderowana przez obiekt wirtualny.
+
+### TOCANVAS
+
+```
+BOOL TOCANVAS
+```
+
+Określa, czy obiekt jest rysowany na kanwie.
+
+### VISIBLE
+
+```
+BOOL VISIBLE
+```
+
+Określa, czy obiekt jest widoczny.
+
+## Metody
+
+### GETHEIGHT
+
+```
+INTEGER GETHEIGHT()
+```
+
+Zwraca wysokość obiektu w pikselach.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — wysokość.
+
+### GETPOSITIONX
+
+```
+INTEGER GETPOSITIONX()
+```
+
+Zwraca pozycję X obiektu.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata X.
+
+### GETPOSITIONY
+
+```
+INTEGER GETPOSITIONY()
+```
+
+Zwraca pozycję Y obiektu.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — koordynata Y.
+
+### GETWIDTH
+
+```
+INTEGER GETWIDTH()
+```
+
+Zwraca szerokość obiektu w pikselach.
+
+**Zwraca**: [`INTEGER`](INTEGER.md) — szerokość.
+
+### MOVE
+
+```
+void MOVE(INTEGER offsetX, INTEGER offsetY)
+```
+
+Przesuwa obiekt o zadane wartości względem aktualnej pozycji.
+
+**Parametry**
+
+- `offsetX`, `offsetY` — wektor przesunięcia.
+
+**Przykłady**
+
+```
+VGO^MOVE($1,$2);
+```
+
+### SETMASK
+
+```
+void SETMASK(STRING maskName)
+```
+
+Ustawia maskę wycinającą — odpowiednik pola [`MASK`](#mask).
+
+**Parametry**
+
+- `maskName` — nazwa zmiennej graficznej pełniącej rolę maski.
+
+**Przykłady**
+
+```
+VGO^SETMASK(MSK);
+```
+
+### SETPOSITION
+
+```
+void SETPOSITION(INTEGER posX, INTEGER posY)
+```
+
+Ustawia bezwzględną pozycję obiektu.
+
+**Parametry**
+
+- `posX`, `posY` — nowa pozycja.
+
+**Przykłady**
+
+```
+VGO^SETPOSITION($1,$2);
+```
+
+### SETPRIORITY
+
+```
+void SETPRIORITY(INTEGER priority)
+```
+
+Ustawia priorytet rysowania (pozycję w osi Z) — odpowiednik pola [`PRIORITY`](#priority).
+
+**Parametry**
+
+- `priority` — nowa wartość priorytetu.
+
+**Przykłady**
+
+```
+VGO^SETPRIORITY(1000);
+```
+
+### SETSOURCE
+
+```
+void SETSOURCE(STRING sourceName)
+```
+
+Ustawia zmienną graficzną wskazywaną przez pole [`SOURCE`](#source).
+
+**Parametry**
+
+- `sourceName` — nazwa zmiennej graficznej.
+
+**Przykłady**
+
+```
+VGO^SETSOURCE($2);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/WORLD.md
+++ b/docs/pl/reference/WORLD.md
@@ -0,0 +1,549 @@
+# WORLD
+
+Interfejs do silnika fizycznego 3D zbudowanego na bibliotece Sekai — cienkiego wrappera Open Dynamics Engine (ODE). Świat zarządza ciałami sztywnymi, ich połączeniami i ścieżkami, oraz emituje siły, grawitację i tłumienia. Wersja 3D używana w grach Piklib. Pojęciowo odpowiednik [`INERTIA`](INERTIA.md), ale z dostępem do trzeciej osi i własnym, znacznie szerszym API.
+
+Każdy obiekt w świecie identyfikowany jest liczbą całkowitą (`objectId`). Świat ładowany jest z pliku `.SEK`, który zawiera definicje obiektów, ich parametrów fizycznych, siatek kolizyjnych, listy punktów na scenie oraz ich połączeń.
+
+## Typy geometrii
+
+Wartości akceptowane przez parametr `geomType` metody [`ADDBODY`](#addbody):
+
+| Wartość | Geometria |
+| --- | --- |
+| `0` | prostopadłościan (box) |
+| `1` | cylinder |
+| `2` | sfera |
+| `3` | trimesh (siatka trójkątów; używana wyłącznie podczas ładowania z pliku `.SEK`) |
+| `4` | samochodzik (cztery koła + prostopadłościan) |
+
+## Pola
+
+### FILENAME
+
+```
+STRING FILENAME
+```
+
+Ścieżka do pliku `.SEK` z definicją świata fizycznego.
+
+## Metody
+
+### ADDBODY
+
+```
+void ADDBODY(INTEGER objectId, DOUBLE mass, DOUBLE mu, DOUBLE mu2,
+             DOUBLE bounce, DOUBLE bounceVelocity, DOUBLE maxVelocity,
+             INTEGER bodyType, INTEGER geomType,
+             DOUBLE dim1, DOUBLE dim2, DOUBLE dim3)
+```
+
+Tworzy w świecie nowe ciało fizyczne. Parametry `mass`, `mu`, `mu2`, `bounce` i `bounceVelocity` są mapowane bezpośrednio na odpowiednie parametry ODE: masa, tarcie, tarcie w drugim kierunku, wartość odbicia oraz minimalna prędkość wymagana do odbicia. `maxVelocity` ogranicza prędkość obiektu.
+
+Wymiary `dim1`, `dim2`, `dim3` zależą od `geomType`:
+
+- **box** — długości w osiach X, Y, Z.
+- **cylinder** — `dim1` to promień, `dim2` wysokość; `dim3` ignorowane.
+- **sfera** — `dim1` to promień; `dim2` i `dim3` ignorowane.
+
+**Parametry**
+
+- `objectId` — identyfikator nowego ciała.
+- `mass` — masa obiektu.
+- `mu`, `mu2` — współczynniki tarcia.
+- `bounce` — wartość odbicia.
+- `bounceVelocity` — minimalna prędkość wymagana do odbicia.
+- `maxVelocity` — limit prędkości obiektu.
+- `bodyType` — typ ciała (znaczenie zarezerwowane przez ODE).
+- `geomType` — typ geometrii (zobacz [Typy geometrii](#typy-geometrii)).
+- `dim1`, `dim2`, `dim3` — wymiary obiektu zgodnie z geometrią.
+
+**Przykłady**
+
+```
+WORLD^ADDBODY(100,10,0.0,10000.0,0.0,0.0,40000,1,2,30,16,16);
+WORLD^ADDBODY(VARINT0,0.1,0.5,0.5,0.0,0.0,100000,1,2,16,16,16);
+```
+
+### ADDFORCE
+
+```
+void ADDFORCE(INTEGER objectId, DOUBLE forceX, DOUBLE forceY, [DOUBLE forceZ])
+```
+
+Przykłada siłę do obiektu w trzech osiach. Pominięcie `forceZ` jest równoważne podaniu `0.0`.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `forceX`, `forceY`, `forceZ` — składowe siły.
+
+**Przykłady**
+
+```
+WORLD^ADDFORCE(100,VARFORCEX,VARFORCEY,0);
+WTEST^ADDFORCE(501,0,VARD_TMP1,0);
+```
+
+### ADDGRAVITYEX
+
+```
+void ADDGRAVITYEX(INTEGER objectId, INTEGER secondObjectId, BOOL gravityEx)
+```
+
+Dodaje rozszerzoną grawitację pomiędzy dwoma obiektami. Pełne znaczenie nie zostało ustalone.
+
+**Przykłady**
+
+```
+WTEST^ADDGRAVITYEX(VARI_ID,_I_,TRUE);
+```
+
+### FINDPATH
+
+```
+void FINDPATH(INTEGER objectId, INTEGER pointObjectId,
+              INTEGER targetX, INTEGER targetY, INTEGER targetZ,
+              BOOL saveIntermediates, [BOOL flag])
+```
+
+Wyznacza ścieżkę dla obiektu między aktualną pozycją a punktem docelowym, korzystając z grafu nawigacyjnego załadowanego z pliku `.SEK`. Wynik jest zapamiętywany przez silnik fizyczny i wykorzystywany w kolejnych wywołaniach [`FOLLOWPATH`](#followpath).
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu, dla którego liczona jest ścieżka.
+- `pointObjectId` — identyfikator punktu nawigacyjnego (zaczepu).
+- `targetX`, `targetY`, `targetZ` — koordynaty punktu docelowego.
+- `saveIntermediates` — gdy `TRUE`, zapamiętywane są punkty pośrednie ścieżki.
+- `flag` — (opcjonalnie) flaga konfiguracyjna (znaczenie nieustalone).
+
+**Przykłady**
+
+```
+WPATH^FINDPATH(100,VARIPATHID,$3,$4,0,TRUE,FALSE);
+WPATH^FINDPATH(101,VARIPATHID,VARIKRETGOX,VARIKRETGOY,0,FALSE);
+```
+
+### FOLLOWPATH
+
+```
+DOUBLE FOLLOWPATH(INTEGER objectId, INTEGER arrivalRadius, DOUBLE turnClamp, DOUBLE speed)
+```
+
+Przemieszcza obiekt wzdłuż ścieżki wyznaczonej wcześniej przez [`FINDPATH`](#findpath). Zwraca pozostały dystans do celu.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `arrivalRadius` — promień, w którym obiekt uważany jest za zatrzymany przy celu.
+- `turnClamp` — ograniczenie skrętu na jednym kroku.
+- `speed` — prędkość ruchu.
+
+**Zwraca**: [`DOUBLE`](DOUBLE.md) — pozostały dystans.
+
+**Przykłady**
+
+```
+WPATH^FOLLOWPATH(100,20,0.5,VARDMAXVEL);
+WPATH^FOLLOWPATH(101,20,0.5,VARD_KRETSPEED);
+```
+
+### GETANGLE
+
+```
+DOUBLE GETANGLE(INTEGER objectId)
+```
+
+Zwraca kąt wynikający z wektora prędkości obiektu (w stopniach).
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+
+**Zwraca**: [`DOUBLE`](DOUBLE.md) — kąt w stopniach.
+
+### GETBKGPOSX
+
+```
+INTEGER GETBKGPOSX()
+```
+
+Zwraca pozycję X tła powiązanego ze światem fizycznym.
+
+### GETBKGPOSY
+
+```
+INTEGER GETBKGPOSY()
+```
+
+Zwraca pozycję Y tła powiązanego ze światem fizycznym.
+
+### GETMOVEDISTANCE
+
+```
+DOUBLE GETMOVEDISTANCE(INTEGER objectId)
+```
+
+Zwraca dystans pokonany przez obiekt od ostatniego resetu pomiaru.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+
+### GETPOSITIONX
+
+```
+INTEGER GETPOSITIONX(INTEGER objectId)
+```
+
+Zwraca pozycję X obiektu w układzie ekranu (po przesunięciu o `+400` względem początku układu fizyki).
+
+### GETPOSITIONY
+
+```
+INTEGER GETPOSITIONY(INTEGER objectId)
+```
+
+Zwraca pozycję Y obiektu w układzie ekranu (z odwróconą osią — `300 - Y`).
+
+### GETPOSITIONZ
+
+```
+INTEGER GETPOSITIONZ(INTEGER objectId)
+```
+
+Zwraca pozycję Z obiektu.
+
+### GETROTATIONZ
+
+```
+DOUBLE GETROTATIONZ(INTEGER objectId)
+```
+
+Zwraca kąt obrotu obiektu względem osi Z (w stopniach).
+
+### GETSPEED
+
+```
+DOUBLE GETSPEED(INTEGER objectId)
+```
+
+Zwraca prędkość obiektu (długość wektora prędkości liniowej).
+
+### JOIN
+
+```
+void JOIN(INTEGER firstId, INTEGER secondId,
+          DOUBLE anchorX, DOUBLE anchorY, DOUBLE anchorZ,
+          DOUBLE limitMotor, DOUBLE lowStop, DOUBLE highStop,
+          [DOUBLE hingeAxisX, DOUBLE hingeAxisY, DOUBLE hingeAxisZ])
+```
+
+Tworzy połączenie zawiasowe (hinge joint) pomiędzy dwoma ciałami. Opcjonalne argumenty wyznaczają oś obrotu — domyślnie `(0, 0, 1)`.
+
+**Parametry**
+
+- `firstId`, `secondId` — identyfikatory łączonych obiektów.
+- `anchorX`, `anchorY`, `anchorZ` — punkt kotwiczenia połączenia.
+- `limitMotor` — wartość siły potrzebna do zerwania połączenia.
+- `lowStop`, `highStop` — graniczne kąty obrotu.
+- `hingeAxisX`, `hingeAxisY`, `hingeAxisZ` — (opcjonalnie) oś obrotu.
+
+**Przykłady**
+
+```
+WORLD^JOIN(199,200,400,300,0,0,-180,180);
+WTEST^JOIN(VARI_ID,VARI_TMP1,VARI_X,VARI_TMP2,0,0,-180,180,0,1,0);
+```
+
+### LINK
+
+```
+void LINK(INTEGER objectId, STRING objectName)
+```
+
+Wiąże ciało fizyczne ze zmienną [`ANIMO`](ANIMO.md) lub [`IMAGE`](IMAGE.md) — pozycja grafiki jest aktualizowana na podstawie pozycji ciała.
+
+**Parametry**
+
+- `objectId` — identyfikator ciała.
+- `objectName` — nazwa zmiennej graficznej.
+
+**Przykłady**
+
+```
+WPATH^LINK(100,"ANNREX");
+WORLD^LINK(VARINT0,VARSTRING0);
+```
+
+### LOAD
+
+```
+void LOAD(STRING filename)
+```
+
+Resetuje silnik fizyczny i ładuje świat z pliku `.SEK`.
+
+**Parametry**
+
+- `filename` — ścieżka do pliku `.SEK`.
+
+**Przykłady**
+
+```
+WPATH^LOAD(SOBJECT|NAME);
+```
+
+### MOVEOBJECTS
+
+```
+DOUBLE MOVEOBJECTS()
+```
+
+Wykonuje jeden krok symulacji i przesuwa wszystkie obiekty zgodnie z prawami fizyki. Zwraca czas, który upłynął w symulacji w tym kroku.
+
+**Zwraca**: [`DOUBLE`](DOUBLE.md) — czas symulacji.
+
+**Przykłady**
+
+```
+WORLD^MOVEOBJECTS();
+```
+
+### REMOVEOBJECT
+
+```
+void REMOVEOBJECT(INTEGER objectId)
+```
+
+Usuwa obiekt z silnika fizycznego.
+
+**Przykłady**
+
+```
+WTEST^REMOVEOBJECT(60);
+```
+
+### SETACTIVE
+
+```
+void SETACTIVE(INTEGER objectId, BOOL active, BOOL collidable)
+```
+
+Ustawia stan aktywności obiektu.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `active` — czy obiekt podlega symulacji.
+- `collidable` — czy obiekt bierze udział w wykrywaniu kolizji.
+
+**Przykłady**
+
+```
+WPATH^SETACTIVE(VARI_3DPATHID,$1,$2);
+```
+
+### SETBKGSIZE
+
+```
+void SETBKGSIZE(INTEGER leftX, INTEGER rightX, INTEGER topY, INTEGER bottomY)
+```
+
+Ustawia rozmiar prostokąta tła powiązanego ze światem.
+
+### SETG
+
+```
+void SETG(INTEGER objectId, DOUBLE g)
+```
+
+Ustawia indywidualną stałą grawitacyjną dla obiektu (modeluje magnesy). Domyślna wartość `0` oznacza brak przyciągania.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `g` — stała grawitacyjna.
+
+**Przykłady**
+
+```
+WTEST^SETG(VARI_ID,VARD_MAGNESREACT);
+WTEST^SETG(501,-7000000);
+```
+
+### SETGRAVITY
+
+```
+void SETGRAVITY(DOUBLE gravityX, DOUBLE gravityY, DOUBLE gravityZ)
+```
+
+Ustawia wektor grawitacji globalnej dla całego świata.
+
+**Parametry**
+
+- `gravityX`, `gravityY`, `gravityZ` — składowe grawitacji.
+
+**Przykłady**
+
+```
+WORLD^SETGRAVITY(0,0,-1000);
+WORLD^SETGRAVITY(0,-15,0);
+```
+
+### SETGRAVITYCENTER
+
+```
+void SETGRAVITYCENTER(INTEGER objectId, BOOL gravityCenter)
+```
+
+Włącza lub wyłącza traktowanie obiektu jako źródła centralnego pola grawitacyjnego.
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `gravityCenter` — flaga włączająca.
+
+### SETLIMIT
+
+```
+void SETLIMIT(INTEGER objectId, INTEGER minX, INTEGER minY, INTEGER minZ,
+              INTEGER maxX, INTEGER maxY, INTEGER maxZ)
+```
+
+Ustawia ograniczenie pozycji obiektu (prostopadłościenny obszar dozwolonego ruchu).
+
+**Parametry**
+
+- `objectId` — identyfikator obiektu.
+- `minX`, `minY`, `minZ` — dolne granice w trzech osiach.
+- `maxX`, `maxY`, `maxZ` — górne granice w trzech osiach.
+
+**Przykłady**
+
+```
+WORLD^SETLIMIT(100,0,0,0,800,600,999999);
+```
+
+### SETMAXSPEED
+
+```
+void SETMAXSPEED(INTEGER objectId, INTEGER maxSpeed)
+```
+
+Ustawia maksymalną prędkość obiektu.
+
+**Przykłady**
+
+```
+WORLD^SETMAXSPEED(100,200);
+```
+
+### SETMOVEFLAGS
+
+```
+void SETMOVEFLAGS(BOOL moveX, BOOL moveY)
+```
+
+Włącza lub wyłącza ruch obiektu w osiach X i Y. Pełne znaczenie i kontekst zastosowania nie zostały ustalone.
+
+**Przykłady**
+
+```
+WPATH^SETMOVEFLAGS(VARITEMP0,VARITEMP1);
+```
+
+### SETPOSITION
+
+```
+void SETPOSITION(INTEGER objectId, DOUBLE x, DOUBLE y, DOUBLE z)
+```
+
+Ustawia bezwzględną pozycję obiektu (koordynaty w układzie ekranu — silnik przelicza je na układ fizyki).
+
+**Przykłady**
+
+```
+WORLD^SETPOSITION(100,150,400,0);
+WTEST^SETPOSITION(VARI_ID,VARI_X,VARI_Y,0);
+```
+
+### SETREFOBJECT
+
+```
+void SETREFOBJECT(INTEGER objectId)
+```
+
+Ustawia obiekt jako referencyjny — używany przy obliczeniach pozycji względem niego.
+
+**Przykłady**
+
+```
+WPATH^SETREFOBJECT(100);
+```
+
+### SETVELOCITY
+
+```
+void SETVELOCITY(INTEGER objectId, DOUBLE speedX, DOUBLE speedY, DOUBLE speedZ)
+```
+
+Ustawia prędkość obiektu w trzech osiach.
+
+**Przykłady**
+
+```
+WORLD^SETVELOCITY(207,5000000,0,0);
+WORLD^SETVELOCITY(VARPLAYERID,0,0,0);
+```
+
+### START
+
+```
+void START()
+```
+
+Uruchamia symulację (włącza timer silnika fizycznego).
+
+**Przykłady**
+
+```
+WORLD^START();
+```
+
+### STOP
+
+```
+void STOP()
+```
+
+Zatrzymuje symulację (wyłącza timer silnika fizycznego). Stan obiektów pozostaje zachowany.
+
+**Przykłady**
+
+```
+WORLD^STOP();
+```
+
+### UNLINK
+
+```
+void UNLINK(INTEGER objectId)
+```
+
+Zrywa powiązanie obiektu z animacją utworzone metodą [`LINK`](#link).
+
+**Przykłady**
+
+```
+WTEST^UNLINK(VARI_TMP2);
+```
+
+## Sygnały
+
+### ONINIT
+
+Wywoływany w momencie inicjalizacji obiektu.
+
+### ONSIGNAL
+
+Wywoływany po otrzymaniu sygnału (zobacz [Zdarzenia i sygnały](../engine/events.md#onsignal)).
--- a/docs/pl/reference/index.md
+++ b/docs/pl/reference/index.md
@@ -1,6 +1,6 @@
 # Referencja typów

-Spis typów danych dostępnych w skryptach silnika Piklib/BlooMoo. Lista będzie uzupełniana w miarę opracowywania kolejnych stron.
+Spis typów danych dostępnych w skryptach silnika Piklib/BlooMoo, pogrupowanych tematycznie.

 ## Typy używane w skryptach

@@ -32,6 +32,24 @@ Spis typów danych dostępnych w skryptach silnika Piklib/BlooMoo. Lista będzie
 - [EPISODE](EPISODE.md) — logiczny segment gry.
 - [SCENE](SCENE.md) — pojedyncza scena.

+### Interakcja i kompozycja
+
+- [BUTTON](BUTTON.md) — interaktywny przycisk z trzema stanami wizualnymi.
+- [CANVAS_OBSERVER](CANVAS_OBSERVER.md) — operacje na kanwie i tle.
+- [CNVLOADER](CNVLOADER.md) — dynamiczne ładowanie plików `.CNV`.
+- [GROUP](GROUP.md) — grupa zmiennych z delegowanymi wywołaniami metod.
+- [PATTERN](PATTERN.md) — wielowarstwowa plansza kafelkowa.
+- [STATICFILTER](STATICFILTER.md) — filtr graficzny (rotacja, skalowanie, blur).
+- [VIRTUALGRAPHICSOBJECT](VIRTUALGRAPHICSOBJECT.md) — wirtualny obiekt graficzny.
+
+### Dane
+
+- [DATABASE](DATABASE.md) — baza danych z kursorem.
+
+### Fizyka 3D
+
+- [WORLD](WORLD.md) — interfejs 3D silnika fizycznego opartego na ODE.
+
 ### Wbudowane obiekty I/O

 - [KEYBOARD](KEYBOARD.md) — stan klawiatury.
@@ -48,8 +66,11 @@ Spis typów danych dostępnych w skryptach silnika Piklib/BlooMoo. Lista będzie
 - [SOUND](SOUND.md) — krótki efekt dźwiękowy.
 - [TEXT](TEXT.md) — tekst wyświetlany na ekranie.

-## Pozostałe typy
+### Matematyczne i narzędziowe

-Strony dla poniższych typów zostaną dodane w następnej kolejności:
-
-BUTTON, CANVAS_OBSERVER, CNVLOADER, DATABASE, EXPRESSION, GROUP, INERTIA, MATRIX, PATTERN, STATICFILTER, STRUCT, TIMER, VECTOR, VIRTUALGRAPHICSOBJECT, WORLD.
+- [EXPRESSION](EXPRESSION.md) — wyrażenie arytmetyczne dwuargumentowe.
+- [INERTIA](INERTIA.md) — interfejs wbudowanego silnika fizycznego 2D.
+- [MATRIX](MATRIX.md) — siatka pól z systemem fizyki kamieni.
+- [STRUCT](STRUCT.md) — struktura danych z nazwanymi polami.
+- [TIMER](TIMER.md) — cykliczny licznik czasu.
+- [VECTOR](VECTOR.md) — N-wymiarowy wektor liczb zmiennoprzecinkowych.