title	The Game of Piranha
	name	('PIRANHA')
	include	solvdm.lib

	extrn	SOLon,CONsta,CONin,CONout,gotoxy

; ########################################################
; # Angepasst an den JOYCE, Werner Cirsovius, Maerz 2002 #
; ########################################################
;
;;SOL	equ	true		; Originaltasten
SOL	equ	false		; Angepasste Tasten
;
;;SOLesc	equ	true	; Umbelegung Tasten moeglich
SOLesc	equ	false		; Umbelegung Tasten unmoeglich
;
IF	SOL
;
; Originalzeichen
;
_UL	equ	'Y'
_UP	equ	'U'
_UR	equ	'I'
_LT	equ	'H'
_RG	equ	'K'
_DL	equ	'N'
_DW	equ	'J'
_DR	equ	','
;
ELSE
;
; Zeichen fuer Steuerung kompatibel zu CHASE
;
_UL	equ	'T'
_UP	equ	'Z'
_UR	equ	'U'
_LT	equ	'G'
_RG	equ	'J'
_DL	equ	'B'
_DW	equ	'N'
_DR	equ	'M'
;
ENDIF
;
marked	equ	'X'
dead	equ	'O'
victim	equ	'P'
ftrk	equ	'I'
notrk	equ	'A'

frate	equ	4
mrate	equ	1
one	equ	1

vmaxs	equ	23
vfast	equ	7
subl	equ	-maxcol

vsym	equ	_bel		; Spieler
fish	equ	'*'		; Piranha
boom	equ	'+'

blank	equ	' '
zero	equ	'0'
bin0	equ	0
border	equ	' '+MSB

maxfish equ	(maxrow+maxcol)/3

vlin0a	equ	SOLvid+1
vlin0e	equ	SOLvid+maxcol-2
vlin1	equ	SOLvid+maxcol
vlin14	equ	SOLvid+13*maxcol
vlin15	equ	SOLvid+14*maxcol
vlin161	equ	VidTop+15*maxcol+6
vlin162	equ	VidTop+15*maxcol+16
vlin163	equ	VidTop+15*maxcol+39
vlin164	equ	VidTop+15*maxcol+49
vlin165	equ	VidTop+15*maxcol+51
vlin166	equ	VidTop+15*maxcol+52

rcorn1	equ	 18*256+22
rcorn2	equ	 19*256+24
rcorn3	equ	 20*256+22
rcorn4	equ	 21*256+24
rcorn5	equ	 22*256+22
rcorn6	equ	 23*256+16
rcorn7	equ	 24*256+16
;
;
;
	ld	sp,stack	; Stack initialisieren
	call	SOLon		; SOL einschalten
	call	randomize	; Zufallszahl initiieren
;
; Neustart
;
restart:
	ld	sp,stack	; Stack initialisieren
	call	setup		; Spielfeld vorbereiten
	call	rose		; Hilfstext ausgeben
;
; #################
; # Hauptschleife #
; #################
;
mainlp:
	ld	hl,vtabl	; Kontrolltabelle laden
	inc	hl
	ld	a,(hl)		; Wert holen
	cp	dead		; Testen
	jr	z,mp1
	push	hl
	call	addscr
	ld	a,(scrflg)
	or	a
	call	p,vmove
	pop	hl
mp1:
	call	user		; Benutzer abfragen
	call	bigctr		; Zaehler erhoehen
	call	newfish		; Neuen Fisch eintragen
	ld	hl,vtabl	; Kontrolltabelle laden
	ld	b,maxfish+1	; .. Laenge
fishes:
	push	bc
	push	hl
	call	fishy
	pop	hl
	call	bump6		; .. naechster Eintrag
	pop	bc
	djnz	fishes
	jr	mainlp
;
; Meldung und Stand von Phase im Akku ausgeben
;
setpha:
	ld	hl,vlin161
	ld	c,a
	ld	de,phamsg
	ld	b,phamln
movpha:
	ld	a,(de)		; Meldung 'Phase' ausgeben
	ld_hl_a
	inc	de
	inc	hl
	djnz	movpha
	ld	a,c
	add	a,zero		; Phasewert berechnen
	ld_@_a	vlin162
;;	sub	zero
	ld	a,c
;;		
	rlca			; *2
	rlca			; *4
	rlca			; *8
	ld	d,0
	ld	e,a
	ld	hl,(ctlptr)	; Kontrollfeld fuer Phase
	add	hl,de		; .. positionieren
	ld	de,lnewf
	ld	b,lnewln
