CYBER27 — eigenes Betriebssystem

CYBER27 BASIC (27-BIT)

Ein PROGRAMM ist eine Liste von Zeilen.
Jede Zeile hat eine NUMMER und einen INHALT:

     10 PRINT "OK"
     ^^ ^^^^^^^^^^
     |  +-- Inhalt (was tun)
     +----- Nummer (Reihenfolge)

Die NUMMERN bestimmen die AUSFÜHRUNGS-
REIHENFOLGE, nicht die Eingabereihenfolge.
Du kannst also Zeile 15 zwischen 10 und 20
einfügen — sie läuft trotzdem richtig.

REGISTER: R0, R1 ... R7
  8 Zellen für Zahlen. Am schnellsten.

SPEICHER: 256 Wörter (Adressen 0x00..0xFF)
  Größer als Register, langsamer.
  Zugriff über POKE und PEEK.

ZAHLEN: Gleitkomma (wie C64, aber
genauer). Punkt und Minus funktionieren:
  PRINT 1/2    ->  0.5
  PRINT 10/3   ->  3.33333333
  PRINT -5     ->  -5

SPEICHER (POKE/PEEK) und Bitoperatoren
bleiben 27-Bit (0x07FFFFFF).

NUMMERIERUNG AUTOMATISCH: im Editor bekommt
eine neue Zeile selbst eine Nummer
(10, 20, 30...). Du kannst auch selbst
eine Nummer eingeben.

PRINT "TEXT"    gibt Text aus
  Anführungszeichen PFLICHT für Text!
  PRINT "HALLO"

PRINT R3        gibt den INHALT des
  Registers aus — OHNE Anführungszeichen

PRINT "A", R0   mehrere Elemente
  ',' = Leerzeichen, ';' = ohne Abstand
  abschließendes ';' = ohne Zeilenumbruch

?               Kurzform von PRINT

Ein Leerzeichen (ohne Komma) trennt
Text und Zahl — wie in C64.

REGISTER R0..R7 — 8 Zellen für Zahlen.
Das sind die SCHNELLSTEN Variablen.

  R0 = 5            Wert zuweisen
  R1 = R0 * 2       rechnen
  PRINT R1          ausgeben (10)

REGISTER sind da, wo Geschwindigkeit zählt.

SPEICHER (POKE/PEEK):
  POKE 0x10, R3     schreibe in den Speicher
    0x10 = Adresse (Slot 16)
    R3   = Wert zum Schreiben
    Der Speicher hat 256 Wörter (0x00..0xFF).

  PEEK 0x10         lese aus dem Speicher
    Ergebnis auf dem BILDSCHIRM. Im Programm
    nutze PEEK(x) als Funktion im Ausdruck.

DIM A(20)         TABELLE A (Indizes 0..20)
  A(i) = 7        Element schreiben
  PRINT A(i)      Element lesen
  Buchstaben A..Z, Index max. 63.

INPUT R0          Zahl vom Benutzer
  von der Tastatur einlesen

ADD R0, R1, R2    R0 = R1 + R2
SUB R0, R1, R2    R0 = R1 - R2
MUL R0, R1, R2    R0 = R1 * R2
DIV R0, R1, R2    R0 = R1 / R2

WICHTIG: Das ERGEBNIS muss in einem
REGISTER landen (nicht in einer Tabelle)!

In Ausdrücken funktionieren auch
normale Operatoren:

  R0 = 3 * 4 + 1       -> 13
  R1 = (2 + 3) * 4     -> 20
  R2 = 10 / 4          -> 2.5

Priorität: ( ) dann * / dann + -

Ganze Zahl abschneiden: es gibt kein
TRUNC/INT — nutze & (Bitmaske) oder
einen anderen Weg.

SIN(x)   Sinus (x im Bogenmaß)
COS(x)   Kosinus
TAN(x)   Tangens
ATN(x)   Arkustangens
SQR(x)   Quadratwurzel
ABS(x)   Betrag
SGN(x)   Vorzeichen (-1, 0, 1)

GRAD -> BOGENMASS:
  rad = grad * PI / 180

KREIS ze Winkeln:
  x = cx + r * COS(w)
  y = cy + r * SIN(w)

PI ist eine eingebaute Konstante:
  PRINT PI     -> 3.14159265...

POTENZEN:
  SQR(x) ist die Wurzel. Für Potenzen
  multipliziere: x*x*x statt x^3.

BIT-OPERATIONEN — auf jedem Bit einzeln.
Das ist NICHT normale Mathematik.

