CYBER27 — własny system operacyjny

CYBER27 BASIC 27-BIT

PROGRAM to lista linii. Kazda linia
ma NUMER i TRESC:

     10 PRINT "OK"
     ^^ ^^^^^^^^^^
     |  +-- tresc (co zrobic)
     +----- numer (kolejnosc)

NUMERY decyduja o KOLEJNOSCI wykonania,
nie o kolejnosci wpisania. Dlatego
mozesz dopisac linie 15 miedzy 10 a 20
i wykona sie wlasciwie.

REJESTRY: R0, R1 ... R7
  8 komorek na liczby. Najszybsze.

PAMIEC: 256 slow (adresy 0x00..0xFF)
  Wieksza niz rejestry, wolniejsza.
  Dostep przez POKE i PEEK.

LICZBY: zmiennoprzecinkowe (jak C64,
ale dokladniejsze). Dziala kropka
i znak minus:
  PRINT 1/2    ->  0.5
  PRINT 10/3   ->  3.33333333
  PRINT -5     ->  -5
PAMIEC (POKE/PEEK) i operatory bitowe
zostaja 27-bitowe (0x07FFFFFF).

NUMERACJA W LOCIE: w edytorze nowa
linia sama dostaje numer (10,20,30...).
Mozesz tez wpisac numer recznie.

PRINT "TEKST"   wypisz tekst
  Cudzyslow OBOWIAZKOWY dla tekstu!
  PRINT "WITAJ"

PRINT R3        wypisz ZAWARTOSC
  rejestru — BEZ cudzyslowu

PRINT "A", R0  WIELE elementow
  ',' odstep, ';' bez odstepu
  koncowe ';' = bez nowej linii

?               skrot od PRINT
  ? R0  to samo co PRINT R0

LIST            wypisz caly program
  z numerami linii

RUN             URUCHOM program
  Wykonuje od najmniejszego numeru
  do konca programu.

NEW             wyczysc program
  Usuwa WSZYSTKIE linie.
  UWAGA: nie ma cofniecia!

CLS             wyczysc ekran
CLEAR           wyczysc rejestry
STATUS          pokaz stan rejestrow
BOOT            pokaz ekran startowy

REM tekst       KOMENTARZ
  Linia ignorowana przez interpreter.
  Uzyj do opisania, co robi program.

RND(n)          liczba losowa [0, n)
  INT(RND(6))+1  ->  kosc 1..6
INT(x)          czesc calkowita (podloga)
RANDOMIZE       nowe ziarno dla RND

DZWIEK (SID):
  PLAY glos,freq,w   w: 0=PUL 1=SAW
                      2=TRI 3=SINE 4=NOISE
  NOTE freq,dur   TEMPO bpm   STOP
  ENV glos,a,d,s,r  obwiednia (ms)
  PULSE glos,w   0..4095 (2048=50%)
  PAN glos,p     0=lewo .. 15=prawo
  ARP glos,n1,n2[,n3]  akord na 1 glosie
  TRACK n1,n2,n3,n4[,dur]  wiersz utworu
  SONG              odtworz utwor (petla)
  SONGCLR           wyczysc utwor

TEKSTY: zmienne A$..Z$
  A$ = "Witaj"
  B$ = A$ + "!"      sklejanie '+ '
  PRINT A$, LEN(A$)
  LEFT$/RIGHT$(A$,n)
  MID$(A$,i,n)  (i od 1)
  CHR$(n) ASC(a$) STR$(n) VAL(a$)
  IF A$ = "Witaj" THEN PRINT "OK"

GRA:  GET R0   ostatni klawisz
  200/201/202/203 = L/P/G/D, 13=ENTER
  FRAME [fps]  staly takt klatki!
  (FRAME=50fps; NIE dziala jak WAIT!)
  WAIT ms        czekaj (np. WAIT 50)
  MOVSPR s,dx,dy  przesun sprite
  SPRCOL d,a,b   kolizja sprite'ow

MYSZ (edytory, menu):
  MOUSEGRID Rx,Ry  pozycja (PIKSELE
           GRAFIKI 0..163 / 0..127)
  MOUSEX Rn / MOUSEY Rn  j.w. pojedynczo
  MOUSESX Rn / MOUSESY Rn  piksele EKRANU
  MOUSEB Rn   1=lewy 2=prawy 3=oba
  MOUSECLICK Rx,Ry  nowy klik (kolejka!)
  MOUSEHOLD Rn  czy LEWY trzymany
  MOUSEDOWN Rn  czy NOWY klik (1/0)
  MOUSEWHEEL Rn  ruch rolki

SILNIK 2 - WYSOKOSCI (schody, rampy):
  W2INIT w,h        mapa z wysokosciami
  W2H x,y,p         podloga kafla (0..15)
  W2HG x,y          odczyt do R0
  W2RAMP x1,y1,x2,y2,h1,h2  rampa
  W2STEP x1,y1,x2,y2,n,h    schody
  WMAZE zloz[,seed]  labirynt
  WCAVE wyp,smooth   jaskinia (groty)
  WTUNNEL dl,komory  TUNELE (korytarze)
  WTEX2 sciana,podl,sklep  tekstury bunkra
  WLAMP 0|1          swiatla w tunelu
  WMODE 4            tryb BUNKIER (luk)
  1 jednostka = 1/4 kafla

TOZSAMOSC (adres = hash klucza, NIE IP):
  MYID A$        Twoj adres (16 znakow)
  MYID           wypisz na ekran
  MYIDRESET      nowa tozsamosc (NOWY adres!)
  Plik: IDENTITY.RAW (32 B, karta SD)

PLIKI MASOWE (edytory grafiki):
  BLOAD "plik",t[,n]  tab <- plik
  BSAVE "plik",t,n   tab -> plik
  (t = tablica A..Z, n bajtow)
  R0 = ile wczytano/zapisano

RYSOWANIE (piksele 0..163 / 0..127):
  LINE x1,y1,x2,y2[,c]
  BOX/RECT x1,y1,x2,y2[,c]
  FILLRECT x1,y1,x2,y2[,c]
  CIRCLE x,y,r[,c]
  FILLCIRCLE x,y,r[,c]
  ELLIPSE x,y,rx,ry[,c]
  FILLELLIPSE x,y,rx,ry[,c]
  ARC x,y,r,a1,a2[,c] (stopnie)
  PAINT x,y[,c]   wypelnienie
  CHAR x,y,"tekst"[,c]  napis
  SCALE n   gruby piksel (1..8)
  c = kolor 0..15 (domyslnie CO)