trpha:
	ld	a,(hl)		; Kontrollfeld umpacken
	ld	(de),a
	inc	hl
	inc	de
	djnz	trpha
	xor	a
	ld	(bigtwo),a
	ret
;
; Piranha stoppen fuer neuen Phasewert
;
stop:
	pop	hl
;
; Neuen Phasewert einlesen
;
getpha:
	call	CONin		; Wert lesen
	cp	'0'		; .. Bereich testen
	ret	c
	cp	'9'
	ret	nc
	sub	'0'
	ld	(phase),a	; .. und setzen
	call	setpha		; Phase ausgeben
	ret
;
;
;
addscr:
	ld	a,(phase)	; Phasewert laden
	inc	a
	ld	b,a
	ld	hl,vlin166	; Videozeiger laden
morscr:
	call	scorit		; Wert erhoehen
	djnz	morscr
	ld	hl,vpos
	ld	d,(hl)		; Videoadresse laden
	inc	hl
	ld	e,(hl)
	call	convert		; Koordinaten ermitteln
	ld	a,(goodcal)
	cp	d		; Spalte testen
	jr	nz,chkbmp
	cp	one
	jr	nz,leftcol
	ld	a,maxcol-2
	jr	setcol
leftcol:
	ld	a,one
setcol:
	ld	(goodcal),a
	ld	a,(lbonus)
	ld	b,a
givbon:
	ld	hl,vlin166	; Videozeiger laden
	call	ascbmp
	djnz	givbon
chkbmp:
	ld	a,(bigtwo)
	cp	20		;;14h
	ret	nz
;;	jp	bmtpha
;
;
;
bmtpha:
	ld	a,(phase)
	cp	phasct-1	;;9
	ret	z
	inc	a
	ld	(phase),a
	call	setpha		; Phase ausgeben
	ret
;
;
;
scorit:
	ld	a,(scrctr)
	inc	a
	ld	(scrctr),a
	sub	45		;;2dh
	ret	nz
	ld	(scrctr),a
ascbmp:
	ld_a_hl
	cp	blank
	jr	nz,gotdig
	ld_hl_8	zero+1
	ret
gotdig:
	cp	zero+9
	jr	nz,not9
	ld_hl_8	zero
	dec	hl
	jr	ascbmp
not9:
	inc	a
	ld_hl_a
	ret
;
;
;
scrctr:
	db	3		;;inc	bc
;
ascdec:
	ld_a_hl
	cp	blank
	jr	z,cntdec
	cp	zero
	jr	nz,notzero
	ld_hl_8	zero+9
	dec	hl
	jr	ascdec
notzero:
	dec	a
	ld_hl_a
	cp	zero
	ret	nz
	dec	hl
	ld_a_hl
	cp	blank
	ld	a,blank
	ret	nz
	inc	hl
	ld_hl_a
	ret
cntdec:
	ld	a,true
	ld	(scrflg),a
	ret
;
; Zaehler erhoehen
;
bigctr:
	ld	hl,bigone	; Zaehler laden
	inc	(hl)		; .. einfaches Zaehlen
	ret	nz		; Uebertrag nicht vergessen
	inc	hl
	inc	(hl)
	ret	nz
	inc	hl
	inc	(hl)
	ret	nz
	inc	hl
	inc	(hl)
	ret
;
; Neuen Fisch eintragen
;
newfish:
	ld	a,(lnewf)
	call	random
	cp	one
	ret	nz
	ld	a,frate
	call	random
	cp	0
	ret	nz
	call	alive		; Test ob Fisch noch frei
	ld	a,h
	or	a
	jr	nz,gotfish	; .. ja
	ld	a,l
	or	a
	ret	z		; Alles belegt
gotfish:
	ld	(hl),one	; Wert setzen
	inc	hl
	ld	a,100
	call	random
	ld	b,a
	ld	a,(ltrack)
	cp	b
	jr	nc,dotrack
	ld	(hl),notrk	; Status setzen
	jr	notrack
dotrack:
	ld	(hl),ftrk
notrack:
	inc	hl
	ld	a,(lsrng)
	call	random
	ld	b,a
	ld	a,(lmins)
	add	a,b
	ld	(hl),a		; Geschwindigkeit eintragen
	dec	hl
	dec	hl
	ld	a,(hl)
	call	bump3
	push	hl
	ld	a,(lside)
	call	random
	cp	3
	jr	z,brnlft
	cp	2
	jr	z,brnrht
	cp	one
	jr	z,brntop
	ld	b,subl		; Werte setzen
	ld	a,maxcol-2
	ld	hl,vlin14	; .. Videoadresse
	ld	de,1
	jr	fborn
