;			BLOCKDUDE BY BRANDON STERNER
;			    THIS IS A TCPA GAME
;
;I do not claim this to be good source.  Actaully I think it is kind of messy.
;So read it if you like.  Alter it if you want but do not distribute any 
;variation of this game without my permission.  And don't plan on getting 
;permission.

.NOLIST
#define equ .equ
#define EQU .equ
#define end .end
;	name	location	bytes and description
#define mx	apd_buf		;1 x coor of man
#define my	apd_buf+1	;1 y coor of man
#define x	apd_buf+2	;1 generic x
#define y	apd_buf+3	;1 generic y
#define curloc	apd_buf+4	;2 current location of compressed data
#define height  apd_buf+6	;1
#define width	apd_buf+7	;1
#define guyloc	apd_buf+8	;2 location of guy in boardmap
#define toploc	apd_buf+10	;2 location of the top left square in screen
#define direction apd_buf+12	;1 direction of man; 0 if left; not 0 if right
#define carry	apd_buf+13	;1 if the dude is carrying something =1 if not =0
#define textloc apd_buf+14	;2 bytes
#define textxy	apd_buf+16	;2 bytes
#define option	apd_buf+18	;1 byte	
#define options	apd_buf+19	;1 byte
#define mode	apd_buf+20	;1 byte flag; demo(1) or play(0) mode
#define counter apd_buf+21	;1 byte timing moves
#define mask	apd_buf+22	;1 mask for decompressing
#define password apd_buf+23	;4 3 bytes will be chars the last being the zero terminated string
#define byte	apd_buf+27	;6 a clear buffer
#define level	apd_buf+33	;1 the # of the level you are on
#define secbuf	apd_buf+34	;4 buffer for secret presses
#define levloc	apd_buf+34+4	;2 location of the current level
#define passloc	apd_buf+36+4	;2 location in passbuff
#define passbuff apd_buf+38+4	;3 an inputted password
#define char	apd_buf+41+4	;1 current char# in the inout routine 
#define page	apd_buf+46		;1 page you are on in the instructions
#define boardmap apd_buf+50	;651 bytes of data
#include "crash82.inc"
.LIST

get_key = GET_KEY
apd_buf	= APD_BUF
cgbuf = _GRBUFCPY_V
textInverse = 3
textflags = $5
graph_mem = GRAPH_MEM
PLOTSSCREEN = GRAPH_MEM
plotsscreen = GRAPH_MEM
textwrite       EQU       7
sgrflags        EQU       20
gbuf = GRAPH_MEM
_divHLbyA   = $00A3
pencol   = GRAF_CURS
_vputmap = M_CHARPUT
_vputs = D_ZM_STR

.org START_ADDR

 .db	"Block Dude - TCPA",0

 ROM_CALL(CLEARLCD)
 ld	a,(INT_STATE)
 or	a
 jr	z,prog_start
 ld	hl,0
 ld	($800C),hl
 ld	hl,Text
 ROM_CALL(D_ZT_STR)
WaitKey:
 call	GET_KEY
 cp	$36
 jr	nz,WaitKey
 ret
Text:
.db "Please disable   Interrupts",0

prog_start:
 ld	hl,password
 ld	(hl),0
 ld	de,password+1
 ld	bc,14
 ldir			;needed zeros for byte,password, and level

 call	erasescreen
 set	1,(iy+$05)	;underline
 set	textwrite,(iy+sgrflags)	;to graphbuffer

 call	loaddemo
 ROM_CALL(cgbuf)
 ld	hl,endtxt
 ld	de,57*256+5
 ld	a,4
 call	choosemode
 xor	a
 ld	(mode),a

 ld	a,(option)
 cp	4
 jp	z,new
 cp	3
 jr	z,enterpass
 res	1,(iy+$05)	;underline
 res	textwrite,(iy+sgrflags)	;to graphbuffer
 res	textInverse,(iy+textflags);
 dec	a
 ret	z			;exit
loadhelp:
 res	textwrite,(iy+sgrflags)
 call	erasescreen
 ROM_CALL(cgbuf)
 ld	hl,instructions
 ld	a,1
 ld	(page),a
loadhelp2:
 ld	a,0
 ld	(x),a
 ld	(y),a
 ld	b,10
loadhelp3:
 push	bc
 ld	de,(x)
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	a,(y)
 add	a,6
 ld	(y),a
 pop	bc
 djnz	loadhelp3
 push	hl
 call	wait
 ROM_CALL(cgbuf)
 pop	hl
 ld	a,(page)
 inc	a
 ld	(page),a
 cp	3
 jr	nz,loadhelp2
 set	textwrite,(iy+sgrflags)
 jp	prog_start

enterpass:
 call	box
 ld	hl,please
 ld	de,256*24+28
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	de,256*31+26
 ld	(pencol),de
 ROM_CALL(_vputs)
 ROM_CALL(cgbuf)
 ld	bc,256*38+42
 res	textwrite,(iy+sgrflags)
 call	input
 set	textwrite,(iy+sgrflags)

 ld	hl,level1-1
 ld	(curloc),hl
 xor	a
 ld	(level),a
checkpass:
 ld	hl,(curloc)
 ld	(levloc),hl
 ld	ix,passbuff-1
 ld	c,3
checkpass2:
 inc	hl
 inc	ix
 ld	a,(hl)
 ld	b,a
 ld	a,(ix)
 cp	b
 jr	nz,nextcheck
 dec	c
 jr	nz,checkpass2
 ld	hl,(levloc)
 ld	(curloc),hl
 jr	setuplevel			;found level