AND R2,R0,R1   bitweises UND
  Ergebnis 1 nur wenn BEIDE Bits 1 sind.
    1100 AND 1010 = 1000

OR  R2,R0,R1   bitweises ODER
  Ergebnis 1 wenn IRGENDEIN Bit 1 ist.
    1100 OR  1010 = 1110

XOR R2,R0,R1   bitweises XOR
  Ergebnis 1 wenn Bits sich UNTERSCHEIDEN.
    1100 XOR 1010 = 0110

NOT R2,R0      Negation
  Macht aus jeder 0 eine 1 und umgekehrt.

SHL R2,R0,3    nach LINKS verschieben
  Das ist Multiplikation mit 2^3 = 8.
    0001 SHL 1 = 0010

SHR R2,R0,2    nach RECHTS verschieben
  Das ist Division durch 4 (auf Bits).

WOFÜR: einen Pin prüfen heißt
AND mit Maske — ohne Multiplikation,
sehr schnell. So arbeitet die Hardware.

UNTERSCHIED zu ADD/MUL:
  SHL ist ein Schieben — kein Rechnen.

CO n              ZeichenFARBE setzen
  n = 0..255 (Palette, C64 + 191 neue):
     0 schwarz     1 weiß
     2 rot         3 cyan
     4 violett     5 grün
     6 blau        7 gelb
     8-15 helle Varianten
  CO 1     oder   COLOR 12

TD x,y,"TEXT"     TEXT zeichnen
  x = Spalte, y = Zeile
  TD 2,2,"CYBER27"

TP x,y,color      PIKCEL setzen
  x,y   = Position (Pixel)
  TP 0,0,15   TP 20,10,12

LINIEN UND FIGUREN (Pixelkoordinaten):
  LINE x1,y1,x2,y2    Linie
  BOX x1,y1,x2,y2     Rechteck (Rahmen)
  FILLRECT x1,y1,x2,y2 gefülltes Rechteck
  CIRCLE x,y,r        Kreis
  FILLCIRCLE x,y,r    gefüllter Kreis
  Beispiel:
    BOX 10,10,80,60

BLIT sx,sy,w,h,dx,dy   Rechteck kopieren
BLITT sx,sy,w,h,dx,dy  wie BLIT, aber 0 = transparent

GRAFIK-PUFFER: 320 x 240 Pixel.
Auf dem Bildschirm 2x vergrößert.

MON              zeigt die Karte 32x16
  Das ist ein HILFS-Speicherbereich
  (m_MonitorMap), kein echter Bildschirm.
  Dient zum Testen der Grafik.
  Zeichen in der Ausgabe:
     '.' = leeres Pixel
     '#' = gesetztes Pixel

SP slot,x,y,color   SPRITE (Objekt)
  slot  = 0..7 — welcher der 8 Sprites
  x,y   = Position in der Karte
  color = Farbe 0..255

  BEISPIEL:
     SP 0,5,6,15   Sprite 0 auf (5,6)
     SP 1,10,8,7   Sprite 1 auf (10,8)

  Wird in m_SpriteMap[] gespeichert.
  Einfacher Prototyp — bereit für
  Bewegung und Kollisionen.
  Wird NICHT auf dem Bildschirm gezeichnet.

GPO pin,value   AUSGANG (Zustand schreiben)

  'pin' ist eine GPIO-Nummer ODER ein NAME:
     17, 22, 4...     Pin-Nummer
     LED, ACT         aktive LED
     TX, RX, UART     serielle Leitungen
     USB, SD, RTC     Hardware-Kontrolle
     CPU, FAN, MON    Systemstatus

  'value' ist 0 (aus) oder 1 (ein).

  BEISPIEL:
     GPO 17,1     Pin 17 auf 1 setzen
     GPO LED,0    LED ausschalten

  ERLAUBTE Pins (sicher):
     17 18 22 23 24 25 27 4
  (kollidieren nicht mit UART/I2C/SPI)

GPI pin         EINGANG (lesen)
  Liest den ECHTEN Pin-Zustand in R0:
     GPI 17
     PRINT "PIN 17 = ", R0

GPMODE pin,in|out   Richtung setzen

FOR R0 = 1 TO 5    SCHLEIFE — Anfang
  R0 = Zähler (Register R0..R7 ODER Name)
  1  = Startwert
  5  = Endwert (einschließlich)
  Mit Schritt:
     FOR R0 = 0 TO 10 STEP 2
  Auch mit Namen:  FOR I = 1 TO 10

