;*************************************************************************
;*
;* Dieses Programm ist Public Domain und wurde mit dem Profimat-Assembler
;* von Data Becker erstellt. Das Kopieren für den privaten
;* Gebrauch ist erlaubt. Sollen das Programm oder Teile daraus für
;* kommerzielle Zwecke verwendet werden, bitte ich darum, sich mit
;* mir in Verbindung zu setzen.
;*
;* © 1987 Richard Englert, Flößaustraße 160, 8510 Fürth, Tel.:0911/708255
;*
;* letzte Änderung: 20-09-1987
;*
;* TinyCycle ist ein Tron-Clone mit einfacher Grafik (aber mit einigen
;* Extras).
;* Gestartet wird das Programm entweder über CLI oder Workbench. Nach dem
;* Start werden einige Parameter eingestellt, die TinyCycle über Requester
;* vom Spieler erfragt:
;*
;* Geschwindigkeit:
;*    -Normal: normale Spielgeschwindogkeit; vor jedem Durchlauf wird
;*             mittels Delay-Funktion eine fünfzigstel Sekunde gewartet.
;*    -Horror: keine Verzögerung. Die eine fünfzigstel Sekunde macht's
;*             wirklich aus. (Ausprobieren !!)
;*
;* Spieler 1:
;*    -Tastatur: Spieler 1 benutzt die Cursor-Tasten um zu steuern.
;*    -Joystick: Spieler 1 benutzt einen Joystick in Port 1.
;*
;* Spieler 2:
;*    -Ja:   ein zweiter Spieler steuert mit einem Joystick in Port 2
;*           einen eigenen Fahrer.
;*    -Nein: kein zweiter Spieler. Dafür kommt automatisch ein Robo-
;*           Driver ins Spiel.
;*
;* Robo-Driver:
;*    -Ja:   spielen zwei Menschen gegeneinander, gibt es noch die
;*           Möglichkeit, einen Computergesteuerten Spieler mitmischen
;*           zu lassen.
;*    -Nein: nur die zwei menschlichen (?) Spieler spielen gegeneinander.
;*
;* Spielt man zu zweit und mit Computer, sollte man Versuchen, gemeinsam
;* gegen den Robo-Driver anzukommen, und sich nicht gegeseitig den Hahn
;* abzudrehen. Der Robo-Driver ist zwar nicht sonderlich intelligent,
;* aber dadurch, daß sich die zwei menschlichen Spieler bekämpfen, bekommt
;* er aber doch die meisten Punkte.
;*
;* Wer seine Reaktionen testen will, sollte alleine gegen den Computer
;* mit Geschwindigkeit Horror spielen.
;*
;* Auf Sound habe ich verzichtet, da ich, wie der Name TinyCycle schon
;* aus drückt, besonders auf die Kürze des Programmcodes geachtet habe.
;* Allerdings ist es nach allen Erweiterungen und Zusätzen, die mir
;* beim Programmieren eingefallen sind, doch etwa 3-mal so groß geworden,
;* wie vorgesehen.
;*
;* Gestartet wird nach der Parametereingabe mit der DEL-Taste. Ein neues
;* Spiel wird entweder durch Druck auf den Feuerknopf eines der beiden
;* Joysticks oder durch drücken der DEL-Taste.
;* Nach jedem Spiel kann man außerdem die Parameter neu einstellen, dazu
;* HELP drücken, oder TinyCycle verlassen (ESC).
;*
;*************************************************************************

 INCLUDE 'ram:Amiga.ASM'

; AmigaDos-Funktionen:

_LVOOpenLibrary   EQU -552
_LVOCloseLibrary  EQU -414
_LVOOpenScreen    EQU -198
_LVOCloseScreen   EQU -66
_LVOOpenWindow    EQU -204
_LVOCloseWindow   EQU -72
_LVOSetWindowTitles EQU -276
_LVOWritePixel    EQU -324
_LVOReadPixel     EQU -318
_LVOSetAPen       EQU -342
_LVODelay         EQU -198
_LVOSetRGB4       EQU -288
_LVOClearScreen   EQU -48
_LVOMove          EQU -240
_LVODraw          EQU -246
_LVOSetTaskPri    EQU -300
_LVOSetPointer    EQU -270
_LVOAutoRequest   EQU -348

; Konstanten

RastPort          EQU $32
ViewPort          EQU $2C