nextcheck:
 ld	hl,(levloc)
 ld	bc,4
 add	hl,bc
 ld	(curloc),hl
 call	erasemap
 ld	a,(level)
 inc	a
 ld	(level),a
 cp	11
 jr	nz,checkpass

new:
 xor	a
 ld	(level),a
 ld	hl,level1-1	;beginning of compressed data
 ld	(curloc),hl

setuplevel:
 ld	a,(level)
 inc	a
 ld	(level),a
 cp	12
 jp	z,message2
 ld	hl,(curloc)
 ld	(levloc),hl	;in case you want to restart level
 inc	hl		;if we are on a level>1 then we just decompressed this byte so we need to increment
 ld	de,password
 ld	bc,3
 ldir
 ld	(curloc),hl
 call	erasemap
 call	box
 ld	hl,leveltxt
 ld	de,27*256+27	;y,x
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	a,(level)
 ld	l,a
 ld	h,0
 call	disphl


 ld	hl,passtxt
 ld	de,36*256+27	;y,x
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	hl,password
 ROM_CALL(_vputs)

 ROM_CALL(cgbuf)
 call	get2nd
 call	dispall

main:
 ROM_CALL(cgbuf)
;check if clear was pressed
 ld	b,0fdh 
 call	Direct_Input
 cp	%10111111
 jp	z,message1
 ld 	b,0bfh 
 call 	Direct_Input
;check if 2nd was pressed
 cp 	%11011111
 jr 	z,scan

 ld	b,0FEh
 call	Direct_Input
 cp	%11110111
 call	z,up
 cp	%11111110 
 call	z,down
 cp	%11111101
 call	z,left
 cp	%11111011
 call	z,right

 jr	main
scan:
 ld	hl,(toploc)
 push	hl
scan2:
 halt
 ld	b,0FEh
 call	Direct_Input
 cp	%11110111
 call	z,checkup2
 cp	%11111110 
 call	z,checkdown2
 cp	%11111101
 call	z,checkleft2
 cp	%11111011
 call	z,checkright2
 call	dispall
 ROM_CALL(cgbuf)
 halt
 ld 	b,0bfh 
 call 	Direct_Input
;check if 2nd was pressed
 cp 	%11011111
 jr 	z,scan2
 pop	hl
 ld	(toploc),hl
 call	dispall
 jr	main

Direct_Input:
 ld	a,0ffh
 out	(1),a
 ld	a,b
 out	(1),a
 in	a,(1)
 ret
left:
 ld	ix,(guyloc)
 ld	a,(ix-1)
 cp	3
 jp	z,nextlevel
 or	a
 jr	nz,left4	;can't walk through a wall you idiot!
 ld	a,(carry)
 or	a
 jr	z,left3
 ld	a,(ix-32)
 or	a
 jr	z,left2
 ld	(ix),2
 xor	a
 ld	(ix-31),a
 ld	(carry),a
 jr	left31
left2:
 ld	(ix-31),a
 ld	(ix-32),2
left3:
 ld	(ix),0
left31:
 dec	ix
left4:
 ld	(ix),4
 ld	(guyloc),ix
 xor	a
 ld	(direction),a
 call	checkleft
 call	checkfall
 jp	dispall

right:
 ld	ix,(guyloc)
 ld	a,(ix+1)
 cp	3
 jp	z,nextlevel
 or	a
 jr	nz,right4	;can't walk through a wall you idiot!
 ld	a,(carry)
 or	a
 jr	z,right3	;no carry
 ld	a,(ix-30)
 or	a
 jr	z,right2
 ld	(ix),2
 xor	a
 ld	(ix-31),a
 ld	(carry),a
 jr	right31
right2:
 ld	(ix-31),a
 ld	(ix-30),2
right3:
 ld	(ix),0
right31:
 inc	ix
right4:
 ld	(ix),5
 ld	(guyloc),ix
 ld	a,1
 ld	(direction),a
 call	checkright
 call	checkfall
 jp	dispall

up:
 ld	ix,(guyloc)
 ld	a,(ix-31)
 cp	1
 ret	z	;you can't go up, there is brick above you
 ld	a,(direction)
 or	a
 jr	nz,upright
upleft:
 ld	a,(ix-1)
 or	a
 ret	z	;bozo there's nothing to climb:)
 cp	3
 jp	z,nextlevel
 ld	a,(ix-32)
 cp	3
 jp	z,nextlevel
 or	a
 ret	nz	;its too tall
 ld	a,(carry)
 or	a
 jr	z,upleft2
 ld	a,(ix-63)
 or	a
 ret	nz	;there is something on top of the empty space you're trying to move into
 ld	(ix-31),a ;erase current block carried 
 ld	(ix-63),2 ;put up where you will be
upleft2:
 ld	(ix),a
 ld	de,-32
 add	ix,de
 ld	(ix),4
 ld	(guyloc),ix
 xor	a
 ld	(direction),a
 call	checkleft
 call	checkup
 jp	dispall
upright:
 ld	a,(ix+1)
 or	a
 ret	z	;bozo there's nothing to climb:)
 cp	3
 jp	z,nextlevel
 ld	a,(ix-30)
 cp	3
 jp	z,nextlevel
 or	a
 ret	nz	;its too tall
 ld	a,(carry)
 or	a
 jr	z,upright2
 ld	a,(ix-61)
 or	a
 ret	nz
 ld	(ix-31),a
 ld	(ix-61),2
upright2:
 ld	(ix),a
 ld	de,-30
 add	ix,de
 ld	(ix),5
 ld	(guyloc),ix
 ld	a,1
 ld	(direction),a
 call	checkright
 call	checkup
 jp	dispall