REJESTRY to 8 komorek: R0..R7.
Kazda trzyma liczbe zmiennoprzecinkowa
(kropka i znak, jak w C64).

SET R0, 0x123    ustaw rejestr R0
  Liczby: dziesietnie (123)
  albo szesnastkowo (0x7B).

LET R1 = 42      to samo co SET,
  ale skladnia ze znakiem '='

R0 = 5           najkrotsza forma
  Sam rejestr i '=' wystarcza.

POKE 0x10, R3    zapisz do PAMIECI
  0x10 = adres (slot 16)
  R3   = wartosc do zapisania
  Pamiec ma 256 slow (0x00..0xFF).

PEEK 0x10        odczytaj z PAMIECI
  Wynik na EKRAN. W programie uzyj
  PEEK(x) jako funkcji w wyrazeniu.

DIM A(20)        TABLICA A (indeksy 0..20)
  A(i) = 7       zapisz element
  PRINT A(i)     czytaj element
  Litery A..Z, indeks max 63.

INPUT R0         wczytaj liczbe
  od uzytkownika z klawiatury

⚙ DODANE PO PYTANIU O APOLLO ⚙

Komputer pokladowy Apollo (AGC) mial
DODAWANIE sprzętowe. CYBER27 mial
tylko operacje bitowe — dlatego nie
dal sie napisac nic, co "liczy".
Teraz jest — w liczbach zmiennoprzecinkowych.

ADD R2,R0,R1   R2 = R0 + R1
SUB R2,R0,R1   R2 = R0 - R1
MUL R2,R0,R1   R2 = R0 * R1
DIV R2,R0,R1   R2 = R0 / R1 (ulamki!)
MOD R2,R0,R1   R2 = reszta z R0/R1

Zamiast rejestru mozna podac LICZBE:
  ADD R2,R0,10     dodaj 10
  MUL R2,R0,0x10   pomnóż przez 16

PRZYKLAD:
  SET R0,7
  SET R1,3
  ADD R2,R0,R1   wynik 10
  SUB R3,R0,R1   wynik 4
  MUL R4,R0,R1   wynik 21
  DIV R5,R0,R1   wynik 2
  MOD R6,R0,R1   wynik 1

══ ZAKRES I ZNAK ══

Liczby maja teraz ZNAK i ulamki:
  SUB R2,3,7   ->  R2 = -4
  DIV R2,1,2   ->  R2 = 0.5
Zakres ogromny (jak double) — nie
musisz sie martwic o obciecie.

Dzielenie MOD przez zero = BLAD:
  DIV R2,R0,0   przerwie program
  Na UART: "DIV: dzielenie przez zero"

Operatory BITOWE (AND/OR/XOR/SHL/
SHR/NOT) obcinaja do 27 bitow —
bo dzialaja na slowach pamieci.

SQR dest,source    PIERWIASTEK
POW dest,base,exp  POTEGA

Uwaga: to NIE sa zwykle funkcje.
AGC w Apollo liczylo pierwiastki
do nawigacji — i robil to tak samo:
metoda Newtona, krok po kroku.

══ SQR — PIERWIASTEK ══

  SET R0,144
  SQR R1,R0     R1 = 12

Wynik z ulamkiem (prawdziwy pierwiastek):
SQR R1,144  =  12
SQR R1,2    =  1.41421356
SQR R1,10   =  3.16227766

Liczba ujemna = blad:
  "SQR: liczba ujemna"

══ POW — POTEGA ══

  POW R2,2,10     R2 = 2^10 = 1024
  POW R2,3,4      R2 = 3^4  = 81
  POW R2,5,3      R2 = 5^3  = 125

Uwaga: 2^10 to 2 podniesione
do potegi 10, czyli 1024.
NIE mylić z XOR!

Potegowanie jest zmiennoprzecinkowe:
  POW R2,2,30   →  1.07374182E+09
  POW R2,2,0.5  →  1.41421356

══ PRZYKLAD: SPRAWDZANIE ══

  SET R0,100
  SQR R1,R0      R1 = 10
  MUL R2,R1,R1   R2 = 100 (z powrotem)
  POW R3,10,3    R3 = 1000

To jest test poprawnosci: pierwiastek
podniesiony do kwadratu daje oryginal

══ SIN, COS, PI — FALE (2026-10-10) ══

SIN(x)  sinus kata x (w radianach)
COS(x)  cosinus kata x
PI      ~3.14159 (stala)

SIN(0)      = 0
SIN(PI/2)   = 1   (cwierc okresu)
SIN(PI)     = 0
COS(0)      = 1

Jeden pelny okres = 2*PI (~6.28).
Fala: y = SIN(x) * wysokosc.

══ FLIP — ODSWIEZ EKRAN ══

FLIP wymusza odrysowanie ekranu
w tym miejscu. Gry rysujace przez
TP/LINE/BOX wolaja FLIP co klatke,
zeby obraz byl plyny:
  100 rysuj...
  110 FLIP
  120 WAIT 15
  130 GOTO 100

PRZYKLADY FAL (pokoj NAUKA):
  LOAD "FALA"      wykres sinusa
  LOAD "OSCYLOSKOP" petle Lissajous

Operacje BITOWE — na kazdym bicie
osobno. To NIE jest zwykla matematyka.

AND R2,R0,R1   iloczyn bitowy
  Wynik 1 tylko gdy OBA bity sa 1.
    1100 AND 1010 = 1000

OR  R2,R0,R1   suma bitowa
  Wynik 1 gdy KTORYKOLWIEK bit jest 1.
    1100 OR  1010 = 1110

XOR R2,R0,R1   roznica bitowa
  Wynik 1 gdy bity sie ROZNIA.
    1100 XOR 1010 = 0110

NOT R2,R0      negacja
  Zamienia kazde 0 na 1 i odwrotnie.

SHL R2,R0,3    przesun w LEWO o 3
  To mnozenie przez 2^3 = 8.
    0001 SHL 1 = 0010

SHR R2,R0,2    przesun w PRAWO o 2
  To dzielenie przez 4 (na bitach).

PO CO TO: sprawdzenie jednego pinu
to AND z maska — bez mnozenia,
bardzo szybko. Tak mowi sprzęt.

ROZNICA od ADD/MUL:
  SHL to przesuniecie BITOW
  MUL to mnozenie ARYTMETYCZNE
  Przy malych liczbach wynik ten sam,
  ale SHL dziala tez na bitach flagowych.

CO n              ustaw KOLOR rysowania
  n = 0..15 (paleta jak w C64):
     0 czarny      1 bialy
     2 czerwony    3 cyan
     4 fiolet      5 zielony
     6 niebieski   7 zolty
     8-15 jasne wersje tych samych
  CO 1     lub   COLOR 12