;*************************************************************************
;Hauptprogramm:
;*************************************************************************

 INIT_AMIGA

 LEA IntuitionName,A1            ;Intuition Library
 MOVEQ #0,D0                     ;öffnen
 CALLSYS OpenLibrary
 MOVE.L D0,IntuitionBase
 BEQ EXIT

 LEA GfxName,A1                  ;Graphics Library
 MOVEQ #0,D0                     ;öffnen
 CALLSYS OpenLibrary
 MOVE.L D0,GfxBase
 BEQ EXIT

 LEA DosName,A1                  ;Dos Library
 MOVEQ #0,D0                     ;öffnen
 CALLSYS OpenLibrary
 MOVE.L D0,DosBase
 BEQ EXIT

 LEA ScrDef,A0                   ;Screen öffnen
 LINKSYS OpenScreen,IntuitionBase
 MOVE.L D0,Screen
 BEQ EXIT

 MOVE.L D0,A1
 LEA ViewPort(A1),A0             ;ViewPort des Screens
 MOVE.L A0,VP

 CLR.L D0                        ;Farbregister 0
 CLR.L D1                        ;mit schwarz belegen
 CLR.L D2
 CLR.L D3
 LINKSYS SetRGB4,GfxBase

 MOVE.L VP,A0
 MOVEQ.L #1,D0                   ;Register 1: weiß
 MOVE.L #$F,D1
 MOVE.L #$F,D2
 MOVE.L #$F,D3
 LINKSYS SetRGB4,GfxBase

 MOVE.L VP,A0
 MOVEQ.L #2,D0                   ;Register 2: grün
 MOVE.L #$6,D1
 MOVE.L #$F,D2
 MOVE.L #$0,D3
 LINKSYS SetRGB4,GfxBase

 MOVE.L VP,A0
 MOVEQ.L #3,D0                   ;und Register 3: rot
 MOVE.L #$D,D1
 MOVE.L #$5,D2
 MOVE.L #$0,D3
 LINKSYS SetRGB4,GfxBase

 LEA WinDef,A0                   ;Window öffnen
 LINKSYS OpenWindow,IntuitionBase
 MOVE.L D0,Window
 BEQ EX

 MOVE.L D0,A0
 MOVE.L RastPort(A0),A1          ;RastPort des Windows
 MOVE.L A1,RP

 BSR Parameter                   ;Parameter einstellen

 BSR Rahmen                      ;Rahmen zeichnen

 MOVE.L Window,A0
 LEA MouseData,A1                ;Mauszeiger für Window
 MOVE.L #15,D0                   ;unsichtbar werden lassen
 MOVE.L #15,D1
 MOVEQ #-1,D2
 MOVEQ #-1,D3
 LINKSYS SetPointer,IntuitionBase

WarteDel:
 CMP.B #115,$BFEC01              ;auf DEL-Taste warten
 BNE WarteDel

Neues_Spiel:
 MOVE.W #80,J1X                  ;Anfangskoordinaten für
 MOVE.W #140,J1Y                 ;Spieler 1 und 2, und
 MOVE.W #240,J2X                 ;den Computergesteuerten
 MOVE.W #140,J2Y                 ;dritten Spieler setzen
 MOVE.W #160,RbX
 MOVE.W #140,RbY

 MOVE.L Window,A0                ;Screentitelzeile
 SUB.L A1,A1

 TST.W RobFlag
 BEQ SC3                         ;entsprechend der

 TST.W Joy2Flag
 BEQ SC2
 LEA ScrTitle1,A2                ;Einstellung ( 2 Spieler und
 BRA SetW                        ; Robo, oder

SC2:
 LEA ScrTitle2,A2                ; 1 Spieler und Robo, oder
 BRA SetW

SC3:
 LEA ScrTitle3,A2                ; nur 2 Spieler)

SetW:
 LINKSYS SetWindowTitles,IntuitionBase   ;setzen

 CLR.W D4
 CLR.W D5

Hauptschleife:                   ;Hauptprogrammschleife
 MOVEM.W D4-D5,-(SP)             ;in D4/D5 Daten für Tastaturabfrage

 MOVE.L #14,D4
 MOVE.L #15,D5

 CLR.L D7

 MOVE.W $DFF00C,D0               ;Port 2 abfragen
 MOVE.W D0,D1
 MOVE.W D1,D2
 MOVE.W D2,D3                    ;und die Richtungen in

 LSL.W D5,D0                     ;D0 für runter
 LSR.W D5,D0

 LSL.W D4,D1                     ;D1 für rechts
 LSR.W D5,D1

 LSL.W #7,D2                     ;D2 für rauf
 LSR.W D5,D2

 LSL.W #6,D3                     ;und D3 für links
 LSR.W D5,D3                     ;bringen

 TST.W D1                        ;nach rechts ?
 BEQ qwa
 MOVEQ.L #4,D7                   ;ja, dann D7 = 4
 BRA Joy1Test

qwa:
 TST.W D0                        ;nach unten ?
 BEQ qay
 MOVEQ.L #2,D7                   ;ja, dann D7 = 2
 BRA Joy1Test

qay:
 TST.W D3                        ;nach links ?
 BEQ wsx
 MOVEQ.L #3,D7                   ;ja, dann D7 = 3
 BRA Joy1Test

wsx:
 TST.W D2                        ;oder nach oben ?
 BEQ Joy1Test
 MOVEQ.L #1,D7                   ;dann D7 = 1