NEXT R0            SCHLEIFE — Ende
  Erhöht R0 um den Schritt und springt
  zurück zu FOR, solange R0 <= Endwert.
  Ohne R0 wird das letzte FOR verwendet.

IF Bedingung THEN Befehl
  Operatoren: >  <  =  >=  <=
  IF R0 > 0 THEN PRINT "OK"
  IF R0 = 5 THEN GOTO 100

GOTO nummer        Sprung zur Zeile
GOSUB nummer       Unterprogramm (RETURN)

VOLLSTÄNDIGES BEISPIEL — zähle bis 5:
  10 FOR R0 = 1 TO 5
  20 PRINT R0
  30 NEXT R0
  40 PRINT "ENDE"

SAVE "name.bas"    auf SD-Karte speichern
LOAD "name.bas"    von der Karte laden

  Der Name MUSS in Anführungszeichen stehen.
  Die Datei landet im Hauptverzeichnis
  der Karte (montiert als SD:).

  HINWEIS: Der alte Befehl SAVE wirkt auf
  die Interpreter-Tabelle, NICHT auf den
  Editor-Puffer!

  IM EDITOR nutze die Tastenkürzel:
     Ctrl+S   ganzen Puffer speichern
     Ctrl+L   in den Puffer laden
  Datei: SD:/BASIC.BAS oder EDITOR.BAS

DEL nummer        Programmzeile löschen
  DEL 10 — löscht die Zeile 10

RS232 (serielle Schnittstelle):
  XSEND "datei"  senden (XMODEM)
  XRECV "datei"  empfangen (XMODEM)
  Auf dem PC: sx datei / rx datei (lrzsz)

BEISPIEL 1 — Text anzeigen:
  10 CO 12
  20 TD 2,2,"CYBER27"
  30 TP 10,10,15
  40 PRINT "FERTIG"

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

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

BEISPIEL 4 — Bit-Arithmetik:
  10 LET R0 = 0xFF
  20 SET R1, 0x0F
  30 AND R2, R0, R1
  40 PRINT R2

BEFEHL-KÜRZEL:
  TD  = Text Draw   (Text)
  TP  = Plot Pixel  (Pixel)
  CO  = Color       (Farbe)
  MON = Monitor map (Vorschau)
  SP  = Sprite      (Objekt)
  GPO = GPIO Out    (Ausgang)
  GPI = GPIO In     (Eingang)

WIE SCHREIBEN:
  Buchstaben werden GROSS — die Tastatur
  liefert große Zeichen, keine kleinen.

  Text IMMER in Anführungszeichen:
     PRINT "OK"      richtig
     PRINT OK        falsch!

  Zahlen: 123 oder 0x7B (hexadezimal)

HÄUFIGE FEHLER:
  — fehlende Anführungszeichen um Text
  — Komma statt Leerzeichen
  — Tippfehler im Befehlsnamen
  — FOR mit Variable statt Register
    (jetzt erlaubt: FOR I = ... und FOR R0 = ...)

STATUS   Zustand der Register und Fenster
LIST     Programm mit Nummern ausgeben
SAVE     Programm speichern
LOAD     Programm laden

── PFEILTASTEN IN DER HILFE ──
UP/DOWN    durch das Inhaltsverzeichnis
ENTER      Thema öffnen
PgUp/PgDn  8 Positionen springen
ESC        eine Ebene zurück
F1         Hilfe schließen

── EDITOR-KÜRZEL ──
Ctrl+S     Puffer auf SD speichern
Ctrl+L     Puffer von SD laden
BACKSPACE  Zeichen vor dem Cursor löschen
ENTER      nächste Zeile
ALT+1-9    zu Raum springen
ALT+PFEIL  Raum in der Matrix wählen

── UART-LOG ──
BASIC-Fehlermeldungen gehen an den
seriellen Port 115200.
Anzeige: screen /dev/ttyUSB0 115200

SPEICHERKARTE (27-Bit):
  Register R0..R7 — Float-Zahlen
  Speicher: 256 Wörter (POKE/PEEK)
  Grafikpuffer 320x240 (TP/LINE...)
  Sprites: 16 Slots (WSDEF)
  Texte A$..Z$; Textbildschirm
  Alles erreichbar aus BASIC

KLANG — 4 STIMMEN (0..3)

WELLENFORM: WAVE stimme,w
  0 PULSE  1 SAW  2 TRIANGLE
  3 SINE   4 NOISE (Trommel)

