;*************************************************************************
;	GPL3+
;	Copyright 2023 by Sean Conner.
;	Draws a maze on a Color Computer.
;
;NOTE:	This program has a bug for instructional purposes.  See
;	<https://boston.conman.org/2023/11/27.1>; for more information.
;*************************************************************************

		include	"Coco-DP.i"
		include	"Coco-video.i"

VIDEO		equ	$0E00

NORTH		equ	8
EAST		equ	4
WEST		equ	2
SOUTH		equ	1

EXPLORE		equ	2
BACKTRACK	equ	3
BG		equ	0

xpos		equ	U76	; these are unused locations
ypos		equ	U77	; in the direct page of the Coco
xstart		equ	UF4
ystart		equ	UF5
lfsr		equ	UF6
color		equ	UF7
rnd4.cache	equ	UF8
rnd4.cnt	equ	UF9

;*************************************************************************

		org	$4000

start		lda	$FF22		; set G1C mode-64x64 4-colors
		anda	#$07
		ora	#G1C.PIA
		sta	$FF22
		sta	$FFC4 + (G1C.MODE & 4 <> 0)
		sta	$FFC2 + (G1C.MODE & 2 <> 0)
		sta	$FFC0 + (G1C.MODE & 1 <> 0)

		ldx	#$FFD2		; point to frame buffer address bits
		lda	ECB.grpram	; get MSB of frame buffer
.mapframebuf	clrb			; isolate next bit of address
		lsla
		rolb
		sta	b,x		; inform hardware of bit value
		leax	-2,x		; point to next "bit address"
		cmpx	#$FFC4		; 7-bits of address required
		bne	.mapframebuf

.clear_screen	ldx	ECB.beggrp	; address of frame buffer
		clra
		clrb
.cls_loop	std	,x++		; clear frame buffer
		cmpx	ECB.endgrp	; are we done with the clearing?
		bne	.cls_loop	; keep going if not.

		ldd	#32 * 256 + 32	; starting position
		std	xpos
		std	xstart
.reseed		lda	$112		; read timer value
		beq	.reseed		; if zero, read again
		sta	lfsr		; seed our random number generator
		clr	rnd4.cnt	; and clear the rnd cache count

;*************************************************************************

explore		lda	#EXPLORE	; exploring free territory
		sta	color

.loop		bsr	boxed_in	; can we move?
		beq	backtrack	; if not, start backtracking
		lbsr	rnd4		; pick a random direction
		lslb
		leax	movetab,pc
		jsr	b,x		; call drawing function
		bra	.loop

;*************************************************************************

backtrack	lda	#BACKTRACK
		sta	color

.loop		ldd	xpos		; check to see if we're back
		cmpd	xstart		; at the starting point,
		beq	done		; and if so, we're done

		ldd	xpos		; can we backtrack NORTH?
		decb
		lbsr	getpixel
		cmpb	#EXPLORE
		bne	.check_east
		lbsr	move_north.now	; if so, move NORTH and see if
		bra	.probe		; we have to keep backtracking

.check_east	ldd	xpos		; east ...
		inca
		lbsr	getpixel
		cmpb	#EXPLORE
		bne	.check_west
		lbsr	move_east.now
		bra	.probe

.check_west	ldd	xpos		; yada yada ...
		deca
		lbsr	getpixel
		cmpb	#EXPLORE
		bne	.check_south
		lbsr	move_west.now
		bra	.probe

.check_south	ldd	xpos
		incb
		lbsr	getpixel
		cmpb	#EXPLORE
		bne	.probe
		lbsr	move_south.now

.probe		bsr	boxed_in	; can we stop backtracking?
		bne	explore		; if so, go back to exploring
		bra	.loop		; else backtrack some more

;*************************************************************************

done		jsr	[$A000]
		beq	done
		cmpa	#32
		lbeq	start.clear_screen
		jmp	[$FFFE]

;*************************************************************************
;	BOXED_IN	Are we boxed in?
;Entry:	none
;Exit:	A - direction flag
;*************************************************************************

boxed_in	clr	,-s		; clear direction flags
		ldb	ypos
		beq	.check_east
		subb	#2		; look up two pixels
		lda	xpos
		lbsr	getpixel	; get the color there
		tstb			; 0?
		bne	.check_east	; if not, look towards the east
		lda	,s		; set NORTH flag
		ora	#NORTH
		sta	,s

.check_east	lda	xpos		; now look east
		cmpa	#62
		beq	.check_west
		adda	#2
		ldb	ypos
		lbsr	getpixel
		tstb
		bne	.check_west
		lda	,s
		ora	#EAST
		sta	,s