TD x,y,"TEXT"     rysuj TEKST
  x = kolumna, y = wiersz ekranu
  TD 2,2,"CYBER27"

TP x,y,color      postaw PIKSEL
  x,y   = pozycja (piksele)
  TP 0,0,15   TP 20,10,12

LINIE I FIGURY (wspolrzedne w pikselach):
  LINE x1,y1,x2,y2    linia
  BOX x1,y1,x2,y2     prostokat (ramka)
  FILLRECT x1,y1,x2,y2 prostokat pelny
  CIRCLE x,y,r        okrag
  FILLCIRCLE x,y,r    okrag pelny
  przyklad:
    BOX 10,10,80,60

EKRAN GRAFIKI: 164 x 128 pikseli.
(0,0) = lewy gorny rog.
Grafike widac w POWIEKSZONYM
pokoju (ENTER), nie w matrycy 3x3.

── RYSUJ PETLA FOR (latwe!) ──

A) KROPKA W RZEDKU:
   10 CLS
   20 FOR R0 = 0 TO 100
   30 TP R0, 50, 15
   40 NEXT R0

B) LINIA POZIOMA:
   10 LINE 0,20,100,20

C) KWADRAT Z KROPEK:
   10 CLS
   20 FOR R0 = 0 TO 50
   30 TP R0, 10, 12
   40 TP R0, 60, 12
   50 NEXT R0

D) SCHODKI (schodek w dol):
   10 CLS
   20 FOR R0 = 0 TO 40 STEP 4
   30 BOX R0, R0, R0+8, R0+8
   40 NEXT R0

E) KOLKA W RZEDKU:
   10 CLS
   20 FOR R0 = 0 TO 8
   30 CIRCLE R0*18+9, 40, 8
   40 NEXT R0

F) KOLOR ZMIENIA SIE (co 10 krokow):
   10 CLS
   20 FOR R0 = 0 TO 100
   30 CO 2
   40 TP R0, 30, 2
   50 CO 5
   60 TP R0, 40, 5
   70 CO 7
   80 TP R0, 50, 7
   90 NEXT R0

JAK ZAPISAC: wpisz linie z numerami,
potem RUN. Grafike widac po RUN.
ESC przerywa rysowanie.

MON              pokazuje MAPE 32x16
  To POMOCNICZY obszar pamieci
  (m_MonitorMap), a nie prawdziwy
  ekran. Sluzy do testow grafiki.
  Znaki na wydruku:
     '.' = pusty piksel
     '#' = zapisany piksel

SP slot,x,y,color   SPRITE (obiekt)
  slot  = 0..7 — ktory z 8 sprite'ow
  x,y   = pozycja w mapie
  color = kolor 0..15

  PRZYKLAD:
     SP 0,5,6,15   sprite 0 na (5,6)
     SP 1,10,8,7   sprite 1 na (10,8)

  Zapisywane w m_SpriteMap[].
  To PROSTY prototyp — gotowy do
  rozbudowy o ruch i kolizje.
  Na razie NIE rysuje sie na ekranie.

GPO pin,value   WYJSCIE (zapisz stan)

  'pin' to numer GPIO albo NAZWA:
     17, 22, 4...      numer pinu
     LED, ACT         dioda aktywna
     TX, RX, UART     linie szeregowe
     USB, SD, RTC     kontrola sprzetu
     CPU, FAN, MON    status systemu

  'value' to 0 (wylacz) albo 1 (wlacz).

  PRZYKLAD:
     GPO 17,1     ustaw pin 17 na 1
     GPO LED,0    zgas diode

  ZMIANA 2026-10-10: GPO/GPI dotykaja
  TERAZ REALNYCH pinow Raspberry Pi!
  Dozwolone piny (bezpieczne):
     17 18 22 23 24 25 27 4
  (nie koliduja z UART/I2C/SPI)

GPI pin         WEJSCIE (odczytaj)
  Czyta REALNY stan pinu i zapisuje
  go do rejestru R0:
     GPI 17
     PRINT "PIN 17 = ", R0

GPMODE pin,in|out   kierunek pinu
  GPMODE 17,in    wejscie (pomiar)
  GPMODE 17,out   wyjscie (LED)
  UWAGA: przed podaniem napiecia na
  pin ustaw go jako WEJSCIE (in) —
  inaczej moze dojsc do zwarcia!
  Monitor na zywo: pokoj GPIO.

ACTLED v        dioda aktywna (skrot)
  ACTLED 1   zapal
  ACTLED 0   zgas
  ACTLED     tylko odczytaj

FOR R0 = 1 TO 5    PETLA — poczatek
  R0 = licznik (rejestr R0..R7)
  1  = wartosc poczatkowa
  5  = wartosc koncowa (wlacznie)
  Mozna dodac krok:
     FOR R0 = 0 TO 10 STEP 2

NEXT R0            PETLA — koniec
  Zwieksza R0 o krok i wraca do FOR,
  dopoki R0 <= wartosc koncowa.
  Bez R0 uzyje ostatniego FOR.

IF warunek THEN komenda
  operatory: >  <  =  >=  <=
  IF R0 > 0 THEN PRINT "OK"
  IF R0 = 5 THEN GOTO 100

GOTO numer         skok do linii
  GOTO 100 — idz do linii 100

GOSUB numer        podprogram
  Skok do linii, RETURN wraca.

KOMPLETNY PRZYKLAD — policz do 5:
  10 FOR R0 = 1 TO 5
  20 PRINT R0
  30 NEXT R0
  40 PRINT "KONIEC"
  50 RUN

SAVE "nazwa.bas"    zapisz na karte SD
LOAD "nazwa.bas"    wczytaj z karty

  Nazwa MUSI byc w cudzyslowie.
  Plik trafia do katalogu glownego
  karty (montowany jako SD:).

  UWAGA: stara komenda SAVE dziala
  na tablicy interpretera, a nie
  na buforze edytora!

  W EDYTORZE uzyj skrotow:
     Ctrl+S   zapisz caly bufor
     Ctrl+L   wczytaj do bufora
  Plik: SD:/BASIC.BAS lub EDITOR.BAS

DEL numer         usun linie programu
  DEL 10 — usun linie o numerze 10

RS232 (port szeregowy):
  XSEND "plik"  wyslij (XMODEM)
  XRECV "plik"  odbierz (XMODEM)
  Na PC: sx plik / rx plik (lrzsz)