down:	;pick up/put down
 ld	ix,(guyloc)
 ld	a,(carry)
 or	a
 jr	nz,putdown
 ld	a,(ix-31)
 or	a
 ret	nz	;there is something over your head
 ld	a,(direction)
 or	a
 jr	nz,pickupr 
 ld	a,(ix-1)
 cp	2
 ret	nz	;yes you're still stupid, you can't pick it up(if there was anything there in the first place)
 ld	a,(ix-32)
 or	a
 ret	nz	;can't pick up something if something is on top of it
 ld	a,2
 ld	(carry),a
 ld	(ix-1),0
 ld	(ix-31),a
 call	dispall
 ld	c,1
 jp	nodkey
pickupr:
 ld	a,(ix+1)
 cp	2
 ret	nz	;yes you're still stupid, you can't pick it up(if there was anything there in the first place)
 ld	a,(ix-30)
 or	a
 ret	nz	;can't pick up something if something is on top of it
 ld	(ix+1),a
 ld	a,2
 ld	(carry),a
 ld	(ix-31),a
 call	dispall
 jp	nodkey
putdown:
 ld	a,(direction)
 rla
 ld	e,a
 ld	d,0
 dec	de
 add	ix,de	;either ix-1 or ix+1
 ld	de,-31
 add	ix,de	;now we have the blocks location left or right one
 ld	a,(ix)
 or	a
 ret	nz	;something is in the way
putdown2:
 ld	de,31
 add	ix,de
 ld	a,(ix)
 or	a
 jr	z,putdown2
putdown3:
 ld	(ix-31),2
 ld	ix,(guyloc)
 xor	a
 ld	(ix-31),a
 ld	(carry),a
 call	dispall
 jp	nodkey
checkup:
 ld	a,(my)
 cp	40
 ret	nc
checkup2:
 ld	hl,(toploc)
 ld	de,-31
 add	hl,de
 ld	a,(hl)
 inc	a
 ret	z
 ld	(toploc),hl
 ret
checkdown:
 ld	a,(my)
 cp	24
 ret	c
checkdown2:
 ld	hl,(toploc)
 ld	de,248
 add	hl,de
 ld	a,(hl)
 inc	a
 ret	z
 ld	de,-217
 add	hl,de
 ld	(toploc),hl
 ret
checkright:
 ld	a,(mx)
 cp	56
 ret	c
checkright2:
 ld	ix,(toploc)
 ld	a,(ix+12)
 inc	a
 ret	z
 inc	ix
 ld	(toploc),ix
 ret
checkleft:
 ld	a,(mx)
 cp	48
 ret	nc
checkleft2:
 ld	ix,(toploc)
 dec	ix
 ld	a,(ix)
 inc	a
 ret	z
 ld	(toploc),ix
 ret
checkfall:
 ld	ix,(guyloc)
 ld	a,(ix+31)
 or	a
 jr	nz,checkfall3
 ld	a,(my)
 add	a,8
 ld	(my),a
 call	checkdown
 ld	(ix),0
 ld	de,31
 add	ix,de
 ld	a,(direction)
 add	a,4
 ld	(ix),a
 ld	(guyloc),ix
 ld	a,(carry)
 or	a
 jr	z,checkfall2
 ld	(ix-31),a	;i think it'll always be 2
 ld	(ix-62),0
checkfall2:
 jr	checkfall
checkfall3:
 cp	3
 ret	nz
 call	dispall
 pop	hl		;de increment stack by 2
 jp	nextlevel

dispall:
 call	erasescreen
 call	drawtiles
delay:	;or nokey
 ROM_CALL(cgbuf)
 ld	c,10
delay2:
 halt
 ld	b,0FEh
 call	Direct_Input
 inc	a
 jr	z,delay3
 dec	c
 jr	nz,delay2
delay3:
 ret

getdata2:
 push	bc
 push	hl
 push	de
 push	ix
 ld	c,0
getdata3:
 ld	hl,(curloc)
 ld	a,(mask)
 ld	b,a
 ld	a,(hl)
 and	b
 cp	b
 jr	nz,gotbyte
 inc	c
 call	nec
 jr	getdata3
gotbyte:
 call	nec
 ld	a,c
 pop	ix
 pop	de
 pop	hl
 pop	bc
 ret
nec:
 ld	a,(mask)
 rrca
 ld	(mask),a
 cp	128
 ret	nz
 inc	hl
 ld	(curloc),hl
 ret

interpret:
 or	a
 ret	z
 ld	ix,brick-8
 ld	de,8
interpret2:
 add	ix,de
 dec	a
 jr	nz,interpret2
 ld	a,(y)
 ld	l,a
 ld	a,(x)
sprite:
 ld     b,8
 jp     smsprt

;draw the tiles on screen from location (toploc)
drawtiles:
 ld	hl,(toploc)
 xor	a
 ld	(y),a
drawtiles2:
 xor	a
 ld	(x),a
drawtiles3:
 ld	a,(hl)
 cp	4
 jr	c,drawtiles4
 ld	(guyloc),hl
 sub	4
 ld	(direction),a
 ld	de,(x)
 ld	(mx),de
 add	a,4
drawtiles4:
 push	hl
 call	interpret
 pop	hl
 inc	hl
 ld	a,(x)
 add	a,8
 ld	(x),a
 cp	96
 jr	nz,drawtiles3
 ld	de,19
 add	hl,de
 ld	a,(y)
 add	a,8
 ld	(y),a
 cp	64
 jr	nz,drawtiles2
 ret