SPIELEN: PLAY stimme,freq,w
  z.B. PLAY 0,440,0
TON: NOTE freq,dauer(ms)
  z.B. NOTE 880,120

KLANG:
  PULSE stimme,w  0..4095 (2048=50%)
  ENV stimme,a,d,s,r  Hüllkurve ms
  PAN stimme,p    0=links .. 15=rechts
  ARP stimme,n1,n2  Akkord auf 1 Stimme

SEQUENZER:
  TRACK n1,n2,n3,n4[,dur]
  SONG (Schleife)   SONGCLR
STOP — Klang stoppen

BEISPIEL (bass+lead+Trommel):
  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

WIE MAN EIN SPIEL SCHREIBT — IN ETAPPEN

Schreibe nicht alles auf einmal!
Wir machen einen KLEINEN Schritt und prüfen.
Jede Etappe ist ein fertiges Programm.

STARTEN:
   LOAD "GRA1"
   RUN
Oder: hier F5 drücken (die Hilfe
lädt und startet GRA1 selbst).

ETAPPE 1 — SPIELFELD (GRA1)
  Nur die Fläche zeichnen:
   - obere und untere Bande (FILLRECT)
   - gestrichelte Mittellinie
  Noch bewegt sich nichts.

ETAPPE 2 — BALL (GRA2)
  Der Ball prallt vertikal ab.
  Das Geheimnis der Animation, wiederhole:
    1. CLS            löschen
    2. neue Position berechnen
    3. Ball zeichnen
    4. FLIP + WAIT    zeigen und warten
    5. GOTO 1

ETAPPE 3 — ABPRALLEN (GRA3)
  Der Ball fliegt über den ganzen Bildschirm.
  Bewegung in X (links-rechts) kommt dazu.
  Richtung X in R2, Richtung Y in R3.

ETAPPE 4 — SCHLÄGER (GRA4)
  Dein Balken unten am Bildschirm.
  UP/DOWN verschieben ihn.
  Der Ball prallt vom Schläger ab.

ETAPPE 5 — VOLLES SPIEL (GRA5)
  Zwei Schläger: DU und CPU.
  Punkte, wenn der Ball vorbeifliegt.
  Das ist die Verbindung der Etappen 1-4!

TIPP: wenn etwas nicht geht —
gehe eine Etappe zurück und vergleiche.
Jede Etappe FUNKTIONIERT allein.

F5 = startet GRA1

ETAPPE 1 — SPIELFELD  (GRA1)

Ziel: nur die Spielfläche.
Noch bewegt sich nichts.

Was wir zeichnen:
  - obere Bande (FILLRECT)
  - untere Bande (FILLRECT)
  - gestrichelte Mittellinie
    (FOR-Schleife + STEP 8)

Code (Kurzfassung):
  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 = startet GRA1
Dann zurück hierher und weiter
mit Thema 19 (Etappe 2).

ETAPPE 2 — BALL IN BEWEGUNG  (GRA2)

Ziel: der Ball prallt vertikal ab.

GEHEIMNIS DER ANIMATION (wiederhole):
  1. CLS              Bildschirm löschen
  2. Position rechnen R1 = R1 + R2
  3. Ball zeichnen    FILLRECT
  4. FLIP             auf dem Bildschirm zeigen
  5. WAIT 20          20 ms warten
  6. GOTO 1           wiederholen

R1 = Y-Position des Balls
R2 = Richtung (+1 nach unten, -1 nach oben)

ABPRALLEN (sehr wichtig):
  340 IF R1 <= 8   THEN SET R2, 1
  360 IF R1 >= 119 THEN SET R2, -1
Wenn der Ball die Bande berührt,
ändern wir die Richtung.

FLIP ist nötig, sonst springt das Bild.

F5 = startet GRA2

ETAPPE 3 — ABPRALLEN AN 4 WÄNDEN  (GRA3)

Ziel: der Ball fliegt über den GANZEN Bildschirm.
Bewegung in X (links-rechts) kommt dazu.

Jetzt haben wir ZWEI Richtungen:
  R2 = Richtung X (1=rechts, -1=links)
  R3 = Richtung Y (1=unten,  -1=oben)

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

Abprallen (4 Wände):
  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 = startet GRA3

ETAPPE 4-5 — SCHLÄGER UND VOLLES SPIEL