brntop:
	ld	b,maxcol
	ld	a,maxcol-2
	ld	hl,vlin1
	ld	de,1
	jr	fborn
brnrht:
	ld	b,-1
	ld	a,maxrow-3
	ld	hl,vlin0e
	ld	de,maxcol
	jr	fborn
brnlft:
	ld	b,one
	ld	a,maxrow-3
	ld	hl,vlin0a
	ld	de,maxcol
fborn:
	call	random
	inc	a
moveit:
	add	hl,de
	dec	a
	jr	nz,moveit
	ex	de,hl
	pop	hl
	ld_a_de
	cp	blank
	jr	z,setfish
	dec	hl
	dec	hl
	ld	(hl),dead
	ret
setfish:
	ld	(hl),b
	inc	hl
	ld	(hl),d
	inc	hl
	ld	(hl),e
	ld	a,fish
	ld_de_a
	ret
;
; Zufallszahl erzeugen
; EIN	Akku haelt maximale Zahle
; AUS	Akku haelt Zufallszahl
;
random:
	push	bc
	push	hl
	ld	b,a		; Maximale Zahl retten
rand1:
	ld	hl,(rptr)	; Zufallszahl holen
	ld	c,8		; Laenge laden
rand3:
	ld	a,h		; Zahl erzeugen
	rrca
	xor	h
	rrca
	rrca
	xor	h
	rrca
	xor	l
	rrca
	rrca
	rrca
	xor	1
	and	1
	add	hl,hl
	add	a,l
	ld	l,a
	dec	c
	jr	nz,rand3
;;rand:
	ld	(rptr),hl	; Neue Zahl ablegen
	ld	a,h
	add	a,l
	ld	h,a
	ld	a,b		; Maximale Zahl holen
rand2:
	ld	l,a
	add	a,b
	cp	b
	jr	nc,rand2
	ld	a,h
	cp	l
	jr	nc,rand1
tops:
	cp	b		; Test ob im maximalen Bereich
	jr	c,gotnum
	sub	b		; .. auf Maximum beschraenken
	jr	tops
gotnum:
	pop	hl
	pop	bc
	ret
;
; Zufallszahl initiieren
;
randomize:
        ld      a,r             ; Refresh Counter
        ld      (rptr),a 	; .. fuer Zahl
	nop
	nop
	nop
        ld      a,r
        ld      (rptr+1),a
	ret
;
; Zeicheneingabe und Kommandoausfuehrung
;
user:
	call	CONsta		; Test Status
	ret	z		; .. keine Taste
	call	CONin		; Zeichen lesen
	dec	hl		; Zeiger setzen
	ld	(hl),one
	call	bump3
	push	hl
	ld	hl,chars	; Zeichentabelle laden
	ld	b,charl		; .. Laenge
comp:
	cp	(hl)		; Zeichen vergleichen
	jr	z,found		; .. gefunden
	inc	hl
	djnz	comp
;;return:
	pop	hl
	ret
found:
	ld	a,charl
	sub	b		; Zeiger berechnen
	and	0feh		; .. gerader Index
	ld	e,a
	ld	d,0
	ld	hl,jumps
	add	hl,de		; Adresse in Tabelle
	ld	e,(hl)		; Adresse holen
	inc	hl
	ld	d,(hl)
	ex	de,hl
	jp	(hl)		; .. ausfuehren
;
; Tastaturbewegungen
; ==================
;
up:
	ld	a,subl
	jr	movhim
right:
	ld	a,one
	jr	movhim
down:
	ld	a,maxcol
	jr	movhim
left:
	ld	a,-one
	jr	movhim
ul:
	ld	a,subl-1
	jr	movhim
ur:
	ld	a,subl+1
	jr	movhim
lr:
	ld	a,maxcol+1
	jr	movhim
ll:
	ld	a,maxcol-1
movhim:
	pop	hl
	cp	(hl)		; Test ob gleicher Wert zuvor
	jr	z,sdirec
	ld	(hl),a		; Neuen Wert setzen
	dec	hl
	ld	(hl),vmaxs
	ret
sdirec:
	dec	hl
	ld	(hl),vfast
	ret
;
; Piranha anhalten
;
halt:
	pop	hl
	ld	(hl),null	; Wert setzen
	ret
;
; Piranha automatisch
;
auto:
	pop	hl
	ld	a,(scrflg)
	cpl
	ld	(scrflg),a
	ret