Joy1Test:
 CLR.L D6

 MOVE.W $DFF00A,D0               ;gleiches Spiel, wie für
 MOVE.W D0,D1                    ;Joystick-Port 2
 MOVE.W D1,D2
 MOVE.W D2,D3

 LSL.W D5,D0
 LSR.W D5,D0

 LSL.W D4,D1
 LSR.W D5,D1

 LSL.W #7,D2
 LSR.W D5,D2

 LSL.W #6,D3
 LSR.W D5,D3

 TST.W D1
 BEQ qwe
 MOVEQ.L #4,D6
 BRA KeyTest

qwe:
 TST.W D0
 BEQ qas
 MOVEQ.L #2,D6
 BRA KeyTest

qas:
 TST.W D3
 BEQ wsd
 MOVEQ.L #3,D6
 BRA KeyTest

wsd:
 TST.W D2
 BEQ KeyTest
 MOVEQ.L #1,D6

KeyTest:
 MOVEM.W (SP)+,D4-D5             ;Tastatur abfragen

 TST.W KeyFlag                   ;wird Tastatur gebraucht ?
 BEQ Joy2Up                      ;nein, dann Joy 2 auswerten

 MOVE.B D4,D5
 MOVE.B $BFEC01,D4               ;welche Taste gedrückt ?

 CMP.B D4,D5                     ;gleiche Taste, wie beim
 BEQ Joy2Up                      ;letzten Mal, dann Joy 2

 CMP.W #1,X1                     ;testen, ob gegen die Fahrt-
 BNE UI1                         ;richtung gesteuert werden
 CMP.B #97,D4                    ;soll, wenn ja, dann
 BEQ Joy2Up                      ;ignorieren

UI1:
 CMP.W #-1,X1                    ;soll gegen Fahrtrichtung
 BNE UI2                         ;gesteuert werden ?
 CMP.B #99,D4
 BEQ Joy2Up                      ;ja, dann überspringen

UI2:
 CMP.W #1,Y1                     ;wie eben
 BNE UI3
 CMP.B #103,D4
 BEQ Joy2Up

UI3:
 CMP.W #-1,Y1                    ;wie eben
 BNE KeyUp
 CMP.B #101,D4
 BEQ Joy2Up

KeyUp:
 CMP.B #103,D4                   ;nach oben steuern ?
 BNE KeyDown
 CLR.L X1                        ;vorige Richtung löschen
 MOVE.W #-1,D0                   ;und neue Richtung setzen
 MOVE.W D0,Y1

 BRA Joy2Up                      ;Joy 2 auswerten

KeyDown:
 CMP.B #101,D4                   ;nach unten steuern ?
 BNE KeyLeft
 CLR.L X1                        ;wieder vorige Richtung löschen
 MOVE.W #1,D0                    ;und neue setzen
 MOVE.W D0,Y1

 BRA Joy2Up

KeyLeft:
 CMP.B #97,D4                    ;nach links ?
 BNE KeyRight
 CLR.L X1                        ;wie gehabt
 MOVE.W #-1,D0
 MOVE.W D0,X1

 BRA Joy2Up

KeyRight:
 CMP.B #99,D4                    ;nach rechts ?
 BNE Joy2Up
 CLR.L X1                        ;nochmal das gleiche Spiel
 MOVE.W #1,D0
 MOVE.W D0,X1

Joy2Up:
 TST.W Joy2Flag                  ;wird Joy 2 gebraucht ?
 BEQ TJ1                         ;nein, dann Joy 1 testen

 TST.W D7                        ;Joy 2 in keine Richtung, dann
 BEQ TJ1                         ;gleich Joy 1 testen

 CMP.W #1,X2                     ;wieder wie oben, beim Tastatur-
 BNE ZU1                         ;test prüfen, ob in die Gegen-
 CMP.W #3,D7                     ;richtung gesteuert werden soll,
 BEQ TJ1                         ;und wenn ja, überspringen

ZU1:
 CMP.W #-1,X2                    ;das ganze für alle 4 Richtungen
 BNE ZU2
 CMP.W #4,D7
 BEQ TJ1

ZU2:
 CMP.W #1,Y2                     ;nochmal
 BNE ZU3
 CMP.W #1,D7
 BEQ TJ1

ZU3:
 CMP.W #-1,Y2                    ;und noch einmal
 BNE ZU4
 CMP.W #2,D7
 BEQ TJ1

ZU4:
 CMP.W #1,D7                     ;Joy 2 nach oben ?
 BNE Joy2Down
 CLR.L X2                        ;ja, dann alte Richtung löschen
 MOVE.W #-1,D0                   ;und neue Richtung setzen
 MOVE.W D0,Y2

 BRA TJ1                         ;Joy 1 auswerten

Joy2Down:
 CMP.W #2,D7                     ;Joy 2 nach unten ?
 BNE Joy2Left
 CLR.L X2                        ;wenn ja, wieder alte Richtung
 MOVE.W #1,D0                    ;löschen und neue setzen
 MOVE.W D0,Y2

 BRA TJ1