ETAPPE 4 (GRA4): Dein Schläger.
  R4 = Position des Schlägers (links)
  UP/DOWN verschieben ihn (GET R6).
  Abprallen vom Schläger:
    wenn der Ball den Balken berührt ->
    Richtung X umkehren
  F5 = startet GRA4

ETAPPE 5 (GRA5): VOLLES SPIEL.
  Zwei Schläger: DU und CPU.
  R4 = Schläger des Spielers (links)
  R5 = Schläger der CPU (rechts)
  R6,R7 = Punktestand DU, CPU
  Die CPU jagt den Ball selbst:
    IF R5 < R1 THEN ADD R5,R5,3
    IF R5 > R1 THEN SUB R5,R5,3
  Punkt, wenn der Ball vorbeifliegt.
  Das ist die Verbindung der Etappen 1-4!

Um GRA5 zu starten (F5 startet GRA4),
tippe von Hand:
  LOAD "GRA5"
  RUN

SPIEL: SNAKE  (WAZ1 = Kopf, WAZ2 = ganz)

Ein Klassiker: die Schlange frisst und wächst.
  UP/DOWN/LEFT/RIGHT = Bewegung
  ESC = Ende

WAZ1 — nur der KOPF (ein Quadrat).
  Lehrt flüssige Animation in einer
  Richtung. Wände wickeln:
   IF R0 < 0 THEN SET R0, 160

WAZ2 — ganze Schlange:
  * KÖRPER aus vielen Segmenten
    (Arrays SX(), SY())
  * FRESSEN (rotes Quadrat)
  * gefressen -> die Schlange wächst
  * stößt sie sich selbst -> Ende

Geheimnis der Körperbewegung: die
Segmente vom Ende zum Kopf verschieben
(eine Röhre):
  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 = startet WAZ1

SPIEL: ARKANOID  (ARKANOID)

Zerstöre alle KLÖTZE oben!
  LEFT/RIGHT = Schläger
  ESC = Ende

Spielelemente:
  R0,R1 = Ball (X,Y)
  R2,R3 = Ballrichtung
  R4    = Schläger (Spieler, unten)
  KX(),KY(),KH() = Klötze

Die Klötze sind ARRAYS — jeder hat:
  Position X, Y und Zustand (da/zerstört)
  Trifft der Ball -> KH(R7) = 0
  und der Ball prallt nach unten ab.

Abprallen vom Schläger — Klassiker:
  IF Ball auf Schlägerhöhe
  AND Ball über dem Schläger
  THEN SET R3, -2

F5 = startet ARKANOID

SPIEL: 2 KANONEN  (ARMATA)

ZWEI Spieler abwechselnd!
  Ziel: die Kanone des Gegners treffen.

Steuerung:
  G / D = WINKEL der Kanone (hoch/runter)
  H / J = SCHUSSSTÄRKE
  ENTER = FEUERN!   ESC = Ende

Physik (lehrt Winkel und Vektoren!):
  Winkel in Grad -> Bogenmaß:
    R8 = winkel * PI / 180
  waagerechte Geschwindigkeit: vx = stärke*COS(w)
  senkrechte Geschwindigkeit:  vy = stärke*SIN(w)
  Schwerkraft: jede Runde
    vy = vy + 1  (das Geschoss sinkt)

Das Geschoss fliegt im BOGEN —
je größer die Stärke, desto weiter.
Treffer = Punkt. Dann schießt der
andere. Ergebnis unten.

F5 = startet ARMATA

SYNTH — SO SPIELT MAN

WICHTIG: Der Ton schaltet sich erst
nach dem ersten Befehl NOTE oder PLAY
ein. Ohne das bleibt es STILL!

SCHRITT 1: Ton in BASIC einschalten:
   NOTE 440,300
   (440 Hz = Ton A, 300 ms)
Jetzt siehst du oben im Raum SYNTH:
DZWIEK: ON

SCHRITT 2: Raum SYNTH öffnen
(Raummenü -> SYNTH -> ENTER)

TASTEN IM RAUM SYNTH:
  1 2 3 4        STIMME wählen
  W              nächste WELLENFORM
  Z X C V B N M  Noten C D E F G A B
  ESC            zurück zum Raummenü

4 STIMMEN — jede spielt einen eigenen
Klang gleichzeitig (wie 4 Musiken).
Stimme mit Ziffer wählen, Wellenform
mit W ändern.

MUSIC — WELLENFORM (Wellenformen)

Die WELLENFORM bestimmt die FORM der
Schallwelle. Andere Form = andere
Klangfarbe (Timbre).