;
IF	SOLesc
;
; ESCape betaetigt: Eingabe neuer Bewegungstasten
;
escp:
	ld	bc,chargo	; Kommandofeld laden
	ld	de,string	; .. Meldung laden
	ld	hl,SOLvid	; .. Video-Adresse laden
esc1:
	ld	a,(de)		; Zeichen holen
	inc	de
	cp	eot		; Test ob Ende
	jp	z,restart
	ld_hl_a			; Zeichen anzeigen
	inc	hl
	cp	'-'		; Test ob Eingabe erforderlich
	jr	nz,esc1
	call	get		; Neue Taste holen
	ld_hl_8	blank		; Zeichen loeschen
	inc	hl
	jr	esc1
;
; Neue Tastenbelegung laden
;
get:
	call	CONin		; Zeichen lesen
	cp	esc		; Test ob Abbruch
	jp	z,restart
	ld	(bc),a		; Zeichen ablegen
	inc	bc
	inc	bc
	ld_hl_a			; .. und anzeigen
	inc	hl
	ret
ENDIF
;
;
;
vmove:
	ld	hl,vtabl	; Kontrolltabelle laden
	ld	a,(hl)
	cp	one
	ret	nz
	ld_a_@	vlin164
	cp	blank
	ret	z
	ld	hl,vlin166	; Videozeiger laden
	call	ascdec
	ld	hl,vpos
	ld	b,(hl)		; Videoadresse laden
	inc	hl
	ld	c,(hl)
	call	nbr1
	ld	d,a
	dec	hl
	dec	hl
	ld	a,(hl)
	or	a
	jr	nz,moving
	ld	a,(goodcal)
	cp	one
	ld	a,-1
	jr	z,equal1
	ld	a,one
equal1:
	ld	(hl),a
moving:
	call	nbr3
	ld	e,a
	rla
	add	a,e
	ld	e,a
	rrca
	or	e
	ld	e,a
	and	d
	or	a
	ret	z
	ld	b,7
	ld	a,(rotate)
	xor	00001000b	;;8
	ld	(rotate),a
way3:
	ld	a,e
rotate:
	rlca
	ld	e,a
	and	d
	or	a
	jr	z,gotway
	djnz	way3
	ld	a,e
	rlca
	rlca
	and	e
	ld	e,a
	ld	b,8
way1:
	ld	a,e
	rrca
	ld	e,a
	and	d
	or	a
	jr	z,findirec
	djnz	way1
	ld	(hl),0
	ret
gotway:
	ld	a,e
	rlca
	ld	e,a
	rrca
	rrca
	and	e
findirec:
	call	nbr2
	ld	(hl),a
	ld	b,7
subloop:
	ld	hl,vlin165
	call	ascdec
	djnz	subloop
	ret
;
; EIN	Register BC haelt Videoadresse
; AUS	Akku haelt ????
;
nbr1:
	push	hl
	ld	hl,nbtb2	; Tabelle laden
	xor	a
	ld	(count),a	; Zaehler initialisieren
	ld	a,ntbl/3	;;8
loop1:
	ld	(lctr),a
	ld	a,(hl)		; Wert laden
	or	a		; Vorzeichen testen
	ld	e,a
	ld	d,0		; Auf 16 Bit expandieren
	jp	p,fwd
	ld	d,-1
fwd:
	ex	de,hl
	add	hl,bc		; Adresse positionieren
;;	ld	a,(hl)
	ld_a_hl			; Belegung holen
	ex	de,hl
	inc	hl
	cp	blank		; Test ob leer
	jr	z,nonbr
	cp	border		; Test Rahmen
	jr	z,nonbr
	ld	d,(hl)		; Wert laden
	ld	a,(count)
	add	a,d		; .. zu Zaehler addieren
	ld	(count),a
nonbr:
	inc	hl
	inc	hl
	ld	a,(lctr)
	dec	a
	jr	nz,loop1
	ld	a,(count)	; Ergebnis laden
	pop	hl
	ret
;
; EIN	Akku haelt ???
; AUS	Akku haelt ???
;
nbr2:
	push	hl
	ld	hl,nbtb1	; Tabelle laden
	jr	nxtent
nbr3:
	push	hl
	ld	hl,nbtb2	; Tabelle laden
nxtent:
	cp	(hl)		; Wert vergleichen
	jr	z,findent
	call	bump3
	jr	nxtent
findent:
	inc	hl
	ld	a,(hl)		; Ergebnis holen
	pop	hl
	ret