Joy2Left:
 CMP.W #3,D7                     ;das gleiche für links
 BNE Joy2Right
 CLR.L X2
 MOVE.W #-1,D0
 MOVE.W D0,X2

 BRA TJ1

Joy2Right:
 CMP.W #4,D7                     ;und noch für rechts
 BNE TJ1
 CLR.L X2
 MOVE.W #1,D0
 MOVE.W D0,X2

TJ1:
 TST.W KeyFlag                   ;soll Tastatur benutzt werden ?
 BNE Rob                         ;ja, dann gleich Robbi auswerten

 TST.W D6                        ;in keine Richtung gedrückt ?
 BEQ Rob                         ;auch Robbi besuchen

 CMP.W #1,X1                     ;wie gehabt, alle 4 Richtungen
 BNE QU1
 CMP.W #3,D6                     ;abfragen, ob in die Gegenrichtung
 BEQ Rob                         ;gesteuert werden soll

QU1:
 CMP.W #-1,X1
 BNE QU2
 CMP.W #4,D6
 BEQ Rob

QU2:
 CMP.W #1,Y1
 BNE QU3
 CMP.W #1,D6
 BEQ Rob

QU3:
 CMP.W #-1,Y1
 BNE Joy1Up
 CMP.W #2,D6
 BEQ Rob

Joy1Up:
 CMP.W #1,D6                     ;Joy 2 nach oben ?
 BNE Joy1Down
 CLR.L X1                        ;wieder alte Richtung löschen
 MOVE.W #-1,D0                   ;und neue setzen (Gähn)
 MOVE.W D0,Y1

 BRA Rob                         ;Computerzug

Joy1Down:
 CMP.W #2,D6                     ;nach unten ?
 BNE Joy1Left
 CLR.L X1
 MOVE.W #1,D0
 MOVE.W D0,Y1

 BRA Rob

Joy1Left:
 CMP.W #3,D6                     ;oder vielleicht nach links
 BNE Joy1Right
 CLR.L X1
 MOVE.W #-1,D0
 MOVE.W D0,X1

 BRA Rob

Joy1Right:
 CMP.W #4,D6                     ;oder etwa nach rechts ?
 BNE Rob
 CLR.L X1
 MOVE.W #1,D0
 MOVE.W D0,X1

Rob:
 TST.W RobFlag                   ;Computergesteuerter Spieler ?
 BEQ TAD

 ADD.W #1,Zlr                    ;ja, dann spätestens nach 200
 CMP.W #200,Zlr                  ;Zügen die Richtung änderm
 BNE RbTst
 CLR.W Zlr
 CMP.W #1,RX                     ;fährt Rob nach rechts ?
 BNE TsX
 CLR.L RX                        ;dann neue Richtung wählen

 BSR Random                      ;Zufall mit ins Spiel bringen
 TST.B D0
 BNE JU1
 MOVE.W #1,RY                    ;und nach unten
 BRA RbTst

JU1:
 MOVE.W #-1,RY                   ;oder oben umlenken
 BRA RbTst

TsX:
 CMP.W #-1,RX                    ;das selbe für linke Richtung
 BNE TsY
 CLR.L RX

 BSR Random
 TST.B D0
 BEQ JU2
 MOVE.W #1,RY
 BRA RbTst

JU2:
 MOVE.W #-1,RY
 BRA RbTst

TsY:
 CMP.W #1,RY                     ;und nach unten
 BNE TsY2
 CLR.L RX

 BSR Random
 TST.B D0
 BEQ JU3
 MOVE.W #1,RX
 BRA RbTst

JU3:
 MOVE.W #-1,RX
 BRA RbTst

TsY2:
 CLR.L RX                        ;und schließlich für oben

 BSR Random
 TST.B D0
 BEQ JU4
 MOVE.W #1,RX
 BRA RbTst

JU4:
 MOVE.W #-1,RX

RbTst:
 CMP.W #1,RX                     ;fährt Rob nach rechts ?
 BNE TX2

 MOVE.W RbX,D0                   ;was ist rechts von ihm ?
 ADDQ.W #1,D0
 MOVE.W RbY,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BEQ TAD                         ;nichts, dann weiterfahren

 MOVE.W RbX,D0                   ;wenn dort schon ein Punkt ist
 MOVE.W RbY,D1
 ADDQ.W #1,D1                    ;dann mal schauen, was unter
 MOVE.L RP,A1                    ;Rob ist
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobUp                       ;wenn dort ein Punkt ist, nach oben

 MOVE.W RbX,D0
 MOVE.W RbY,D1                   ;wenn unter ihm auch nichts ist,
 SUBQ.W #1,D1
 MOVE.L RP,A1                    ;dann schauen, was über ihm ist
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobDown                     ;wenn schon ein Punkt, nach unten

 BSR Random                      ;weder über noch unter Rob ein Punkt
 TST.B D0                        ;dann Zufall ins Spiel bringen
 BEQ RobUp                       ;und entweder nach oben, oder

 BRA RobDown                     ;unten weiterfahren