5 Wellenformen in CYBER27:
  0 PULSE     Rechteck (wie SID)
  1 SAW       Sägezahn (scharf, brummt)
  2 TRIANGLE  Dreieck (weich)
  3 SINE      Sinus (rein)
  4 NOISE     Rauschen (Trommel, Donner)

Ändern: Taste W im Raum SYNTH
oder in BASIC:
  WAVE 0,3      Stimme 0 -> Sinus

PULSE (Rechteck) hat zusätzlich
PULSE WIDTH — die Impulsbreite:
  PULSE 0,2048  (2048 = genau 50%)

WOFÜR: jedes Instrument hat eine andere
Wellenform — Flöte ist Sinus, Trompete
ist Sägezahn, Schlagzeug ist Rauschen.

PROGRAMMIERKURS — PLAN

Ziel: eine ganze ProgrammierSCHULE,
nicht nur das ABC — 100 Übungen,
damit du nach dem Kurs BASIC
fließend beherrschst.

KURS1 (Start) — Einführung:
  1 Wie ein Computer denkt (0/1)
  2 Das erste PRINT
  3 Zahlen und Register
  4 Addieren in BASIC

ALLE MODULE DES KURSES:
  A Grundlagen (PRINT, Variablen)
  B Arithmetik und Ausdrücke
  C Bedingungen IF...THEN
  D Schleifen FOR...NEXT
  E Tabellen (DIM)
  F Texte A$
  G Unterprogramme GOSUB/RETURN
  H Grafik (TP, LINE, ...)
  I Klang (NOTE, WAVE, ...)
  J Spiele (Animation, Kollision)

F5 = startet KURS1

MARGARET HAMILTON (1936-)

Sie SCHRIEB die Software für Apollo 11!
Sie leitete Teams am MIT (Instrumentation
Laboratory). Sie prägte den Begriff
"Software Engineering".

BERÜHMTES FOTO 1969:
  Sie steht neben einem STAPEL
  Ausdrucke des AGC-Codes —
  höher als sie selbst!

IHR CODE RETTETE DIE MISSION:
  Während des Fluges löste ein Radar
  einen Alarm aus (1201, 1202).
  Ihr Code priorisierte die wichtigen
  Aufgaben und ignorierte den Rest.
  Die Landung gelang.

DIE LEHRE FÜR UNS:
  — Software ist Ingenieurarbeit
  — Fehler kosten Leben (oder Missionen)
  — Gute Prioritäten retten alles

MORSE-ALPHABET

MORSE = Punkt (.) und Strich (-).
Jeder Buchstabe hat eine eigene Folge.

Punkt = KURZES Signal
Strich = LANGES (3x Punkt)
Abstand zwischen Buchstaben = 3 Punkte
Abstand zwischen Wörtern = 7 Punkte

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  --..

C64-ZEIT: Morse war mehr als Witz —
  dazu gab es MORSE.BAS zum Üben.

SONNENSYSTEM: PLANETEN

8 Planeten, jeder hat seine Karte:
  Abstand von der Sonne, Tag (Rotation),
  Jahr (Umlauf), Bedingungen auf der
  Oberfläche und Anzahl der Monde.

REIHENFOLGE von der Sonne:
  1 MERKUR   57,9 Mio km, Jahr 88 Tage
  2 VENUS   108,2 Mio km, +465 °C
  3 ERDE    149,6 Mio km (unser Zuhause!)
  4 MARS    227,9 Mio km, 2 Monde
  5 JUPITER 778,5 Mio km, GAS, 95 Mo.
  6 SATURN  1434 Mio km, Ringe
  7 URAN    2871 Mio km, liegt seitlich
  8 NEPTUN  4495 Mio km, am weitesten

MASSE: 1 AE = 149,6 Mio km
  (AE = Astronomische Einheit)

APOLLO 11: MISSIONS-SIMULATOR

Das ist KEIN Quiz — das ist ein SPIEL.
Du bist der Pilot. Ziel: zum Mond
(384 000 km) und sicher zurück.

STEUERUNG:
  L / P  = FENSTER wechseln (Ansicht)
  G / D  = AKTION wählen
  ENTER  = Aktion ausführen
  S      = Mission speichern
  L      = Mission laden
  ESC    = zurück zum Menü

ANZEIGEN IM COCKPIT:
  HÖHE, GESCHWINDIGKEIT, Entfernung
  zum Ziel, TREIBSTOFF, SAUERSTOFF,
  STROM.