PRZYKLAD 1 — wyswietl tekst:
  10 CO 12
  20 TD 2,2,"CYBER27"
  30 TP 10,10,15
  40 PRINT "GOTOWE"

PRZYKLAD 2 — GPIO:
  10 GPO 17,1
  20 GPI 17
  30 PRINT "GPIO 17"

PRZYKLAD 3 — petla:
  10 FOR R0 = 1 TO 5
  20 PRINT R0
  30 NEXT R0
  40 PRINT "DONE"

PRZYKLAD 4 — arytmetyka bitowa:
  10 LET R0 = 0xFF
  20 SET R1, 0x0F
  30 AND R2, R0, R1
  40 PRINT R2

SKROTY KOMEND:
  TD  = Text Draw   (tekst)
  TP  = Plot Pixel  (piksel)
  CO  = Color       (kolor)
  MON = Monitor map (podglad)
  SP  = Sprite      (obiekt)
  GPO = GPIO Out    (wyjscie)
  GPI = GPIO In     (wejscie)

JAK PISAC:
  Litery wychodza DUZE — klawiatura
  daje wielkie znaki, nie ma malych.

  Tekst ZAWSZE w cudzyslowie:
     PRINT "OK"      dobrze
     PRINT OK        zle!

  Liczby: 123 albo 0x7B (szesnastkowo)

CZESTE BLEDY:
  — brak cudzyslowu wokol tekstu
  — przecinek zamiast spacji
  — literowka w nazwie komendy

STATUS   stan rejestrow i okna
LIST     wypisz program z numerami
SAVE     zapisz program
LOAD     wczytaj program

── STRZALKI W POMOCY ──
UP/DOWN    ruch po spisie tresci
ENTER      wejdz do tematu
PgUp/PgDn  skok o 8 pozycji
ESC        wyjdz poziom wyzej
F1         zamknij pomoc

── SKROTY W EDYTORZE ──
Ctrl+S     zapisz bufor na SD
Ctrl+L     wczytaj bufor z SD
BACKSPACE  usun znak przed kursorem
ENTER      nastepna linia
ALT+1-9    skok do pokoju
ALT+STRZ   wybor pokoju w matrycy

── LOG UART ──
Komunikaty bledow BASIC-a ida
na port szeregowy 115200.
Podglad: screen /dev/ttyUSB0 115200

To ostatni temat pomocy.

MAPA PAMIECI (27-bit):
  Rejestry R0..R7 — liczby float
  Pamiec: 256 slow (POKE/PEEK)
  Bufor grafiki 164x128 (TP/LINE...)
  Sprite'y: 8 slotow (SP/MOVSPR)
  Teksty A$..Z$; ekran tekstowy
  Wszystko dostepne z BASIC-a

DZWIEK — 4 GLOSY (0..3)

PRZEBIEG: WAVE glos,w
  0 PULSE  1 SAW  2 TRIANGLE
  3 SINE   4 NOISE (werbel)

ZAGRAJ: PLAY glos,freq,w
  np. PLAY 0,440,0
KRACH: NOTE freq,dur(ms)
  np. NOTE 880,120

BARWA:
  PULSE glos,w  0..4095 (2048=50%)
  ENV glos,a,d,s,r  obwiednia ms
  PAN glos,p    0=lewo .. 15=prawo
  ARP glos,n1,n2  akord na 1 glosie

SEKWENCER:
  TRACK n1,n2,n3,n4[,dur]
  SONG (petla)   SONGCLR
STOP — zatrzymaj dzwiek

PRZYKLAD (bas+lead+werbel):
  SONGCLR
  WAVE 0,0
  PULSE 0,3000
  ENV 0,0,150,10,80
  PAN 0,7
  WAVE 1,0
  ENV 1,5,120,12,60
  WAVE 2,4
  ENV 2,0,0,15,15
  TRACK 110,220,0,200
  TRACK 110,277,0,200
  TRACK 110,330,0,200
  TRACK 110,220,0,200
  SONG

JAK NAPISAC GRE — ETAPAMI
==========================

Nie pisz calego programu od razu!
Robimy MALY krok i sprawdzamy.
Kazdy etap to gotowy program.

JAK URUCHOMIC: wpisz
   LOAD "GRA1"
   RUN
Albo: nacisnij F5 tutaj (pomoc
sama wczyta i uruchomi GRA1).

ETAP 1 — BOISKO (GRA1)
  Rysujemy tylko plansze:
   - gorna i dolna banda (FILLRECT)
   - srodkowa linia przerywana
  Nic sie jeszcze nie rusza.

ETAP 2 — PILKA (GRA2)
  Pilka odbija sie w pionie.
  Sekret animacji, powtarzaj:
    1. CLS            wyczysc
    2. policz nowa pozycje
    3. narysuj pilke
    4. FLIP + WAIT    pokaz i czekaj
    5. GOTO 1

ETAP 3 — ODBICIA (GRA3)
  Pilka lata po calym ekranie.
  Dodajemy ruch w X (lewo-prawo).
  Kierunek X w R2, kierunek Y w R3.
  Przy scianie: zmien kierunek na
  przeciwny (SET R2, -1 itd.).

ETAP 4 — RAKIETA (GRA4)
  Twoj slupek na dole ekranu.
  GORA/DOL przesuwaja go.
  Pilka odbija sie od rakiety:
    gdy dotknie -> SET kierunek X

ETAP 5 — PELNA GRA (GRA5)
  Dwie rakiety: TY i CPU.
  CPU goni pilke sam.
  Punkt gdy pilka minie rakte.
  Wynik na gorze ekranu.
  To zlozenie etapow 1-4!

RADA: gdy cos nie dziala —
cofnij sie o jeden etap i porownaj.
Kazdy etap DZIALA samodzielnie.

F5 = uruchom GRA1
(potem zmien na GRA2...GRA5 w kodzie)

ETAP 1 — BOISKO  (GRA1)
==========================

Cel: tylko plansza gry.
Nic sie jeszcze nie rusza.

Co rysujemy:
  - gorna banda (FILLRECT)
  - dolna banda (FILLRECT)
  - srodkowa linia przerywana
    (petla FOR + STEP 8)

Kod (skrot):
  150 CLS
  170 CO 6
  180 FILLRECT 0,0,163,6
  200 FILLRECT 0,121,163,127
  230 FOR R0 = 0 TO 120 STEP 8
  240 FILLRECT 81,R0,82,R0+4
  250 NEXT R0

F5 = uruchom GRA1
Potem wroc tu i przejdz do
tematu 19 (etap 2).

ETAP 2 — PILKA W RUCHU  (GRA2)
==========================