TX2:
 CMP.W #-1,RX                    ;der gleiche Test wie für rechts
 BNE TY1                         ;nur für links

 MOVE.W RbX,D0
 SUBQ.W #1,D0
 MOVE.W RbY,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BEQ TAD

 MOVE.W RbX,D0
 MOVE.W RbY,D1
 ADDQ.W #1,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobUp

 MOVE.W RbX,D0
 MOVE.W RbY,D1
 SUBQ.W #1,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobDown

 BSR Random
 TST.B D0
 BEQ RobUp

 BRA RobDown

TY1:
 CMP.W #1,RY                     ;und nun für Fahrtrichtung
 BNE TY2                         ;unten

 MOVE.W RbX,D0
 MOVE.W RbY,D1
 ADDQ.W #1,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BEQ TAD

 MOVE.W RbX,D0
 SUBQ.W #1,D0
 MOVE.W RbY,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobRight

 MOVE.W RbX,D0
 ADDQ.W #1,D0
 MOVE.W RbY,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobLeft

 BSR Random
 TST.B D0
 BEQ RobRight

 BRA RobLeft

TY2:
 MOVE.W RbX,D0                   ;und schließlich für oben
 MOVE.W RbY,D1
 SUBQ.W #1,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BEQ TAD

 MOVE.W RbX,D0
 SUBQ.W #1,D0
 MOVE.W RbY,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobRight

 MOVE.W RbX,D0
 ADDQ.W #1,D0
 MOVE.W RbY,D1
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase
 TST.B D0
 BNE RobLeft

 BSR Random
 TST.B D0
 BEQ RobRight

 BRA RobLeft

RobUp:
 CLR.L RX                        ;Robbi nach oben steuern
 MOVE.W RY,D0                    ;alte Richtung löschen
 MOVE.W #-1,D0                   ;und neue setzen
 MOVE.W D0,RY

 BRA TAD

RobDown:
 CLR.L RX                        ;gleiches Spiel nach unten
 MOVE.W RY,D0
 MOVE.W #1,D0
 MOVE.W D0,RY

 BRA TAD

RobLeft:
 CLR.L RX                        ;nach links
 MOVE.W RX,D0
 MOVE.W #-1,D0
 MOVE.W D0,RX

 BRA TAD

RobRight:
 CLR.L RX                        ;oder nach rechts
 MOVE.W RX,D0
 MOVE.W #1,D0
 MOVE.W D0,RX

TAD:
 MOVEM.W D4-D7,-(SP)             ;alles auswerten und die Punkte
                                 ;setzen
 TST.W Joy2Flag                  ;Joy 2 wird benötigt ?
 BEQ DRJ2

 MOVE.W J2X,D0                   ;ja, dann alte Punkt-
 MOVE.W J2Y,D1                   ;koordinaten nach D0/D1 bringen
 MOVE.W X2,D2                    ;und einen Punkt, entsprechend
 MOVE.W Y2,D3                    ;der Richtung neue Koordinaten
 ADD.W D2,D0                     ;berechnen
 ADD.W D3,D1

 MOVE.W D0,J2X                   ;ist dort schon ein Punkt ?
 MOVE.W D1,J2Y
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase

 TST.B D0
 BNE ENDE2                       ;ja, dann Spieler 2 kollidiert

 MOVE.L RP,A1                    ;nein, Farbe setzen
 MOVEQ.L #1,D0                   ;Register 1
 LINKSYS SetAPen,GfxBase

 MOVE.W J2X,D0                   ;und neuen Punkt setzen
 MOVE.W J2Y,D1
 MOVE.L RP,A1
 LINKSYS WritePixel,GfxBase

DRJ2:
 MOVE.W J1X,D0                   ;das gleiche für Spieler 1
 MOVE.W J1Y,D1
 MOVE.W X1,D2
 MOVE.W Y1,D3
 ADD.W D2,D0                     ;neue Koordinaten
 ADD.W D3,D1

 MOVE.W D0,J1X
 MOVE.W D1,J1Y
 MOVE.L RP,A1                    ;ist dort schon ein Punkt ?
 LINKSYS ReadPixel,GfxBase

 TST.B D0
 BNE ENDE1                       ;ja, dann Spieler 1 kollidiert

 MOVE.L RP,A1
 MOVEQ.L #3,D0                   ;nein, Farbe für Spieler 1
 LINKSYS SetAPen,GfxBase

 MOVE.W J1X,D0
 MOVE.W J1Y,D1                   ;und Punkt setzen
 MOVE.L RP,A1
 LINKSYS WritePixel,GfxBase

 TST.W RobFlag                   ;spielt Robbi auch mit ?
 BEQ WAB

 MOVE.W RbX,D0                   ;ja, dann neue
 MOVE.W RbY,D1                   ;Koordinaten berechnen
 MOVE.W RX,D2
 MOVE.W RY,D3
 ADD.W D2,D0
 ADD.W D3,D1

 MOVE.W D0,RbX
 MOVE.W D1,RbY                   ;und prüfen, ob schon ein Punkt
 MOVE.L RP,A1
 LINKSYS ReadPixel,GfxBase

 TST.B D0
 BNE ENDE3

 MOVE.L RP,A1                    ;nein, dann Farbe und
 MOVEQ.L #2,D0
 LINKSYS SetAPen,GfxBase

 MOVE.W RbX,D0
 MOVE.W RbY,D1                   ;neuen Punkt setzen
 MOVE.L RP,A1
 LINKSYS WritePixel,GfxBase