;
;
;
fishy:
	dec	(hl)		; Runterzaehlen
	ret	nz
	ld	a,mrate
	call	random		; 0 oder 1 erzeugen
	cp	0
	ret	nz		; .. Ende bei 1
	inc	hl
	ld	a,(hl)		; Eintrag testen
	cp	dead
	ret	z		; .. schon 'tot'
	cp	marked
	jp	z,die		; Jetzt 'toeten'
	push	hl
	cp	ftrk
	call	z,track
	pop	hl
	inc	hl
	ld	a,(hl)		; Originalwert laden
	dec	hl
	dec	hl
	ld	(hl),a		; .. einsetzen
	call	bump3
	ld	d,0
	ld	e,(hl)		; Richtungsbyte laden
	ld	a,e
	or	a
	ret	z		; .. 0 ignorieren
	or	a
	jp	p,frward
	ld	d,-1		; 16 Bit-Richtung
frward:
	inc	hl
	ld	b,(hl)		; Videoadresse laden
	inc	hl
	ld	c,(hl)
;;	ld	a,(bc)
	ld_a_bc			; Spielstein laden
	cp	blank		; Test ob leer
	jr	nz,mover
	call	dec4
	ld	(hl),dead	; .. 'toeten' falls nicht
	ret
mover:
	push	hl
	ld	h,b		; Videoadresse kopieren
	ld	l,c
	add	hl,de		; Richtung aendern
	ex	de,hl
	pop	hl
;;	ld	a,(de)
	ld_a_de
	cp	border		; Test Rahmen
	jp	z,hitbor	; .. ja
	cp	blank		; Test leer
	jp	nz,bang4	; .. nein
	dec	hl
	ld	(hl),d		; Adresse retten
	inc	hl
	ld	(hl),e
;;	ld	a,(bc)
	ld_a_bc			; Alten Spielstein
;;	ld	(de),a
	ld_de_a			; .. in neuen Platz
	ld	a,blank
;;	ld	(bc),a
	ld_bc_a			; Alten Platz loeschen
	ret
;
; Videoadresse in Koordinaten wandeln
; EIN	Register DE haelt Videoadresse
; AUS	Register D haelt Spalte, Register E haelt Zeile
;	(Obere Zeile entspricht dem Wert 15)
;
convert:
	push	bc
	ld	hl,-SOLvid
	add	hl,de		; Basisadresse abziehen
	ld	de,-maxcol
	ld	b,maxrow	; Zeilenzahl initialisieren
fineg:
	add	hl,de		; Wert durch 64 teilen
	dec	b		; .. Zeile fixieren
	ld	a,h
	or	a		; Test ob fertig
	jp	p,fineg		; .. weiter dividieren
	ld	e,b		; Zeile laden
	ld	a,l
	add	a,maxcol	; Spalte fixieren
	ld	d,a
	pop	bc
	ret
;
;
;
track:
	ld	a,100
	call	random
	ld	b,a
	ld	a,(lstrk)
	cp	b
	ret	c
	call	bump3
	push	hl
	ld	d,(hl)		; Videoadresse laden
	inc	hl
	ld	e,(hl)
	call	convert		; .. in Koordinaten wandeln
	ld	b,d		; .. Spalte
	ld	c,e		; .. Zeile
;;;
;;	ld	a,(vpos)
;;	ld	d,a
;;	ld	a,(vpos+1)
;;	ld	e,a
	ld	de,(vpos)	; Videoadresse laden
;;
	call	convert		; .. in Koordinaten wandeln
	ld	a,b		; Spalte testen
	sub	d
	ld	d,a
	cp	2*maxcol-1	;;7fh
	jr	c,pos1
	cpl
pos1:
	ld	b,a
	ld	a,c		; .. Zeile testen
	sub	e
	ld	e,a
	or	a
	jp	p,pos2
	cpl
pos2:
	cp	b
	jr	c,trklin
	ld	a,e
	or	a
	jp	m,moveup
	ld	a,maxcol
	jr	setdir
moveup:
	ld	a,subl
	jr	setdir
trklin:
	ld	a,d
	or	a
	jp	p,movelft
	ld	a,one
	jr	setdir
movelft:
	ld	a,-1
setdir:
	pop	hl
	dec	hl
	ld	b,a
	ld	a,(hl)
	cp	b
	ret	z
	cpl
	cp	b
	jr	z,oppos
	ld	(hl),b
	ret
oppos:
	cp	subl
	jr	z,movrht
	cp	maxcol
	jr	z,movrht
	ld	(hl),maxcol
	ret