Cel: pilka odbija sie w pionie.

SEKRET ANIMACJI (powtarzaj w kolko):
  1. CLS              wyczysc ekran
  2. policz pozycje   R1 = R1 + R2
  3. narysuj pilke    FILLRECT
  4. FLIP             pokaz na ekranie
  5. WAIT 20          poczekaj 20 ms
  6. GOTO 1           powtorz

R1 = pozycja Y pilki
R2 = kierunek (+1 w dol, -1 w gore)

ODBICIE (bardzo wazne):
  340 IF R1 <= 8   THEN SET R2, 1
  360 IF R1 >= 119 THEN SET R2, -1
Gdy pilka dotknie bandy,
zmieniamy kierunek na przeciwny.

FLIP jest potrzebny, inaczej obraz
odswiezy sie skokami.

F5 = uruchom GRA2

ETAP 3 — ODBICIA 4 SCIAN  (GRA3)
==========================

Cel: pilka lata po CALYM ekranie.
Dodajemy ruch w X (lewo-prawo).

Teraz MAMY DWA kierunki:
  R2 = kierunek X (1=w prawo, -1=w lewo)
  R3 = kierunek Y (1=w dol,   -1=w gore)

Ruch:
  270 ADD R0, R0, R2     X
  280 ADD R1, R1, R3     Y

Odbicia (4 sciany):
  340 IF R0 <= 4   THEN SET R2, 1
  350 IF R0 >= 159 THEN SET R2, -1
  370 IF R1 <= 4   THEN SET R3, 1
  380 IF R1 >= 123 THEN SET R3, -1

F5 = uruchom GRA3

ETAP 4-5 — RAKIETA I PELNA GRA
==========================

ETAP 4 (GRA4): Twoja rakieta.
  R4 = pozycja rakiety (lewa)
  GORA/DOL przesuwaja (GET R6).
  Odbicie od rakiety:
    gdy pilka dotknie slupka ->
    zmien kierunek X na przeciwny
  F5 = uruchom GRA4

ETAP 5 (GRA5): PELNA GRA.
  Dwie rakiety: TY i CPU.
  R4 = rakieta gracza (lewa)
  R5 = rakieta CPU (prawa)
  R6,R7 = wynik TY, CPU
  CPU goni pilke sam:
    IF R5 < R1 THEN ADD R5,R5,3
    IF R5 > R1 THEN SUB R5,R5,3
  Punkt gdy pilka minie rakte.
  To zlozenie etapow 1-4!

Aby uruchomic GRA5 (F5 startuje
GRA4), wpisz recznie:
  LOAD "GRA5"  i RUN

F5 = uruchom GRA4

GRA: WAZ  (WAZ1 = glowa, WAZ2 = pelny)
==========================

Klasyk: waz je i rosnie.
  GORA/DOL/LEWO/PRAWO = ruch
  ESC = koniec

WAZ1 — tylko GLOWA (jeden kwadrat).
  Uczy CIEKLEJ ANIMACJI w jednym
  kierunku. Sciany zawijaja:
   IF R0 < 0 THEN SET R0, 160

WAZ2 — PELNY waz:
  * CIALO z wielu segmentow
    (tablice SX(), SY())
  * JEDZENIE (czerwony kwadrat)
  * zjedzone -> waz rosnie
  * wpadnie na siebie -> koniec

Sekret ruchu ciala: przesuwamy
segmenty od konca w strone glowy
(rura):
  640 FOR R7 = D(0)-1 TO 1 STEP -1
  650 SX(R7) = SX(R7-1)
  660 SY(R7) = SY(R7-1)
  670 NEXT R7

F5 = uruchom WAZ2

GRA: ARKANOID  (ARKANOID)
==========================

Zbij wszystkie KLOCKI na gorze!
  LEWO/PRAWO = paletka
  ESC = koniec

Elementy gry:
  R0,R1 = pilka (X,Y)
  R2,R3 = kierunek pilki
  R4    = paletka (gracz, dol)
  KX(),KY(),KH() = klocki

Klocki to TABLICE — kazdy ma:
  pozycje X, Y i stan (jest/zbity)
  Gdy pilka trafi -> KH(R7) = 0
  i pilka odbija sie w dol.

Odbicie od paletki — klasyka:
  IF pilka na wysokosci paletki
  AND pilka nad paletka
  THEN SET R3, -2

F5 = uruchom ARKANOID

GRA: 2 ARMATE  (ARMATA)
==========================

DWOCH graczy na zmiane!
  Cel: trafic w armate przeciwnika.

Sterowanie:
  G / D = KAT armaty (gora/dol)
  H / J = MOC strzalu
  ENTER = STRZEL!   ESC = koniec

Fizyka (uczy katow i wektorow!):
  kat w stopniach -> radiany:
    R8 = kat * PI / 180
  predkosc pozioma:  vx = moc*COS(kat)
  predkosc pionowa:  vy = moc*SIN(kat)
  grawitacja: kazda klatka
    vy = vy + 1  (pocisk opada)

Pocisk leci LUKIEM — im wieksza
moc, tym dalej poleci.
Trafienie = punkt. Potem druga
osoba strzela. Wynik na dole.

F5 = uruchom ARMATA

SYNTH — JAK GRAC
==========================

NAJWAZNIEJSZE: dzwiek wlacza sie
DOPIERO po pierwszej komendzie NOTE
lub PLAY. Bez tego jest CISZA!

KROK 1: wlacz dzwiek w BASIC:
   NOTE 440,300
   (440 Hz = dzwiek A, 300 ms)
Teraz na gorze pokoju SYNTH
zobaczysz: DZWIEK: ON

KROK 2: wejdz do pokoju SYNTH
(menu pokoi -> SYNTH -> ENTER)

KLAWISZE W POKOJU SYNTH:
  1 2 3 4        wybor GLOSU
  W              nastepny PRZEBIEG
   Z X C V B N M  nuty C D E F G A B
  ESC            wyjdz do menu pokoi

4 GLOSY — kazdy gra osobny dzwiek
naraz (jak 4 muzyki). Wybierz glos
cyfra, zmien mu przebieg klawiszem W.

Zobacz tez temat 26 (MUSIC/waveform)
i temat 16 (komendy dzwieku).

MUSIC — WAVEFORM (przebiegi)
==========================

PRZEBIEG (waveform) = jaki KSZTALT
ma fala dzwieku. Inny ksztalt =
inna barwa (brzmienie).