ZUFALLSEREIGNISSE (AUSFÄLLE!):
  - Treibstoffleck
  - Ausfall der Elektronik
  - Sauerstoffverlust

APOLLO: FLUGPHYSIK

Die physikalischen Gesetze, die den
Flug zum Mond bestimmen.

1) GESCHWINDIGKEIT: v = s / t
   Geschwindigkeit = Weg / Zeit
   z.B. 300 km in 2 h -> 150 km/h

2) TREIBSTOFF: Treibstoff = Verbrauch * Zeit
   Der Motor verbraucht X pro Stunde,
   der Flug dauert Y Stunden -> X * Y.

3) BESCHLEUNIGUNG: a = dv / t
   wie schnell die Geschwindigkeit wächst.

4) GEWICHT: Schwerkraft verschiedener Körper
   (Erde = 1, Mond = 1/6 -> 6x leichter).

5) FLUCHTGESCHWINDIGKEIT:
   die Mindestgeschwindigkeit, um einen
   Körper zu verlassen (Erde: 11,2 km/s).

EIGENE RÄUME (Befehle)

Du kannst einen EIGENEN Raum anlegen
und selbst bestimmen, welches Programm
dort startet.

SO GEHT ES:
  1. Schreibe ein Programm (im Raum
     BASIC) und speichere es:
       SAVE "MEINPROG"
     (erzeugt MEINPROG.BAS)
  2. Füge einen Raum mit diesem Programm hinzu:
       POKOJ "MEIN SPIEL","MEINPROG"
  3. Speichere die Raumliste auf die Karte:
       ZAPISZPOKOJE

Der neue Raum erscheint im RAUMMENÜ und
startet dein Programm. Er überlebt einen
NEUSTART (Datei POKOJE.TXT auf der Karte).

BENANNTE VARIABLEN

Stell dir SCHACHTELN mit Beschriftung vor.
In jede legst du eine Zahl. Der Name sagt,
WAS darin liegt.

Statt zu merken "R3 sind die Punkte",
schreibst du einfach: POINTS.

VERWENDUNG:
  POINTS = 10      lege 10 in POINTS
  PRINT POINTS     zeige (10)
  POINTS = POINTS + 5   erhöhe (15)

RECHNEN:
  LEBEN = 3
  LEBEN = LEBEN - 1     (2)
  ERGEBNIS = LEBEN * 10 (20)

Der NAME darf Buchstaben, Ziffern und '_'
enthalten. Bis 15 Zeichen. Groß/klein
ist egal: pun kte = PUNKTE.

TYPEN UND DATENSÄTZE (TYPE)

Statt 5 einzelner Variablen für EINE Sache —
mach EINE Schachtel mit mehreren Fächern.

Das ist ein DATENSATZ. Die Fachnamen
sind FELDER.

SCHRITT 1 — beschreiben, was ein Geschoss hat:
  TYPE Geschoss
  X
  Y
  VX
  END TYPE

SCHRITT 2 — Tabelle von Geschossen:
  DIM p(4) AS Geschoss
  (5 Geschosse: p(0)..p(4))

SCHRITT 3 — benutzen (Punkt '.'):
  p(0).X = 100
  p(0).VX = -3
  p(0).X = p(0).X + p(0).VX

VORTEIL: alle Daten eines Objekts bleiben
zusammen — wie in einer Klassen-Definition.

PROZEDUREN: SUB und FUNCTION

Was, wenn du dasselbe Stück Code oft
wiederholst? Statt zu kopieren — mach
eine PROZEDUR.

SUB ist eine Befehlsgruppe mit Namen.
Du rufst sie mit CALL auf.

SO ERSTELLST DU EIN SUB:
  SUB Zeichne(x, y)
  PRINT "Zeichne in ", x, y
  END SUB

AUFRUFEN:
  CALL Zeichne(10, 20)
  CALL Zeichne(30, 40)

x und y sind PARAMETER. Im SUB sind sie
lokal (haben ihre Werte nur dort).

FUNCTION — wie SUB, aber sie GIBT einen
Wert zurück (in WYNIK):
  FUNCTION Quadrat(a)
  WYNIK = a * a
  END FUNCTION
  R0 = Quadrat(5)     -> 25

MARKEN (GOTO Start)

Bisher sprang man zu einer ZEILENNUMMER:
  GOTO 500
Das ist mühsam — man muss Nummern merken.