movrht:
	ld	(hl),one
	ret
;
; Kante getroffen
;
hitbor:
	call	dec4
	ld	a,(hl)
	cp	victim
	jr	z,vhit
	dec	hl
	call	kill
	ret
vhit:
	xor	a
	inc	hl
	inc	hl
	ld	(hl),a
	ret
;
; Treffer anzeigen - d.h. vier Nachbarfelder
;
bang4:
	call	dec5
	call	kill
	call	find		; Videoadresse finden
	call	kill
	ld	hl,one
	add	hl,bc		; Umliegende Addressen belegen
	call	bang
	ld	hl,-1
	add	hl,bc
	call	bang
	ld	hl,maxcol
	add	hl,bc
	call	bang
	ld	hl,-maxcol
	add	hl,bc
	call	bang
	ret
;
; Treffer anzeigen
;
bang:
;;	ld	a,(hl)
	ld_a_hl
	cp	blank
	jr	z,empty
	cp	border		; Test Rahmen
	ret	z		; .. ignorieren
	cp	boom		; Test Zustand
	ret	z		; .. ignorieren
	push	hl
	push	bc
	ex	de,hl
	call	find		; Videoadresse finden
	call	kill
	pop	bc
	pop	hl
empty:
	ex	de,hl
	push	bc
	call	alive		; Freien Fisch finden
	pop	bc
	ld	a,(ltime)
	ld	(hl),a
	inc	hl
	ld	(hl),marked
	call	bump3
	ld	(hl),d		; Videoadresse speichern
	inc	hl
	ld	(hl),e
	ld	a,boom
;;	ld	(de),a
	ld_de_a
	ret
;
;
;
;;die:
;;	dec	hl
;;	call	kill
;;	ret
;
;
;
kill:
	inc	hl
die:
	ld	(hl),dead
	call	bump3
	ld	b,(hl)
	inc	hl
	ld	c,(hl)
	ld	a,blank
;;	ld	(bc),a
	ld_bc_a
	ret
;
; Freien Fisch finden
; AUS	Reg HL haelt Adresse oder 0
;
alive:
	ld	hl,ftabl+1	; Tabelle laden
	ld	b,maxfish	; .. Laenge
mordead:
	ld	a,(hl)		; Eintrag laden
	cp	dead		; Status testen
	jr	z,fndead
	call	bump6		; Auf naechsten Eintrag
	djnz	mordead
	ld	hl,one
fndead:
	dec	hl
	ret
;
; Videoadresse in Reg DE in Tabelle finden
;
find:
	ld	hl,vtabl	; Kontrolltabelle laden
	ld	b,maxfish+1
look:
	call	bump4		; Auf Videoadresse zeigen
	ld	a,(hl)
	inc	hl
	cp	d		; Test ob gleich
	jr	nz,nofind
	ld	a,(hl)
	cp	e
	jr	nz,nofind
	call	dec5		; Auf Anfang stellen wenn gefunden
	ret
nofind:
	inc	hl
	djnz	look
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
;;
;;	ld	hl,null		; .. keinen Eintrag gefunden
; Dies ist toedlich fuer das System (Ueberschreiben Adresse 0000)
; Deshalb hier Abbruch
;
	extrn	SOLoff

	call	SOLoff		; SOL ausschalten
	pop	de		; Aufrufer laden
	ld	hl,$$PC
	ld	a,d
	call	ascbyt		; .. PC wandeln
	ld	a,e
	call	ascbyt
	ld	de,$$MSS
	ld	c,9
	call	BDOS		; Fehler ausgeben
	jp	OS		; .. und abbrechen
;
ascbyt:
	push	af
	rrca			; .. obere Bits
	rrca
	rrca
	rrca
	call	ascnib		; Wandeln in Zeichen
	pop	af		; Dann niederwertige Bits
ascnib:
	and	LoMask		; Bits maskieren
	add	a,0f0h		; .. und wandeln
	daa
	adc	a,'0'+16
	daa
	ld	(hl),a		; .. speichern
	inc	hl
	ret
;
$$MSS:
	db	'Fehlerhafte Adresse in 0x'
$$PC:
	db	'xxxx - Abbruch',cr,lf,'$'
;;
;;	ret
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
;
; Spielfeld vorbereiten
;
setup:
;
; Teil 1: Spielfeld loeschen
;
	ld	hl,SOLvid	; Videoadresse laden
	ld	b,maxrow	; .. Anzahl Zeilen
blkch:
	ld	c,maxcol	; Anzahl Spalten	