5 przebiegow w CYBER27:
  0 PULSE     prostokat (jak SID)
  1 SAW       pila (ostry, brzeczy)
  2 TRIANGLE  trojkat (miekki)
  3 SINE      sinus (czysty)
  4 NOISE     szum (werbel, huk)

Jak zmienic: klawisz W w pokoju SYNTH
albo w BASIC:
  WAVE 0,3      glos 0 -> sinus

PULSE (prostokat) ma dodatkowo
PULSE WIDTH — szerokosc impulsu:
  PULSE 0,2048  (2048 = rowno 50%)

PO CO: kazdy instrument ma inny
przebieg — flet to sinus, trabka
to pila, perkusja to szum.

KURS PROGRAMOWANIA — PLAN
==========================

Cel: cala szkola programowania,
a nie tylko abc — 100 cwiczen,
aby po kursie poslugiwac sie
BASIC-iem biegle.

KURS1 (start) — wprowadzenie:
  1 Jak mysli komputer (0/1)
  2 Pierwszy PRINT
  3 Liczby i rejestry
  4 Dodawanie w BASIC-u

CALE MODULY KURSU:
  A Podstawy (PRINT, zmienne)
  B Arytmetyka i wyrazenia
  C Warunki IF...THEN
  D Petle FOR...NEXT
  E Tablice (DIM)
  F Teksty A$
  G Podprogramy GOSUB/RETURN
  H Grafika (TP, LINE, ...)
  I Dzwiek (NOTE, WAVE)
  J Pliki na SD (SAVE, LOAD)
  K Procedury i praktyka

F5 = uruchom KURS1 (start)

MARGARET HAMILTON (1936-)
==============================

PL: Kobieta, ktora NAPISALA
    oprogramowanie Apollo 11!
DE: Sie schrieb die Software
    fuer Apollo 11.

PL: Kierowala zespolami w MIT
    (Instrumentation Laboratory).
    To ona wymyslila slowo
    'software engineering'.
DE: Sie praegte den Begriff
    'Software Engineering'.

SLAWNE ZDJECIE 1969:
  stoi obok STOSU wydrukow kodu
  AGC — wyzszego od niej samej!
DE: Der Stapel Code war hoeher
    als sie selbst.

JEJ KOD URATOWAL MISJE:
  W trakcie lotu Apollo 11
  radar zle dzialal. Jej program
  SAM sie zrestartowal i odrzucil
  mniej wazne zadania.
  Ludzie wyladowali bezpiecznie.
DE: Ihr Code rettete die Mission.

KOMPUTER AGC (Apollo Guidance):
  - pamiec: 4 KB (!)
  - 2 MHz, 16 bitow
  - liczyl trajektorie na Ksiezyc

F5 = uruchom PRZYKLAD6
     (nawigacja Apollo w CYBER27!)

ALFABET MORSE'A
==============================

PL: MORSE = kropka (.) i kreska (-).
    Kazda litera to inny uklad.
DE: Morse: Punkt und Strich.

PL: kropka = KROTKI sygnal
    kreska = DLUGI (3x kropka)
    odstep miedzy literami = 3 kropki
    odstep miedzy slowami = 7 kropek

A  .-      N  -.
B  -...    O  ---
C  -.-.    P  .--.
D  -..     Q  --.-
E  .       R  .-.
F  ..-.    S  ...
G  --.     T  -
H  ....    U  ..-
I  ..      V  ...-
J  .---    W  .--
K  -.-     X  -..-
L  .-..    Y  -.--
M  --      Z  --..

CYFRY:
1 .----   5 .....
2 ..---   6 -....
3 ...--   7 --...
4 ....-   8 ---..
9 ----.   0 -----

SOS = ... --- ...  (ratunek!)

PL: MORSE + TWOJ SPRZET:
  - nadaj dzwiekiem (NOTE)
  - zobacz na OSCYLOSKOPIE
    (kropka = krotki impuls)
DE: mit Oszilloskop sichtbar!

F5 = uruchom MORSE_LEKCJA

UKLAD SLONECZNY: PLANETY
==============================

8 planet, kazda ma swoja karte:
  odleglosc od Slonca, doba (obrot),
  rok (obieg), warunki na powierzchni
  i liczbe ksiezycow.

KOLEJNOSC od Slonca:
  1 MERKURY  57.9 mln km, rok 88 dni
  2 WENUS   108.2 mln km, +465 C
  3 ZIEMIA  149.6 mln km (nasz dom!)
  4 MARS    227.9 mln km, 2 ksiezyce
  5 JOWISZ  778.5 mln km, GAZ, 95 ks.
  6 SATURN  1434 mln km, pierscienie
  7 URAN    2871 mln km, lezy bokiem
  8 NEPTUN  4495 mln km, najdalej

SRODKI: 1 AU = 149.6 mln km
(odleglosc Ziemia-Slonce).

RODZAJE POWIERZCHNI:
  LAD   - skalista (Merkury, Wenus,
          Ziemia, Mars).
          Mozna wyladowac!
  GAZ   - Jowisz, Saturn (bez ladu).
  GAZ+LOD - Uran, Neptun (lodowe).

CIEKAWOSTKI:
  - Na Wenus DOBA > ROK (243 vs 225)
    i kreci sie WSTECZ.
  - Jowisz obraca sie w 10 godzin,
    a rok trwa 12 lat.
  - Saturn ma 146 ksiezycow!
  - Uran obraca sie 'na lezaco'.

F5 = uruchom APO_PLANETY (quiz)

APOLLO 11: SYMULATOR MISJI
==============================

PL: to NIE quiz - to GRA.
    Jestes pilotem statku. Cel:
    doleciec na Ksiezyc (384 tys.
    km) i bezpiecznie wrocic.
DE: Simulator, kein Quiz!

JAK GRAC:
  L / P  = zmien OKNO (widok)
  G / D  = wybierz AKCJE
  ENTER  = wykonaj akcje
  S      = zapisz stan misji
  L      = wczytaj stan misji
  ESC    = powrot do menu

WSKAZNIKI NA PULPICIE:
  WYSOKOSC, PREDKOSC, odleglosc
  do celu, PALIWO, TLEN, PRAD.

ZDARZENIA LOSOWE (AWARIE!):
  - wyciek paliwa
  - utrata tlenu
  - utrata pradu
  - brak lacznosci z Ziemia
  Jak sie pojawi ALARM - dzialaj
  (wybierz NAPRAW AWARIE)!
  Zresetuj po awarii albo misja
  sie skonczy zle.

Zapis jest TRWALY (karta SD),
wiec mozna przerwac i wrocic.

F5 = uruchom APO_MISJA (gra)

APOLLO: FIZYKA LOTU
==============================