Jetzt kannst du einer Stelle einen NAMEN
geben. Du schreibst den Namen und einen
Doppelpunkt:

  SCHLEIFE:
  PRINT "einmal"
  GOTO SCHLEIFE

Eine Marke ist wie ein Lesezeichen im
Buch — GOTO springt dorthin zurück.

WIE ES FUNKTIONIERT:
  Start:      <- Marke (mit ':')
  ... Code ...
  GOTO Start  <- Sprung zur Marke

AUCH GOSUB (mit Rückkehr):
  GOSUB Begruessung
  ...
  Begruessung:
  PRINT "Hallo"
  RETURN

PCM-SAMPLES (Klang wie Amiga)

Der Synthesizer erzeugt Töne aus Noten.
Ein SAMPLE ist eine AUFNAHME — echter
Klang: Schlagzeug, Gitarre, Stimme,
Schuss. Wie am Amiga!

Eine Sample-Datei sind Rohdaten
.RAW (8-Bit, wie Amiga).

SCHRITT 1 — laden (SLOAD):
  SLOAD 0, "TEST.RAW"
  (Slot 0..3, Datei von der SD-Karte)

SCHRITT 2 — abspielen (SPLAY):
  SPLAY 0, 0, 1.0
  Kanal(0..3), Slot, Pitch

PITCH = Tonhöhe (wie Paula):
  1.0 = normal
  2.0 = eine Oktave HÖHER
  0.5 = eine Oktave TIEFER

PAINT 3D — GRAFIK-EDITOR

Du zeichnest Bilder, die danach die
3D-Engine und die Spiele laden.

TAB = nächster Modus:
  0 Textur 64x64 (Wände)
  1 Figur  32x32 x 8 Frames
  2 Waffe  64x32 x 2 Frames
  3 BIB    32x32 (Bibliothek)

N = nächster Frame
G = Gitter 8x8 (Zeichenhilfe)

TASTEN (nur Tastatur!):
  PFEILE    = Cursor bewegen
  LEERTASTE = setzen / beenden
  A / D     = Farbe - / +
  1..5      = Werkzeug

WERKZEUGE (1..5):
  1 Pixel    2 Linie    3 Rechteck
  4 Kreis    5 Füllen

S = speichern (PAINT.RAW)
L = laden

VERWENDUNG IM SPIEL:
  Textur: WTLD 1,"PAINT.RAW"
  Figur:  WSDEF 1,"PAINT.RAW"
  Waffe:  WGUN "PAINT.RAW"

F5 = startet PAINT3D

NEU IN CYBER27 (2026)

255 FARBEN (vorher 32)
  CO 0..254   z.B. CO 32 = reines Schwarz

  Neue Gruppen:
   64-79  Graustufen (16)
   80-95  Rot-Töne (16)
   96-111 Grün-Töne (16)
   112-127 Blau-Töne (16)
   128-143 Gold/Braun (16)
   144-159 Violett (16)
   160-175 Türkis (16)
   176-191 Hauttöne (16)
   192-207 Stein (16)
   208-223 Wald (16)
   224-239 Himmel (16)
   240-254 Feuer (15)

PUFFER 320x240 (vorher 164x128)
  - 4x mehr Pixel
  - auf 640x480 Skala x2 = VOLLER Bildschirm
  - auf 1920x1080 Skala x4

WCOMPAT 2   alte Spiele (0..163)
WCOMPAT 1   neue Spiele (0..319)
  Standard ist 2 — alte Spiele laufen.
  In einem neuen Spiel: WCOMPAT 1.

SCRINFO  Info über den Bildschirm:
  R0,R1 = Breite,Höhe
  R2    = Pufferskala
  R3,R4 = Offset X,Y
  R5,R6 = Puffergröße

FOR mit NAMEN (vorher nur R0..R7)
  FOR I = 1 TO 10   funktioniert!
  NEXT I

BLIT sx,sy,w,h,dx,dy
  Rechteck im Puffer kopieren.
  Scrolling: BLIT 2,0,318,239,0,0

BLITT sx,sy,w,h,dx,dy
  Wie BLIT, aber Pixel 0 sind
  DURCHSICHTIG (Hintergrund bleibt).

WSETDIR "verzeichnis"
  Ressourcen-Verzeichnis für WTLD/WSDEF
  WSETDIR "" = Hauptverzeichnis

WARSTWY.TXT — Ebenen-Datenbank
  NAZWA RENDER HOEHE KOLIZJA TEXTUR [SPRITE=n]
  render: podloga/bryla/prog/drzewo/sprite/brak