WAB:
 MOVE.L Speed,D1                 ;Verzögerung
 LINKSYS Delay,DosBase

 MOVEM.W (SP)+,D4-D7

 BRA Hauptschleife               ;und zum Anfang

ENDE1:
 ADD.W #4,SP                     ;Stack korrigieren
 MOVE.L Window,A0                ;Spieler 1 Kollidiert
 SUB.L A1,A1
 LEA P1Title,A2                  ;Meldung ausgeben
 LINKSYS SetWindowTitles,IntuitionBase
 TST.W Joy2Flag
 BEQ DD3                         ;und entsprechend der

 BSR ADD2                        ;Einstellung neuen Punktestand

DD3:
 TST.W RobFlag                   ;setzen
 BEQ CLW

 BSR ADD3
 BRA CLW

ENDE2:
 ADD.W #4,SP
 MOVE.L Window,A0                ;Ende bei Spieler 2
 SUB.L A1,A1
 LEA P2Title,A2                  ;Meldung
 LINKSYS SetWindowTitles,IntuitionBase
 BSR ADD1

 TST.W RobFlag
 BEQ CLW                         ;und Punktestand

 BSR ADD3
 BRA CLW

ENDE3:
 ADD.W #4,SP
 MOVE.L Window,A0                ;und nochmal für Robbi
 SUB.L A1,A1
 LEA P3Title,A2
 LINKSYS SetWindowTitles,IntuitionBase
 BSR ADD1

 TST.W Joy2Flag
 BEQ CLW

 BSR ADD2

CLW:
 CMP.B #117,$BFEC01              ;ESC gedrückt, dann Ende
 BEQ ENDE_SPIEL                  ;des Spiels
 CMP.B #115,$BFEC01              ;DEL, neues Spiel
 BEQ NG
 MOVE.B $BFE001,D0               ;Feuerknopf in Port 2
 TST.B D0                        ;gedrückt, dann neues Spiel
 BPL NG
 LSL.B #1,D0                     ;oder Feuerknopf in Port 1
 TST.B D0
 BPL NG                          ;dann auch neues Spiel
 CMP.B #65,$BFEC01               ;HELP, dann Parameter einstellen
 BNE CLW

 BSR Parameter

 LEA ScrTitle1,A0                ;Spielstände wieder auf Null setzen
 MOVE.L #'0000',14(A0)
 MOVE.L #'0000',22(A0)
 MOVE.L #'0000',30(A0)

 LEA ScrTitle2,A0
 MOVE.L #'0000',14(A0)
 MOVE.L #'0000',22(A0)

 LEA ScrTitle3,A0
 MOVE.L #'0000',14(A0)
 MOVE.L #'0000',30(A0)

NG:
 MOVE.L RP,A1                    ;Window löschen
 LINKSYS ClearScreen,GfxBase
 MOVE.L RP,A1
 BSR Rahmen                      ;Rahmen zeichnen
 BRA Neues_Spiel                 ;und von vorne anfangen

ENDE_SPIEL:
 MOVE.L Window,A0                ;Window schließen
 LINKSYS CloseWindow,IntuitionBase

EX:
 MOVE.L Screen,A0                ;Screen schließen
 LINKSYS CLoseScreen,IntuitionBase

EXIT:

;Libraries schließen

 MOVE.L IntuitionBase,D0         ;Intuitionlib
 BEQ.S No_Lib
 MOVE.L D0,A1
 CALLSYS CloseLibrary
 MOVE.L GfxBase,D0               ;Graphicslib
 BEQ.S No_Lib
 MOVE.L D0,A1
 CALLSYS CloseLibrary
 MOVE.L DosBase,D0               ;Doslib
 BEQ.S No_Lib
 MOVE.L D0,A1
 CALLSYS CloseLibrary
No_Lib:
 EXIT_AMIGA

Rahmen:
 MOVEQ.L #2,D0                   ;Rahmenfarbe
 LINKSYS SetAPen,GfxBase

 MOVE.L RP,A1                    ;linker oberer Punkt
 CLR.L D0
 MOVE.L #12,D1
 LINKSYS Move,GfxBase

 MOVE.L RP,A1                    ;von dort eine Linie zum
 CLR.L D0                        ;linken unteren Rahmenpunkt
 MOVE.L #255,D1
 LINKSYS Draw,GfxBase

 MOVE.L RP,A1
 MOVE.L #319,D0                  ;zur rechten unteren Ecke
 MOVE.L #255,D1
 LINKSYS Draw,GfxBase

 MOVE.L RP,A1
 MOVE.L #319,D0                  ;zur rechten oberen Ecke
 MOVE.L #12,D1
 LINKSYS Draw,GfxBase

 MOVE.L RP,A1
 CLR.L D0                        ;und zum Ausgangspunkt zurück
 MOVE.L #12,D1
 LINKSYS Draw,GfxBase

 RTS