PL: prawa fizyki, ktore rzadza
    lotem na Ksiezyc.
DE: Physik des Fluges.

1) PREDKOSC:  v = s : t
   predkosc = droga : czas
   Np. 300 km w 2 h -> 150 km/h

2) PALIWO:  paliwo = zuzycie * czas
   Silnik pali X na godzine, lot
   trwa Y godzin -> X * Y paliwa.

3) PRZYSPIESZENIE: a = dv : t
   jak szybko rosnie predkosc.

4) CIEZAR: grawitacja roznych cial
   (Ziemia=1, Ksiezyc=6 -> 6x lzej).

5) GRAWITACJA: predkosc ucieczki
   minimalna predkosc, by opuscic
   cialo (pokonac grawitacje):
     Ksiezyc 2 km/s
     Mars    5 km/s
     Ziemia 11 km/s
     Jowisz 60 km/s
   Jowisz jest wielki i ciezki,
   wiec ucieczka jest trudna!

MIX = losowe zadanie (1-5).
Punkty licza sie wspolnie (PUNKTY).

ZADANIA W MISJI: podczas lotu
pojawiaja sie te same zadania
(oblicz predkosc, czas, paliwo),
by leciec dalej. Nauka w grze!

F5 = uruchom APO_FIZYKA

WLASNE POKOJE (komendy)
==============================

PL: mozesz dodac WLASNY pokoj
    i zdecydowac, jaki program
    sie w nim uruchomi.
DE: Eigene Raeume anlegen.

JAK ZROBIC WLASNY POKOJ:
  1. Napisz program (w pokoju
     BASIC) i zapisz go:
       SAVE "MOJPROG"
     (utworzy MOJPROG.BAS)
  2. Dodaj pokoj z tym programem:
       POKOJ "MOJA GRA","MOJPROG"
  3. Zapisz liste pokoi na karte:
       ZAPISZPOKOJE

Nowy pokoj pojawi sie w MENU
POKOI i uruchomi twoj program.
Przetrwa RESTART (plik POKOJE.TXT
na karcie SD).

POZOSTALE KOMENDY:
  POKOJE          lista pokoi
  WCZYTAJPOKOJE   wczytaj z karty
  POKOJ "N"       pokoj bez programu

NAWIGACJA: L/P przewija pokoje,
ENTER wchodzi, ESC wraca.

F5 = uruchom przyklad

NAZWANE ZMIENNE
================================

Wyobraz sobie PUDEŁKA z napisem.
Do kazdego wkladasz liczbe.
Nazwa mowi, CO sie w nim trzyma.

Zamiast pamietac 'R3 to punkty',
piszesz po prostu: POINTS.

JAK UZYC:
  POINTS = 10      wloz 10 do POINTS
  PRINT POINTS     pokaz (10)
  POINTS = POINTS + 5   zwieksz (15)

MOZESZ LICZYC:
  ZYCIE = 3
  ZYCIE = ZYCIE - 1     (2)
  WYNIK = ZYCIE * 10    (20)

NAZWA moze miec litery, cyfry
i '_' (podkreslnik). Do 15 znakow.
Wielkie/male litery bez roznicy:
  punkty i PUNKTY to to samo.

REJESTRY R0..R7 DALEJ DZIALAJA!
Mozesz uzywac obu naraz:
  R0 = 100
  SUMA = R0 + POINTS

PRZYKLAD - mini gra:
  10 ZYCIE = 3
  20 ZYCIE = ZYCIE - 1
  30 PRINT "Zycie: ", ZYCIE
  40 IF ZYCIE = 0 THEN GOTO 60
  50 GOTO 20
  60 PRINT "Koniec gry"

F5 = uruchom TESTVAR (demo)

TYPY I REKORDY (TYPE)
================================

Zamiast 5 osobnych zmiennych na
JEDNA rzecz - zrob JEDNO pudelko
z kilkoma przegrodkami.

To jest REKORD. Nazwy przegrodek
to POLA.

KROK 1 - opisujemy, co ma pocisk:
  TYPE Pocisk
  X
  Y
  VX
  END TYPE

KROK 2 - robimy tablice pociskow:
  DIM p(4) AS Pocisk
  (5 pociskow: p(0)..p(4))

KROK 3 - uzywamy (kropka '.'):
  p(0).X = 100
  p(0).VX = -3
  p(0).X = p(0).X + p(0).VX

WYOBRAZ SOBIE:
  p(0) to POCISK numer 0.
  p(0).X to jego X (pozycja).
  p(1).X to X pocisku numer 1.

Po co? W grze masz 100 pociskow,
kazdy z wlasnym X, Y, VX. Jeden
TYP opisuje je WSZYSTKIE.

PRZYKLAD - pociski leca:
  TYPE Pocisk
  X
  VX
  END TYPE
  DIM p(3) AS Pocisk
  FOR R0 = 0 TO 3
  p(R0).X = 50
  p(R0).VX = -2
  NEXT R0
  REM teraz kazdy pocisk ma X i VX

WAZNE:
  - 'TYPE ... END TYPE' musi byc
    PRZED 'DIM ... AS ...'
  - zaczynaj pola DUZYMI literami
    (to tylko zwyczaj, dziala tez male)

F5 = uruchom TESTREC (demo)

PROCEDURY: SUB i FUNCTION
================================

Co jesli ten sam kawalek kodu
powtarzasz wiele razy? Zamiast
kopiowac — zrob PROCEDURE.

SUB to zestaw komend z nazwa.
Wolasz go slowem CALL.

JAK ZROBIC SUB:
  SUB Rysuj(x, y)
  PRINT "Rysuje w ", x, y
  END SUB

JAK WOLAC:
  CALL Rysuj(10, 20)
  CALL Rysuj(30, 40)

x i y to PARAMETRY. W srodku SUB
sa to zmienne lokalne (maja swoje
wartosci tylko tam).

FUNCTION — jak SUB, ale ZWRACA
wynik. Wynik odczytasz w WYNIK:

  FUNCTION Podwoj(n)
  RETURN n * 2
  END FUNCTION

  CALL Podwoj(21)
  PRINT WYNIK         (42)

WAZNE:
  - definicja MUSI miec nawias:
    SUB Foo(a) — nie 'SUB Foo'
  - CALL poza definicja, w programie
  - WYNIK jest TYLKO do czytania
  - max 8 procedur, 4 parametry
  - 'SUB R0,R0,2' (bez nawiasu) to
    ODEJMOWANIE, nie procedura!