blkeh:
	ld_hl_8	blank		; Leerzeichen ausgeben
	inc	hl
	dec	c
	jr	nz,blkeh
	djnz	blkch
;
; Teil 2: Rahmen oben und unten setzen
;
	ld	hl,SOLvid	; Adressen vorbereiten
	ld	de,vlin15
	ld	b,maxcol	; Anzahl Spalten
	ld	a,border	; Rahmen
setbor:
	ld_hl_a			; Rahmen oben setzen
	ld_de_a			; Rahmen unten setzen
	inc	hl
	inc	de
	djnz	setbor
;
; Teil 3: Rahmen links und rechts setzen
;
	ld	b,maxrow-2
	ld	de,vlin1	; Adresse links vorbereiten
nxtrow:
	ld_hl_a			; Rahmen links setzen
	ld	c,maxcol-1	; Anzahl Spalten
setside:
	inc	hl		; Zeiger auf rechte Seite
	dec	c
	jr	nz,setside
	ld_hl_a			; Rahmen rechts setzen
;;	ld	c,1
;;padside:
	inc	hl		; Zeiger weiter
;;	dec	c
;;	jr	nz,padside
;;
	djnz	nxtrow
;
; Zeiger initialisieren
;
	ld	hl,vtabl
	ld	(hl),vmaxs	; Tabelle initialisieren
	inc	hl
	ld	(hl),victim
	inc	hl
	ld	(hl),vmaxs
	inc	hl
	ld	(hl),0
	inc	hl
	ld	bc,SOLvid+maxcol*maxrow/2-maxcol+maxcol/2
	ld	(hl),b
	inc	hl
	ld	(hl),c
	ld	a,vsym
;;	ld	(bc),a
	ld_bc_a
;
; Fische initialisieren
;
	ld	b,maxfish
nofish:
	inc	hl
	inc	hl
	ld	(hl),dead	; Wert setzen
	call	bump4		; .. auf naechsten Eintrag
	djnz	nofish
;
; Spielstand initialisieren
;
	ld	hl,vlin163	; Adresse setzen
	ld	b,scrln		; .. Laenge
	ld	de,scrmsg	; .. Meldung
ptrscr:
	ld	a,(de)		; Meldung ausgeben
	ld_hl_a
	inc	de
	inc	hl
	djnz	ptrscr
	ld	a,true
	ld	(scrflg),a
	xor	a
	ld	(phase),a
	call	setpha		; Phase ausgeben
	call	getpha		; .. und Phase einlesen
	ret
;
; Routinen zum Erhoehen des Wertes in Register HL
;
bump6:
	inc	hl
	inc	hl
bump4:
	inc	hl
bump3:
	inc	hl
	inc	hl
	inc	hl
	ret
;
; Routinen zum Erniedrigen des Wertes in Register HL
;
dec5:
	dec	hl
dec4:
	dec	hl
dec3:
	dec	hl
	dec	hl
	dec	hl
	ret
;
; Hilfe aufbauen
;
rose:
	ld	iy,$HLP		; Adresse laden
	ld	b,Hlplen/Hlpitm	; .. Laenge
rosloop:
	ld	e,(iy+0)	; Koordinaten laden
	ld	d,(iy+1)
	ld	l,(iy+2)	; .. und Meldung
	ld	h,(iy+3)
	call	msgo		; Meldung ausgeben
	ld	de,Hlpitm
	add	iy,de
	djnz	rosloop
	ret
;
$HLP:
	dw	rcorn1,help1
Hlpitm	equ	$-$HLP
	dw	rcorn2,help2
	dw	rcorn3,help3
	dw	rcorn4,help4
	dw	rcorn5,help5
	dw	rcorn6,help6
	dw	rcorn7,help7
Hlplen	equ	$-$HLP
;
; Meldung fuer Hilfe ausgeben
;
; DIE ROUTINE ZEIGT HILFE AUSSERHALB DES VDM-BEREICHES
;
; EIN	Reg DE haelt Koordinaten, Reg HL zeigt auf Meldung
;
msgo:
	call	gotoxy		; Cursor setzen
strg:
	ld	a,(hl)
	cp	eot
	ret	z
	call	CONout		; .. Zeichen ausgeben
	inc	hl
	jr	strg
;
help1:
	db	_UL,'   ',_UP,'   ',_UR
	db	eot
help2:
	db	'\ ',_aru,' /'
	db	eot
help3:
	db	_LT,' ',_arl,'   ',_arr,' ',_RG
	db	eot
help4:
	db	'/ ',_ard,' \'
	db	eot