ADD1:
 TST.W RobFlag                   ;Spielstand für Spieler 1
 BEQ J2F                         ;erhöhen und entsprechend

 TST.W Joy2Flag                  ;der Einstellung
 BEQ RJ1
 LEA ScrTitle1,A0                ;Titelzeile aussuchen
 BRA DD_1

RJ1:
 LEA ScrTitle2,A0
 BRA DD_1

J2F:
 LEA ScrTitle3,A0

DD_1:
 MOVE.L 22(A0),D0
 BSR ADDo
 MOVE.L D0,22(A0)
 RTS

ADD2:
 TST.W RobFlag                   ;wie für Spieler 1
 BEQ J2J1
 LEA ScrTitle1,A0
 BRA DD_2

J2J1:
 LEA ScrTitle3,A0

DD_2:
 MOVE.L 30(A0),D0
 BSR ADDo
 MOVE.L D0,30(A0)
 RTS

ADD3:
 TST.W Joy2Flag                  ;und noch einmal
 BEQ J1Rb
 LEA ScrTitle1,A0
 BRA DD_3

J1Rb:
 LEA ScrTitle2,A0

DD_3:
 MOVE.L 14(A0),D0
 BSR ADDo
 MOVE.L D0,14(A0)
 RTS


ADDo:
 ADDQ.L #1,D0                    ;Einerstelle um eins erhöhen
 CMP.B #$3A,D0
 BEQ ADDo_1
 RTS

ADDo_1:
 MOVE.B #$30,D0                  ;wenn nötig, Zehnerstelle
 MOVE.L D0,D1                    ;erhöhen, und Einerstelle auf
 LSR.L #8,D1                     ;Null setzen
 ADD.B #1,D1
 CMP.B #$3A,D1
 BEQ ADDo_2
 ADD.L #$100,D0
 RTS

ADDo_2:
 SUB.L #$900,D0                  ;Zehnerstelle auf Null setzen
 LSR.L #8,D1
 ADD.B #1,D1                     ;und Hunderterstelle um eins
 CMP.B #$3A,D1                   
 BEQ ADDo_3                      ;erhöhen
 ADD.L #$10000,D0
 RTS

ADDo_3:
 SUB.L #$90000,D0                ;Hunderterstelle auf Null setzen
 LSR.L #8,D1
 ADD.B #1,D1                     ;und Tausenderstelle erhöhen
 CMP.B #$3A,D1                   ;>9999, dann auf 0000 setzen
 SUB.L #$9000000,D0
 RTS
 ADD.L #$1000000,D0
 RTS

Abs_Ende:
 CMP.B #117,$BFEC01
 BEQ ENDE_SPIEL
 MOVE.L (SP)+,D0
 BRA Abs_Ende

Random:
 MOVE.L DosBase,A0               ;Zufallszahl aus Datestamp
 ADD.L #$22,A0
 MOVE.L (A0),A0                  ;der Doslib holen
 ADD.L #$13,A0
 MOVE.B (A0),D0
 LSL.B #6,D0                     ;Bit 1 der Zahl der Ticks
 LSR.B #7,D0                     ;nach D0
 RTS

Parameter:                       ;Parameter einstellen
 MOVE.L Window,A0
 LEA Frage,A1                    ;Frage nach der Geschwindigkeit
 LEA R,A2
 LEA L,A3
 MOVE.L #0,D0                    ;als Autorequester
 MOVE.L #0,D1
 MOVE.L #200,D2
 MOVE.L #70,D3
 LINKSYS AutoRequest,IntuitionBase
 MOVE.L D0,Speed

 MOVE.L Window,A0
 LEA Frage1,A1                   ;Tastatur oder Joystick
 LEA R1,A2
 LEA L1,A3                       ;für Spieler 1
 MOVE.L #0,D0
 MOVE.L #0,D1
 MOVE.L #200,D2
 MOVE.L #70,D3
 LINKSYS AutoRequest,IntuitionBase
 MOVE.W D0,KeyFlag

 MOVE.L Window,A0
 LEA Frage2,A1                   ;spielt Spieler 2 mit ?
 LEA R2,A2
 LEA L2,A3
 MOVE.L #0,D0
 MOVE.L #0,D1
 MOVE.L #200,D2
 MOVE.L #70,D3
 LINKSYS AutoRequest,IntuitionBase
 MOVE.W D0,Joy2Flag

 TST.W D0
 BNE RoboTest                    ;nein, dann muß Robbi
 MOVE.W #1,RobFlag               ;gegen Spieler 1 spielen
 RTS