.check_west	lda	xpos		; and so on ...
		beq	.check_south
		suba	#2
		ldb	ypos
		bsr	getpixel
		tstb
		bne	.check_south
		lda	,s
		ora	#WEST
		sta	,s

.check_south	ldb	ypos
		cmpb	#62
		beq	.done
		addb	#2
		lda	xpos
		bsr	getpixel
		tstb
		bne	.done
		lda	,s
		ora	#SOUTH
		sta	,s
.done		lda	,s+		; set flags
		rts

;*************************************************************************

movetab		bra	move_north
		bra	move_east
		bra	move_west
		bra	move_south

;*************************************************************************
;	MOVE_*		Move (draw) along the maze
;Entry:	A - dir
;Exit:	A - trashed
;	B - trashed
;	X - trashed
;*************************************************************************

no_movement	rts

move_north	anda	#NORTH
		beq	no_movement
.now		bsr	setpixel
		dec	ypos
		bsr	setpixel
		dec	ypos
		bra	setpixel

move_east	anda	#EAST
		beq	no_movement
.now		bsr	setpixel
		inc	xpos
		bsr	setpixel
		inc	xpos
		bra	setpixel

move_west	anda	#WEST
		beq	no_movement
.now		bsr	setpixel
		dec	xpos
		bsr	setpixel
		dec	xpos
		bra	setpixel

move_south	anda	#SOUTH
		beq	no_movement
.now		bsr	setpixel
		inc	ypos
		bsr	setpixel
		inc	ypos

;*************************************************************************
;	SETPIXEL	Set a pixel
;Uses:	xpos
;	ypos
;Exit:	X - video address
;	D - trashed
;*************************************************************************

setpixel	ldd	xpos
		bsr	point_addr	; get video address
		stb	,-s		; save mask
		ldb	color		; get color to use
		tsta			; any shift?
		beq	.setit		; if not, skip
.rotate		lslb			; shift color bits
		deca
		bne	.rotate
.setit		lda	,x		; get screen data
		anda	,s		; mask screen data
		sta	,s
		orb	,s+		; add in color
		stb	,x		; save back to video screen
		rts

;*************************************************************************
;	GETPIXEL	Get the color of a given pixel
;Entry:	A - x pos
;	B - y pos
;Exit:	X - video address
;	A - 0
;	B - color
;*************************************************************************

getpixel	bsr	point_addr	; get video address
		comb			; reverse mask (since we're reading
		stb	,-s		; the screen, not writing it)
		ldb	,x		; get video data
		andb	,s+		; mask off the pixel
.rotate		lsrb			; shift color bits
		deca
		bne	.rotate
.done		rts			; return color in B

;*************************************************************************
;	POINT_ADDR		calculate the address of a pixel
;Entry:	A - xpos
;	B - ypos
;Exit:	X - video address
;	A - shift value
;	B - mask
;*************************************************************************

point_addr.bits	fcb	%00111111,%11001111,%11110011,%11111100	; masks
		fcb	6,4,2,0	; bit shift counts

point_addr	pshs	u,a		; save U and xpos
		lda	#16		; # byte per line
		mul			; calculate offset to line
		addd	ECB.beggrp	; add in start of video buffer
		tfr	d,x
		ldb	,s		; get xpos
		lsrb			; xpos /= 4
		lsrb
		abx			; add x offset into video address
		lda	,s+		; get xpos
		anda	#3		; xpos %= 4
		leau	.bits,pc	; point to mask bits table
		ldb	a,u		; get mask
		leau	4,u		; point to shift value table
		lda	a,u		; get shift value
		puls	u,pc		; restore U and return

;***********************************************************************
;	RND4		Generate a random number 0 .. 3
;Entry:	none
;Exit:	B - random number
;***********************************************************************

rnd4		dec	rnd4.cnt	; any more cached random #s?
		bpl	.cached		; yes, get next cached number
		ldb	#3		; else reset count
		stb	rnd4.cnt
		bsr	random		; get random number
		stb	rnd4.cache	; save in the cache
		bra	.ret		; and return the first number
.cached		ldb	rnd4.cache	; get cached value
		lsrb			; get next 2-bit random number
		lsrb
		stb	rnd4.cache	; save ermaining bits
.ret		andb	#3		; mask off our result
		rts

;***********************************************************************
;	RANDOM		Generate a random number
;Entry:	none
;Exit:	B - random number (1 - 255)
;***********************************************************************

random		ldb	lfsr
		andb	#1
		negb
		andb	#$B4
		stb	,-s		; lsb = -(lfsr & 1) & taps
		ldb	lfsr
		lsrb			; lfsr >>= 1
		eorb	,s+		; lfsr ^=  lsb
		stb	lfsr
		rts

;*************************************************************************
		end	start