erasescreen:
 ld	hl,plotsscreen
 ld	(hl),0
 ld	de,plotsscreen+1
 ld	a,(mode)
 or	a
 jr	nz,part
 ld	bc,767
 ldir
 ret
part:
 ld	bc,671
 ldir
 ld	HL,titlescreen
 ld	DE,plotsscreen
 call	DispRLE
 ret
wait:
get2nd:
 call	get_key
 cp	$36
 jr	nz,get2nd
 ret
nodkey:
 ld	c,1	;mask for nokey
nokey:
 push	bc
 ROM_CALL(cgbuf)
 pop	bc
nokey2:
 halt
 ld	b,0FEh
 call	Direct_Input
 and	c
 cp	c
 jr	nz,nokey2
 ret

nextlevel:
 ld	a,(mode)
 or	a
 jr	nz,loaddemo
 pop	hl	;de increment stack by 2
 jp	setuplevel

loaddemo:
 ld	a,1
 ld	(mode),a
 ld	a,20
 ld	(counter),a
 ld	hl,level1+3	;beginning of compressed data (skipping the password
 ld	(curloc),hl
 call	erasemap
 ld	a,128
 ld	(mask),a
 ld	hl,moves
 ld	(curloc),hl
 ret
;-----Menu Routine------;
;as it is now, this is	;
;a sideways menu routine;
;to move use right and	;
;left. Use del to select;
;an option		;
;required vars:		;
;textloc 	;2 bytes;
;textxy		;2 bytes;
;option		;1 byte	;
;options	;1 byte	;
;be sure to put option	; 
;right before the the 	;
;var options in memory	;
;			;
;input for menu:	;
;hl=start of text	;
;de=coors of menu	;
;a=options		;
;			;
;output:		;
;option= # of options-1st or 2nd or...;
;--------Code-----------;
choosemode:		;
 ld	(textloc),hl	;store the variables
 ld	(textxy),de	;
 ld	(options),a	;
 ld	(option),a	;a=the num of options. If there were 5 then five would point to the first option 
writemenu:		
 ld	hl,(textloc)
 ld	de,(textxy)
 ld	(pencol),de
 ld	a,(options)	;load a and b with the 
 ld	b,a		;number of option
writemenu2:		;
 push	bc		;save bc
 ld	a,(option)	;see if option(the one that sould be highlighted)
 cp	b		;= b(the current option being written
 jr	nz,ivputs	;
 set	textInverse,(iy+textflags);
 ROM_CALL(_vputs)		;
 res	textInverse,(iy+textflags);

writemenu3:		;
 pop	bc		;recall bc
 djnz	writemenu2	;

writemenu4:		;main loop for selecting
 ld	a,(mode)
 or	a
 call	nz,demomode
 ROM_CALL(cgbuf)
 call   get_key		;
 cp     $36		;2nd?
 ret	z
 cp	$02		;left?
 jr	z,leftmen	;then move left
 cp	$03		;right?
 jr	z,rightmen	;then move right
 cp	$30
 jr	nz,writemenu4
 ld	a,(mode)
 or	a
 jr	z,writemenu4
 ld	a,(option)
 dec	a
 ld	hl,secbuf
 ld	d,0
 ld	e,a
 add	hl,de
 ld	(hl),1
 ld	hl,secbuf
 ld	b,4
secloop:
 ld	a,(hl)
 dec	a
 jr	nz,writemenu4
 inc	hl
 djnz	secloop
 jp	secretselect
 
leftmen:		;move left in the menu
 ld	de,(option)	;compare 
 ld	a,e		;option to
 cp	d		;options
 jr	z,writemenu4	;if = then go back
 inc	a		;increase the option pointer
 ld	(option),a	;
 jr	writemenu	;rewrite the menu
rightmen:		;
 ld	a,(option)	;compare 
 cp	1		;option # to 1
 jr	z,writemenu4	;if = then go back
 dec	a		;else decrease the option #
 ld	(option),a	;
 jp	writemenu	;rewrite menu
ivputs:			;text w/ underline
 ROM_CALL(_vputs)		;
 jr	writemenu3	;
;-----------------------;
secretselect:
 xor	a
 ld	(mode),a
 call	box
 ld	hl,select
 ld	de,256*24+27
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	de,256*31+38
 ld	(pencol),de
 ROM_CALL(_vputs)
 ROM_CALL(cgbuf)
 ld	a,1
 ld	(level),a
secretloop:
 ld	de,256*38+46
 ld	(pencol),de
 ld	a,(level)
 ld	h,0
 ld	l,a
 call	disphl
 ROM_CALL(cgbuf)
secretl2:
 call	get_key
 cp	$04
 jr	z,sup
 cp	$01
 jr	z,sdown
 cp	$36
 jr	z,secl3
 jr	secretl2
sup:
 ld	a,(level)
 dec	a
 jr	z,secretl2
 ld	(level),a
 jr	secretloop
sdown:
 ld	a,(level)
 cp	11
 jr	z,secretl2
 inc	a
 ld	(level),a
 jr	secretloop
secl3:
 ld	hl,level1-1
 ld	(curloc),hl
 ld	a,(level)
 ld	b,a
secl4:
 ld	hl,(curloc)
 ld	(levloc),hl
 ld	de,4
 add	hl,de
 ld	(curloc),hl
 push	bc
 call	erasemap
 pop	bc
 djnz	secl4
 pop	hl	;rid ourselves of a call
 jp	restart
erasemap:
 ld	hl,boardmap
 ld	(hl),$ff
 ld	de,boardmap+1
 ld	bc,650
 ldir
 call	erasescreen
 ld	a,128
 ld	(mask),a
copydata:
 ld	hl,(curloc)
 ld	a,(hl)
 ld	e,a
 inc	hl
 ld	a,(hl)
 ld	d,a
 inc	hl
 ld	(toploc),de
 ld	a,(hl)
 ld	(height),a
 inc	hl
 ld	a,(hl)
 ld	(width),a
 inc	hl
 ld	(curloc),hl
 ld	hl,boardmap+32
copydata2:
 ld	a,(width)
 ld	b,a
copydata3:
 call	getdata2
 ld	(hl),a
 inc	hl
 djnz	copydata3
 ld	a,(width)
 ld	b,a
 ld	a,31
 sub	b
 ld	d,0
 ld	e,a
 add	hl,de
 ld	a,(height)
 dec	a
 ld	(height),a
 jr	nz,copydata2
 xor	a
 ld	(carry),a
 jp	drawtiles
demomode:
 ld	hl,counter
 dec	(hl)
 ret	nz
 ld	(hl),20
 call	getdata2
 cp	1
 jp	z,up
 cp	2
 jp	z,right
 cp	3
 jp	z,down
 cp	4
 jp	z,left
 ret
;===========================================================
; RLE picture displayer v1.1
; Decodes a RLE picture made by RLE2PIC
; 82/83 version
;
; written by David Phillips <electrum@tfs.net>
; started: 8/19/98
; last update: 1/12/98
;
; input: HL = RLE encoded picture, DE = where to display
; output: 1024 byte decoded picture
; destroys: AF, BC, DE, HL
; current size: 32 bytes
;===========================================================
DispRLE:
 ld bc,264			; we need to copy 768 bytes
DispRLEL:
 ld a,(hl)			; get the next byte
 cp $91				; is it a run?
 jr z,DispRLERun	; then we need to decode the run
 ldi				; copy the byte, and update counters
DispRLEC:
 ld a,b				; check the low byte and
 or c				; the high byte for 0
 jr nz,DispRLEL		; if not, then we're not done either
 ret				; if it's zero, we're done
DispRLERun:
 inc hl				; move to the run value
 ld a,(hl)			; get the run value
 inc hl				; move to the run count
 push hl			; save source pointer
 ld h,(hl)			; get the run count
 ex de,hl			; swap source and destination pointers
DispRLERunL:
 ld (hl),a			; copy the byte
 inc hl				; increase destination pointer
 dec bc				; decrease byte count
 dec d				; decrease run count
 jr nz,DispRLERunL	; if we're not done, then loop
 ex de,hl			; swap pointers back
 pop hl				; recover source pointer
 inc hl				; advance the source pointer
 jr DispRLEC		; check to see if we should loop

box:				; START OF CODE By Chris Hiszpanski (Man in the Moon)
 ld	a,31			; Height + 1 again
 ld	de,plotsscreen+195		; Top left corner
clearline:			; Clear the section saved
 ld	hl,byte
 ld	bc,6			;
 ldir				;
 inc	de			; Skip last four bytes
 inc	de			;
 inc	de			; Skip last four bytes
 inc	de			;
 inc	de			;
 inc	de			;
 dec	a			;
 or	a			;
 jr	nz,clearline		;

line:
 ld	hl,graph_mem+195		; Top left corner
 ld	a,255
 ld	b,6
line1:
 ld	(hl),a
 inc	hl
 djnz	line1
 ld	hl,graph_mem+555
 ld	b,6
line2:
 ld	(hl),a
 inc	hl
 djnz	line2
 ld	a,%10000000
 ld	hl,graph_mem+207
 ld	de,12
 ld	b,29
line3:
 ld	(hl),a
 add	hl,de
 djnz	line3
 ld	a,%00000001
 ld	hl,graph_mem+212
 ld	de,12
 ld	b,29
line4:
 ld	(hl),a
 add	hl,de
 djnz	line4

;put title in 
 ld	hl,description
 ld	de,17*256+25
 ld	(pencol),de
 set	textInverse,(iy+textflags)
 ROM_CALL(_vputs)
 res	textInverse,(iy+textflags)
;end of title
 ret

disphl:
	ROM_CALL($359A)
	ROM_CALL($19F5)
	ROM_CALL($2E46)
	.dw $6CA4
	.db $04
	ret
message2: 
 call	box
 ld	hl,endmess
 ld	de,24*256+32
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	de,30*256+29
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	de,36*256+31
 ld	(pencol),de
 ROM_CALL(_vputs)
 ROM_CALL(cgbuf)
 call	wait
 jp	prog_start

message1:
 call	box
 ld	hl,joke
 ld	de,27*256+28
 ld	(pencol),de
 ROM_CALL(_vputs)
 ld	hl,mess1txt
 ld	de,36*256+27
 ld	a,2
 call	choosemode
 ld	a,(option)
 dec	a
 jp	z,prog_start
;restart level
restart:
 ld	hl,(levloc)
 ld	(curloc),hl
 ld	hl,level
 dec	(hl)
 jp	setuplevel

;input: 
;bc= coors

input:
 ld	hl,passbuff
 ld	(passloc),hl
 ld	(textxy),bc
 ld	(pencol),bc
 ld	a,3
 ld	(option),a
alphastart:
 ld	a,'A'
 ld	(char),a
placechar:
 push	af
 ld	hl,(textxy)
 push	hl
 ld	(pencol),hl
 ld	hl,blanks
 ROM_CALL(_vputs)
 pop	hl
 ld	(pencol),hl
 pop	af
 ROM_CALL(_vputmap)
inputmain:
 call   get_key		;	
 cp	$04		;up?
 jr	z,inputup
 cp	$01		;down?
 jr	z,inputdown
 cp	$36		;2nd?	
 jr	z,nextchar	;	
 jr	inputmain
inputdown:
 ld	a,(char)
 cp	'Z'
 jr	z,inputdown2
 cp	'z'
 jr	z,alphastart
 inc	a
 ld	(char),a
 jr	placechar
inputdown2:
 ld	a,'a'
 ld	(char),a
 jr	placechar
inputup:
 ld	a,(char)
 cp	'A'
 jr	z,lalphaend
 cp	'a'
 jr	z,alphaend
 dec	a
 ld	(char),a
 jr	placechar
alphaend:
 ld	a,'Z'
 ld	(char),a
 jr	placechar
lalphaend:
 ld	a,'z'
 ld	(char),a
 jr	placechar
nextchar:
 ld	a,(char)
 ld	hl,(passloc)
 ld	(hl),a
 inc	hl
 ld	(passloc),hl
 ld	hl,(pencol)
 ld	(textxy),hl
 ld	hl,option
 dec	(hl)
 ret	z
 jr	placechar

brick:
 .db	%11111011
 .db	%11111011
 .db	%00000000
 .db	%11111110
 .db	%11111110
 .db	%00000000
 .db	%11111011
 .db	%11111011
block:			;varible sized block
 .db	%11111111
 .db	%10000001
 .db	%10000001
 .db	%10000001
 .db	%10000001
 .db	%10000001
 .db	%10000001
 .db	%11111111
door:
 .db	%01111110
 .db	%01000010
 .db	%01000010
 .db	%01000010
 .db	%01000110
 .db	%01000010
 .db	%01000010
 .db	%01111110
manl:
 .db	%00011100
 .db	%01111110
 .db	%00010010
 .db	%00100010
 .db	%00010100
 .db	%00101010
 .db	%00001000
 .db	%00110110
manr:
 .db	%00111000
 .db	%01111110
 .db	%01001000
 .db	%01000100
 .db	%00101000
 .db	%01010100
 .db	%00010000
 .db	%01101100
titlescreen:	;rle
 .db $91,$00,$09,$40,$91,$00,$04,$3f,$b0,$00,$08,$1f
 .db $f0,$00,$40,$91,$00,$04,$0c,$90,$00,$08,$08,$18
 .db $00,$40,$91,$00,$04,$09,$10,$00,$10,$08,$08,$00
 .db $40,$91,$00,$04,$16,$20,$e3,$96,$10,$0e,$21,$c6
 .db $91,$00,$04,$1f,$a3,$2c,$28,$10,$0a,$46,$9a,$91
 .db $00,$04,$20,$a4,$30,$30,$20,$14,$59,$14,$91,$00
 .db $04,$20,$a4,$50,$50,$20,$24,$91,$91,$01,$28,$91
 .db $00,$04,$21,$44,$92,$48,$20,$45,$93,$20,$91,$00
 .db $04,$3e,$47,$1c,$4c,$3f,$86,$5d,$b8,$91,$00,$07
 .db $40,$00,$00,$01,$91,$00,$06,$04,$39,$b1,$06,$4d
 .db $b8,$91,$00,$06,$0a,$12,$2a,$88,$aa,$a0,$91,$00
 .db $06,$0e,$12,$33,$8a,$ea,$b0,$91,$00,$06,$0a,$12
 .db $22,$8a,$aa,$a0,$91,$00,$06,$0a,$11,$a2,$86,$a8
 .db $b8,$91,$00,$12,$32,$8a,$4c,$ee,$aa,$4e,$91,$00
 .db $06,$2a,$8a,$aa,$48,$aa,$c8,$91,$00,$06,$31,$0a
 .db $ac,$4c,$44,$4c,$91,$00,$06,$29,$0a,$aa,$48,$aa
 .db $42,$91,$00,$06,$31,$04,$4a,$4e,$aa,$ec,$91,$00
 .db $03
; Total compression: 264 bytes compressed to 205 (22% smaller)

;levels are compressed huffman meathod
level1:
 .db	"tcP"		;password
 .dw	boardmap+40	;screen starting position
 .db	8	;height
 .db	20	;widht
 .db	128,0,10,0,0,40,0,0,160,0,2,132,2,2,184,132,201,159,21
 .db	85,85,85,85,80,0,0,0	;27 bytes of blocks

level2:
 .db	"ARo"
 .dw	boardmap+104	;screen starting position
 .db	10	;height
 .db	22	;widht
 .db	%01000001,%01000000,%00010100,%00001000,%00000000,%00000010
 .db	%00010100,%00000000,%00000000,%10001011,%10000000,%00000000
 .db	%00001001,%01000000,%00000000,%00000010,%01000000,%00000010
 .db	%00110000,%01001000,%00000000,%01011001,%10110111,%10001001
 .db	%01010101,%00001010,%10101010,%10101010,%10101000,%00010001
 .db	%10100000,%00000000,%00000101,%01010100,%00000000,%00000000
;36 bytes of blocks
level3:
 .db	"CKs"
 .dw	boardmap+97
 .db	11	;height
 .db	19	;width
 .db	%01000000,%00000000,%00000100,%00101010,%10101010,%10101010
 .db	%10100100,%10010000,%00000000,%00101000,%10000000,%00000000
 .db	%10100000,%00000000,%00001101,%01000000,%00000000,%00110110
 .db	%10100101,%01000001,%11100001,%01100101,%00100100,%10000010
 .db	%00101010,%10100010,%01001011,%01100101,%00010000,%00010111
 .db	%01001010,%10101010,%01010000,%00010101,%00101000,%01010100
 .db	%00000000
level4:
 .db	"daN"
 .dw	boardmap+198
 .db	16
 .db	24
 .db	%00000000,%00000000,%00100000,%00000000,%00000000,%00100100,%00000000,%00100000
 .db	%00001000,%01000000,%00001001,%00000001,%00000010,%00000101,%01000010,%00001000
 .db	%00000100,%00100000,%00010001,%00000000,%00100100,%00000000,%10100000,%00000010
 .db	%01000000,%00000000,%00000001,%10100100,%00000000,%00000000,%00110110,%10010000
 .db	%00000000,%00001111,%00001010,%10101000,%00100000,%00000010,%00010001,%01110000
 .db	%01001100,%00000001,%01010101,%00010101,%01010010,%01100001,%10001010,%10000000
 .db	%00001001,%00110010,%01011001,%00000000,%00000100,%10101010,%10101010,%10100000
 .db	%00000000,%10101000,%00000000,%0000000
level5:
 .db	"BAH"
 .dw	boardmap+163
 .db	14
 .db	22
 .db	%00000101,%01000001,%01010101,%01010101,%00010101,%01000010,%10101000,%00000001
 .db	%01000000,%00000000,%00000001,%01000000,%00000000,%00000001,%01000000,%00000000
 .db	%00000001,%01000000,%10000000,%00000000,%10100000,%01000000,%00000000,%01010000
 .db	%00101101,%10110110,%00000000,%00101011,%10000101,%01010101,%01011110,%00000000
 .db	%10101001,%01010000,%00101001,%00000011,%01001001,%00000000,%01001010,%00011011
 .db	%01001001,%00000000,%01001010,%00110110,%11010010,%10100000,%00001001,%01010101
 .db	%01010100,%00000000,%00010101,%00000000,%0
level6:
 .db	"Ion"
 .dw	boardmap+134
 .db	13
 .db	21
 .db	%01010100,%00000000,%00001010,%10100100,%01010101,%01010101,%01010101,%01000010
 .db	%10100000,%00000000,%00000010,%10111000,%00000000,%00000000,%10101000,%00000000
 .db	%00000000,%10010000,%00000000,%00000110,%11010010,%11011000,%00000010,%00110001
 .db	%01010010,%11011011,%00000000,%10111101,%10110110,%01000010,%11011011,%01100000
 .db	%00101010,%10100100,%00101010,%10100000,%10101000,%01010100,%00000010,%00011010
 .db	%00000000,%00000001,%01001010,%10000000,%00000000,%00101010,%00000000,%0000
level7:
 .db	"Twe"
 .dw	boardmap+198
 .db	14
 .db	24
 .db	%00100001,%01010101,%00001010,%00010101,%00001001,%00100000,%01001000,%10010000
 .db	%10001000,%10100000,%00101000,%01010000,%01001000,%01000000,%00100000,%10000010
 .db	%01000000,%00000000,%00000001,%10100100,%00000000,%00000000,%00011010,%10100000
 .db	%00000000,%00000001,%10110101,%01110000,%11000000,%00000000,%00101010,%10100001
 .db	%00110000,%00100000,%10100100,%00100001,%00110000,%01010011,%00111101,%01010100
 .db	%00101000,%10011011,%01100010,%10011011,%01101000,%00000100,%01010101,%01010010
 .db	%10101010,%10100000,%00010100,%10000010,%10100000,%00000000,%00101010,%00000000
 .db	%00000000,%00
level8:
 .db	"nTy"
 .dw	boardmap+326
 .db	17
 .db	27
 .db	%01010100,%00000010,%10101000,%01010101,%01010100,%01000010,%00000100,%00010010
 .db	%00000001,%00100000,%10000100,%00001010,%00000000,%01010110,%00001010,%10000010
 .db	%01000000,%10101000,%10101101,%10000000,%00010100,%00000101,%00100010,%10101010
 .db	%00000001,%01000000,%00000101,%11001000,%01010000,%00000000,%01010000,%01010010
 .db	%00100000,%11001000,%00001000,%10000000,%10001000,%00110100,%10000010,%00010000
 .db	%00010010,%00010101,%00001000,%00100010,%00000110,%10010000,%00010010,%00000010
 .db	%10000001,%10110101,%00000000,%01000000,%00000010,%10101010,%10100000,%00000000
 .db	%11000000,%00000001,%01000001,%10000000,%10101000,%00000000,%11010100,%00101010
 .db	%00000000,%00000000,%01101101,%01000000,%00011000,%00000110,%00111100,%01101101
 .db	%10101010,%10101010,%10101010,%10101010,%10101010,%10101010,%10101010,%10101010
level9:
 .db	"iRC"
 .dw	boardmap+132
 .db	16
 .db	20
 .db	%00000000,%10101000,%00000000,%00000010,%00010000,%00000000,%00010000,%00100010
 .db	%10101010,%00000100,%00000010,%10000010,%00001000,%00011000,%00000010,%00010000
 .db	%00011011,%00000001,%10100010,%00000001,%01010000,%01101101,%00100000,%00000000
 .db	%11110010,%10101010,%00000000,%00000110,%00001010,%11100000,%00000001,%01010000
 .db	%10101000,%00101000,%01000000,%01101001,%00000101,%01100010,%10000101,%01010010
 .db	%00001010,%10101010,%10001010,%00001010,%10001000,%00010010,%10000000,%01001010
 .db	%00000101,%01000000,%00010101,%00000000,%0000000
level10:
 .db	"JmK"
 .dw	boardmap+258
 .db	19
 .db	27
 .db	%00010101,%01010101,%01010101,%01010101,%01010101,%01010000,%01010000,%00000000
 .db	%10000000,%00010001,%01010101,%10000000,%01101101,%01100001,%10110110,%01101010
 .db	%01000101,%00010000,%10101010,%10001101,%01010010,%10010100,%00100010,%10000000
 .db	%00101010,%01010100,%01010000,%10100010,%10110110,%11011000,%00000000,%00101011
 .db	%10000000,%01010101,%01010100,%00000000,%01010100,%00000001,%00001010,%10000000
 .db	%00101001,%00000011,%00001001,%00010100,%00000001,%00100000,%01000001,%00000101
 .db	%00000000,%10010101,%01000101,%00000000,%00000010,%10101010,%00010101,%01010000
 .db	%00011110,%00000000,%00010000,%10000000,%00001000,%00000000,%01000010,%00000000
 .db	%01010000,%01010101,%01010101,%00001000,%00000010,%10000000,%00000100,%00010000
 .db	%00000001,%10000000,%00011010,%00001011,%00000101,%01010101,%01010101,%01000011
 .db	%01101000,%00101101,%10001010,%00000000,%01010011,%01101101,%00000101,%01010101
 .db	%00000000,%00001010,%10101010,%0
level11:
 .db	"wTF"
 .dw	boardmap+39
 .db	19
 .db	29
 .db	%10101010,%10101010,%10101010,%10101010,%10101010,%10101010,%10101010,%10100010
 .db	%00010000,%00000000,%00000000,%01010000,%00110101,%10110000,%00000000,%01010101
 .db	%01001010,%11000010,%10100110,%10100000,%01100010,%10001110,%01001010,%11011000
 .db	%00101010,%00011110,%00110000,%00001001,%00101010,%10001101,%10100000,%01001100
 .db	%00000000,%01001010,%00010101,%01000000,%01000101,%01000010,%10100010,%10110000
 .db	%00000000,%01001000,%00001000,%11001010,%11011000,%00000101,%01001001,%01100000
 .db	%10001010,%10101010,%10100110,%00010101,%00010010,%10110001,%00110010,%00101000
 .db	%00000000,%01100101,%01000110,%10000100,%00101000,%01100000,%01101100,%10000101
 .db	%01010000,%00001010,%00001010,%10101010,%10101000,%00000010,%10101010,%01010000
 .db	%00000000,%00011000,%01101010,%00001001,%01010101,%00000000,%00001100,%00100000
 .db	%11011010,%01010110,%10100001,%00000100,%00000000,%01010101,%00101010,%11010101
 .db	%00100000,%10000110,%11011001,%10000000,%01010110,%10110101,%10101000,%00100000
 .db	%00001101,%10110000,%01010101,%01010101,%01010101,%01010101,%01010101,%01010101
 .db	%01010101,%01010000
instructions:
 .db	"The object of this game is",0
 .db	"to reach the door in each",0
 .db	"level.  If you are unsure",0
 .db	"where it is you can hold 2nd",0
 .db	"down and use the arrow keys",0
 .db	"to scroll freely.  You can",0
 .db	"only clinb one block at a time",0
 .db	"and lift only one block at a",0
 .db	"time.  To lift up a block",0
 .db	"press down.  To set it down",0
 .db	"press down again.  CLEAR will",0
 .db	"give you the choice of",0
 .db	"restarting or quiting.  There",0
 .db	"are 11 levels in this game.",0
 .db	"Please visit our web page at",0
 .db	"tcpa.calc.org for additional",0
 .db	"information.  Thanks to all",0
 .db	"the beta testers and the ACZ",0
 .db	"for all there useful utilities",0
 .db	" ",0
moves:	;for demo are compressed huffman style
 .db	%11110111,%01111011,%10101011,%11010111,%10101101,%01101111
 .db	%01110111,%10111101,%01111011,%11011101,%01011110,%11110111
 .db	%10000000
endtxt:
 .db	" New ",0," Password ",0," Help ",0," Quit ",0
mess1txt:
 .db	" Restart ",0," Quit ",0
leveltxt:
 .db	"Level: ",0
passtxt:
 .db	"Pass: ",0
please:
 .db	"Please Enter",0
 .db	"The Password",0 
joke:
 .db	"Too hard? :)",0
select:
 .db	"Secret Level",0
 .db	"Select",0
titletxt:
 .db	"Block Dude - TCPA",0
description:
 .db	"     Block Dude     ",0
blanks:
 .db	"      ",0
endmess:
 .db	"Well done!",0
 .db	"You beat all",0 
 .db	"the levels.",0

;---------= XOR a sprite =---------
; b=size of sprite
; l=yc
; a=xc
; ix holds pointer
smsprt:	ld	e,l
	ld	h,$00
	ld	d,h
	add	hl,de
	add	hl,de
	add	hl,hl
	add	hl,hl
	ld	e,a
	and	$07
	ld	c,a
	srl	e
	srl	e
	srl	e
	add	hl,de
	ld	de,GRAPH_MEM
	add	hl,de
sl1:	ld	d,(ix)
	ld	e,$00
	ld	a,c
	or	a
	jr	z,sl3
sl2:	srl	d
	rr	e
	dec	a
	jr	nz,sl2
sl3:	ld	a,(hl)
	xor	d
	ld	(hl),a
	inc	hl
	ld	a,(hl)
	xor	e
	ld	(hl),a
	ld	de,$0B
	add	hl,de
	inc	ix
	djnz	sl1
	ret
.end
END