PRZYKLAD — kwadrat z procedury:
  SUB Kwadrat(x, y, w)
  LINE x,y,x+w,y
  LINE x+w,y,x+w,y+w
  LINE x+w,y+w,x,y+w
  LINE x,y+w,x,y
  END SUB
  CALL Kwadrat(10, 10, 40)

F5 = uruchom TESTSUB (demo)

ETYKIETY (GOTO Start)
================================

Dotad skakalo sie do NUMERU linii:
  GOTO 500
To trudne, bo musisz pamietac numery.

Teraz mozesz nadac miejscu NAZWE.
Piszesz nazwe i dwukropek:

  PETLA:
  PRINT "raz"
  GOTO PETLA

Nazwa etykiety to jak zakladka
w ksiazce — GOTO do niej wraca.

JAK TO DZIALA:
  Start:      <- etykieta (z ':')
  ... kod ...
  GOTO Start  <- skok do etykiety

MOZNA GOSUB (z powrotem):
  GOSUB Powitanie
  ... dalej ...
  Powitanie:
  PRINT "czesc"
  RETURN

ZASADY:
  - etykieta stoi na POCZATKU linii
    (po numerze), konczy sie ':'
  - nazwa: litery, cyfry, '_'
  - wielkie/male litery bez roznicy
  - STARE GOTO 500 DZIALA DALEJ!

PRZYKLAD — licznik do 5:
  10 N = 0
  20 PETLA:
  30 N = N + 1
  40 PRINT N
  50 IF N < 5 THEN GOTO PETLA
  60 PRINT "koniec"

F5 = uruchom TESTLBL (demo)

PCM SAMPLE (dzwiek jak Amiga)
================================

Syntezator robi dzwieki z nut.
SAMPLE to NAGRANIE — prawdziwy
dzwiek: perkusja, gitara, glos,
strzal. Jak w Amidze!

Plik sample to surowe dane
.RAW (8-bit, jak Amiga).

KROK 1 - wczytaj (SLOAD):
  SLOAD 0, "TEST.RAW"
  (slot 0..3, plik z karty SD)

KROK 2 - zagraj (SPLAY):
  SPLAY 0, 0, 1.0
  kanal(0..3), slot, pitch

PITCH = wysokosc (jak Paula):
  1.0 = normalnie
  2.0 = oktAwe WYZEJ
  0.5 = oktAwe NIZEJ

STOP:
  SSTOP 0      zatrzymaj kanal 0

MOZNA MIESZAC z synteza!
  - 4 kanaly RAZEM
  - np. kanal 0 = perkusja (sample)
    kanal 1-2 = melodia (nut)

PRZYKLAD - perkusja + nuta:
  SLOAD 0, "BUM.RAW"
  SPLAY 0, 0, 1.0
  PLAY 1, 440, 0

WSKAZOWKA: sample 8000 Hz gra
w swoim tempie przy pitch 1.0.

F5 = uruchom TESTSMP (demo)

PAINT 3D - EDYTOR GRAFIKI

Rysujesz obrazki, ktore potem
wczytuje silnik 3D i gry.

TAB = nastepny tryb:
  0 tekstura 64x64 (sciany)
  1 postac   32x32 x 8 klatek
  2 bron     64x32 x 2 klatki
  3 BIB      32x32 (biblioteka)

N = nastepna klatka
G = siatka 8x8 (pomoc do rysowania)

KLAWISZE (tylko klawiatura!):
  STRZALKI = ruch kursora
  SPACJA   = postaw / zakoncz
  A / D    = kolor - / +
  1..5     = narzedzie

NARZEDZIA (1..5):
  1 piksel   2 linia
  3 prostokat 4 wypelnienie
  5 guma

LINIA / PROSTOKAT:
  1. SPACJA = zapamietaj start
  strzalki  = przesun koniec
  2. SPACJA = narysuj

POZOSTALE:
  TAB = tryb  N = klatka
  G = siatka  U = undo
  S = zapis  L = wczytaj
  ESC = koniec

JAK UZYC W GRZE 3D:
  tekstura: WTLD 1,"PAINT.RAW"
  postac:   WSDEF 1,"PAINT.RAW"
  bron:     WGUN "PAINT.RAW"

Plik zawsze nazywa sie PAINT.RAW
(skopiuj na PC i zmien nazwe).

F5 = uruchom PAINT3D

NOWE W CYBER27 (2026-10-23)

64 KOLORY (bylo 32)
  CO 0..63   np. CO 32 = czarny

  Nowe grupy:
   32-34 czernie    35-37 szarosci
   38-39 ciemne     40-42 trawa
   43-45 niebo      46-48 skora
   49-51 drewno     52-54 kamien
   55-56 zloto      57-59 woda
   60-61 ogien      62-63 magia

BUFOR 320x240 (bylo 164x128)
  - 4x wiecej pikseli
  - na 640x480 skala x2 = PELNY ekran
  - na 1920x1080 skala x4

WCOMPAT 2   stare gry (0..163)
WCOMPAT 1   nowe gry (0..319)
  Domyslnie 2 — gry dzialaja.
  W nowej grze wpisz WCOMPAT 1.

SCRINFO  info o ekranie:
  R0,R1 = szer,wys ekranu
  R2    = skala bufora
  R3,R4 = offset X,Y
  R5,R6 = rozmiar bufora

FOR po NAZWIE (bylo tylko R0..R7)
  FOR I = 1 TO 10   dziala!
  NEXT I

WISOPLAYERFRAME n  klatka gracza
  -1 = powrot do auto-animacji

WISOATTACK zasieg  atak w ISO
  R0 = slot trafionego (0=brak)
  R1 = odleglosc

WARSTWY.TXT — baza warstw mapy
  NAZWA RENDER WYS KOLIZJA TEKSTURA [SPRITE=n]
  render: podloga/bryla/prog/drzewo/sprite/brak
  Dodanie warstwy = dopisanie linii.

BLIT sx,sy,w,h,dx,dy
  Kopiuj prostokat w buforze.
  Scrolling: BLIT 2,0,318,239,0,0
  -> przesuwa obraz o 2 px w lewo.

BLITT sx,sy,w,h,dx,dy
  Jak BLIT, ale piksele 0 sa
  PRZEZROCZYSTE (tlo przebija).
  To sprite przesuwany po tle!

WSETDIR "katalog"
  Katalog zasobow dla WTLD/WSDEF:
    WSETDIR "GRA/GRAFIKA/"
    WTLD 1, "T01.RAW"
  WSETDIR "" = katalog glowny.

WISOLAYER x,y
  Info o warstwie kafla:
  R0=nr R1=render R2=wys R3=mapa