RoboTest:
 MOVE.L Window,A0
 LEA Frage3,A1                   ;spielt Robbi mit, wenn
 LEA R3,A2
 LEA L3,A3                       ;auch Spieler 2 dabei ist ?
 MOVE.L #0,D0
 MOVE.L #0,D1
 MOVE.L #200,D2
 MOVE.L #70,D3
 LINKSYS AutoRequest,IntuitionBase
 MOVE.W D0,RobFlag

 RTS

 ALIGN
 DATA
IntuitionName:  DC.B 'intuition.library',0
GfxName:        DC.B 'graphics.library',0

 ALIGN
DosName:        DC.B 'dos.library',0

 ALIGN
ScrDef:
 DC.W    0,0,320,256,2
 DC.B    3,1
 DC.W    2,15
 DC.L    0,ScrName,0,0

ScrName: DC.B 'Sticks einstöpseln & <DEL> drücken',0

 ALIGN

WinDef:
 DC.W 0,0,320,256
 DC.B 0,1
 DC.L 0,$1900,0,0,WName
Screen: DC.L 0
 DC.L 0
 DC.W 320,256,320,256,15

WName: DC.B 'TinyCycle V4.41',0

 ALIGN
ScrTitle1: DC.B 'TinyCycle Rob:0000 S1:0000 S2:0000',0

 ALIGN
ScrTitle2: DC.B 'TinyCycle Rob:0000 S1:0000',0

 ALIGN
ScrTitle3: DC.B 'TinyCycle          S1:0000 S2:0000',0

 ALIGN
P1Title:   DC.B 'Spieler 1 hat verloren',0

 ALIGN
P2Title:   DC.B 'Spieler 2 hat verloren',0

 ALIGN
P3Title:   DC.B 'Robo-Driver hat verloren',0

 ALIGN
X1: DC.W 1
Y1: DC.W 0
X2: DC.W -1
Y2: DC.W 0
RX: DC.W 0
RY: DC.W -1

 ALIGN
MouseData:      DC.L 0
                DC.L 0,0,0,0,0,0
                DC.L 0,0,0,0,0,0
                DC.L 0,0,0,0,0,0
                DC.L 0,0,0,0,0,0
                DC.L 0,0,0,0,0,0
                DC.L 0

 ALIGN
Frage:     DC.B 0,1,0,0
           DC.W 20,15
           DC.L 0,Txt,0
Txt: DC.B 'Geschwindigkeit',0

 ALIGN
R: DC.B 0,1,0,0
    DC.W 5,3
    DC.L 0,RText,0
RText: DC.B 'Normal',0

 ALIGN
L:    DC.B 0,1,0,0
      DC.W 5,3
      DC.L 0,LText,0
LText: DC.B 'Horror',0

 ALIGN
Frage1:    DC.B 0,1,0,0
           DC.W 20,15
           DC.L 0,Text1,0
Text1: DC.B 'Spieler 1 mit:',0

 ALIGN
R1: DC.B 0,1,0,0
    DC.W 5,3
    DC.L 0,R1Text,0
R1Text: DC.B 'Tastatur',0

 ALIGN
L1:   DC.B 0,1,0,0
      DC.W 5,3
      DC.L 0,L1Text,0
L1Text: DC.B 'Joystick',0

 ALIGN
Frage2:    DC.B 0,1,0,0
           DC.W 20,15
           DC.L 0,Text2,0
Text2: DC.B 'Spieler 2 ?',0

 ALIGN
R2: DC.B 0,1,0,0
    DC.W 5,3
    DC.L 0,R2Text,0
R2Text: DC.B ' Ja ',0

 ALIGN
L2:   DC.B 0,1,0,0
      DC.W 5,3
      DC.L 0,L2Text,0
L2Text: DC.B 'Nein',0

 ALIGN
Frage3:    DC.B 0,1,0,0
           DC.W 20,15
           DC.L 0,Text3,0
Text3: DC.B 'Robo-Driver ?',0

 ALIGN
R3: DC.B 0,1,0,0
    DC.W 5,3
    DC.L 0,R3Text,0
R3Text: DC.B ' Ja ',0

 ALIGN
L3:   DC.B 0,1,0,0
      DC.W 5,3
      DC.L 0,L3Text,0
L3Text: DC.B 'Nein',0


 ALIGN

KeyFlag:       DC.W 1
Joy2Flag:      DC.W 0
RobFlag:       DC.W 1
Speed:         DC.L 1

 BSS
IntuitionBase: DS.L 1
GfxBase:       DS.L 1
Window:        DS.L 1
RP:            DS.L 1
VP:            DS.L 1
DosBase:       DS.L 1
J1X:           DS.W 1
J1Y:           DS.W 1
J2X:           DS.W 1
J2Y:           DS.W 1
RbX:           DS.W 1
RbY:           DS.W 1
Zlr:           DS.W 1

 END