help5:
	db	_DL,'   ',_DW,'   ',_DR
	db	eot
help6:
	db	'S: Neustart -- " ": Anhalten'
	db	eot
help7:
	db	'P: Neue Phase -- A: Automatisch'
	db	eot
;
;
;
nbtb1:
	db	1
nbtb2:
	db	subl,    01h,02h
	db	subl+1,  02h,04h
	db	1,       04h,08h
	db	maxcol+1,08h,10h
	db	maxcol,  10h,20h
	db	maxcol-1,20h,40h
	db	-1,      40h,80h
	db	subl-1,  80h
ntbl	equ	$-nbtb1
lctr:
	db	8
count:
	db	0
rptr:
	db	0,0
bigone:
	db	0
bigtwo:
	db	0,0,0
scrmsg:
	db	'Stand       00      '
scrln	equ	$-scrmsg
phamsg:
	db	'Phase     '
phamln	equ	$-phamsg
scrflg:
	db	true
goodcal:
	db	maxcol-2
phase:
	db	0
;
lnewf:
	db	100	; \
lside:			; |
	db	1	; |
lmins:			; |
	db	20	; |
lsrng:			; |
	db	80	; |
ltime:			; |
	db	40	; |28h
ltrack:			; |
	db	1	; |
lstrk:			; |
	db	1	; |
lbonus:			; |
	db	0	; /
lnewln	equ	$-lnewf
;
ctlptr:
	dw	control
	db	22
;
; Kontrollfeld fuer 'lnewf' in Abhaengigkeit von dem Phasewert
;
control:
	db	40h,1,02h,60h,30h, 10, 1, 50	; Phase 0
	db	48h,1,26h,5ch,30h, 20, 4, 75	; Phase 1
	db	50h,1,24h,58h,2ch, 30, 7,100	; Phase 2
	db	58h,1,22h,54h,2ch, 40,10,125	; Phase 3
	db	60h,2,20h,50h,28h, 50,13,150	; Phase 4
	db	68h,2,1eh,4ch,28h, 60,16,175	; Phase 5
	db	70h,2,1ch,48h,24h, 70,19,200	; Phase 6
	db	78h,2,1ah,44h,24h, 80,22,225	; Phase 7
	db	80h,4,18h,40h,20h, 90,25,250	; Phase 8
	db	88h,4,16h,3ch,20h,100,28,255	; Phase 9
ctrlen	equ	$-control
phasct	equ	ctrlen/lnewln
;
;
;
;;***	org	800h

jumps:
;;	dw	SOLOS
IF	SOLesc
	dw	escp
ENDIF
	dw	restart
	dw	up
	dw	down
	dw	left
	dw	right
	dw	ul
	dw	ur
	dw	ll
	dw	lr
	dw	halt
	dw	stop
	dw	auto
;;	dw	return
;
; Zeichentabelle
;
chars:
;;	db	'C'-'@','C'-'@'	; Spielende
IF	SOLesc
	db	esc,esc		; Escape
ENDIF
chargo:
	db	'S',cr		; Neustart
	db	_UP,'8'		; Feld hoch
	db	_DW,'2'		; Feld runter
	db	_LT,'4'		; Feld links
	db	_RG,'6'		; Feld rechts
	db	_UL,'7'		; Feld links hoch
	db	_UR,'9'		; Feld rechts hoch
	db	_DL,'1'		; Feld links runter
	db	_DR,'3'		; Feld rechts runter
	db	' ','5'		; Anhalten
	db	'P','.'		; Neuer Phasewert
	db	'A','0'		; Automatisch
endch:
	db	-1
charl	equ	endch-chars
;
IF	SOLesc
string:
;;	db	' ENTER NEW VALUES FOR: GO-'
	db	' Eingabe neuer Werte f',_ue,'r: '
	db	'GO-'
	db	'U-'
	db	'D-'
	db	'L-'
	db	'R-'
	db	'UL-'
	db	'UR-'
	db	'LL-'
	db	'LR-'
	db	'H-'
	db	'P-'
	db	'A-'
	db	eot
ENDIF
;
vtabl:
	db	vmaxs				; \
	db	victim				; |
vspeed:						; |
	db	vmaxs				; |
vdirec:						; |
	db	0				; |
vpos:						; |
	dw	SOLvid+maxcol*(maxrow-1)/2	; |
tabitm	equ	$-vtabl				; |
;						; |
ftabl:						; |
	ds	maxfish*tabitm			; /
;
	ds	2*32
stack	equ	$

	end