.nolist
    #include      "ti83plus.inc"
    #include	  "mirage.inc"
.list
.org    $9D93
.db    t2ByteTok, tAsmCmp


	ret					;So TIOS wont run the program
	.db	1				;Identifier as MirageOS program
	.db	%00011000,%00000000		;15x15 button
	.db	%10111000,%00000000
	.db	%10111000,%00000010
	.db	%10111000,%00000010
	.db	%11111000,%00000010
	.db	%00011000,%00000010
	.db	%01111000,%00000000
	.db	%00111000,%00000000
	.db	%01111000,%00000000
	.db	%00011101,%00010000
	.db	%11111101,%10111100
	.db	%00011111,%11111100
	.db	%10111111,%11111100
	.db	%10111111,%11111100
	.db	%10111111,%11111100	;32 bytes past $9D95
	.db	"Tetris Marathon v1.1",0		;44

#define	DWAIT	IN A, ($10) \ AND %10010000 \ JR	NZ, $-4 

tempVars	equ	appBackUpScreen
contrastSave	equ	tempVars	;1
leftMask	equ	contrastSave+1	;1
rightMask	equ	leftMask+1	;1
temp1		equ	rightMask+1	;3
temp2		equ	temp1+3		;3
temp3		equ	temp2+3		;3
tempDisp	equ	temp3+3		;4
sidewaysCounter	equ	tempDisp+4	;1
upPressed	equ	sidewaysCounter+1	;1
xtonPressed	equ	upPressed+1	;1
statPressed	equ	xtonPressed+1	;1
_2ndPressed	equ	statPressed+1	;1
alphaPressed	equ	_2ndPressed+1	;1
modePressed	equ	alphaPressed+1	;1
saveDE		equ	modePressed+1	;2
saveHL		equ	saveDE+2	;2	
saveSP		equ	saveHL+2	;2
contrastPressed	equ	saveSP+2	;1
downPressed	equ	contrastPressed+1	;1


varStart	equ	$9A02
score		equ	varStart	;3
goal		equ	score+3		;1
combo		equ	goal+1		;1
level		equ	combo+1		;1
queue		equ	level+1		;11
hold		equ	queue+11	;1
blockDisp	equ	hold+1		;4
blockType	equ	blockDisp+4	;1
grid		equ	blockType+1	;95	19X(10/2)
blockY		equ	grid+95		;1
blockX		equ	blockY+1	;1
blockWidth	equ	blockX+1	;1
dropCounter	equ	blockWidth+1	;1
dropSave	equ	dropCounter+1	;1
holded		equ	dropSave+1	;1
setCounter	equ	holded+1	;1	move 0 drop FF
linesPerDrop	equ	setCounter+1	;1
dropOverride	equ	linesPerDrop+1	;1	should set FF don't set 00
overrideCounter	equ	dropOverride+1	;1


varEnd		equ	overrideCounter+1	;1


	in	a, (2)
	and	%00100000
	jr	nz, moreTop

	bcall(_homeUp)
	ld	hl, _83text
	bcall(_PutS)
loop83:
	bcall(_GetCSC)
	cp	skGraph
	jr	z, moreTop
	or	a
	ret	nz
	jr	loop83

moreTop:	
	ld	a, (contrast)
	ld	(contrastSave), a
	set	7, (iy + 20)	;small text to graph buffer
	ld	(saveSP), sp

top:
	di

	
	call	clearScreen
	

	set	2, (iy + 50)	;big Font
	ld	hl, startText
	ld	de, 8*256+5
	ld	(penCol), de
	bcall(_vPutS)
	ld	de, 8*256+44
	ld	(penCol), de
	bcall(_vPutS)
	res	2, (iy + 50)
	ld	de, 18*256+20
	ld	(penCol), de
	bcall(_vPutS)
	ld	de, 24*256+78
	ld	(penCol), de
	bcall(_vPutS)
	ld	hl, highName1
	ld	de, 16*256+34
	call	putCenterText
	ld	hl, highName2
	ld	de, 16*256+44
	call	putCenterText
	ld	hl, highName3
	ld	de, 16*256+54
	call	putCenterText

	call	convert2Gray
	
;draw the gray section 

	ld	hl, plotSScreen+72
	ld	b, 29
titleGrayLoop:
	push	bc
	inc	hl		;move to light buffer
	ld	(hl), %00001111
	inc	hl
	inc	hl
	ld	b, 10
titleLoop:
	ld	(hl), %11111111
	inc	hl
	inc	hl
	djnz	titleLoop
	ld	(hl), %11110000
	inc	hl
	pop	bc
	djnz	titleGrayLoop

	ld	hl, saveSScreen+9
	ld	b, 29
	ld	de, 18	
titleGrayLoop2:
	push	bc
	ld	(hl), %00111111
	ld	b, 2
	inc	hl
	inc	hl
titleLoop2:
	ld	(hl), %11111111
	inc	hl
	inc	hl
	djnz	titleLoop2
	ld	(hl), %11111100
	add	hl, de
	pop	bc
	djnz	titleGrayLoop2	

;draw the high score numbers

	ld	hl, highScores
	ld	b, 3
	ld	de, 91*256+35
	ld	(saveDE), de
titleLoop3:
	push	bc
	ld	de, temp1
	ld	bc, 3
	ldir
	push	hl
	call	convHex
	ld	c, 0
	ld	de, (saveDE)
	call	smallFont
	ld	hl, 10
	ld	de, (saveDE)
	add	hl, de
	ld	(saveDE), hl
	pop	hl
	pop	bc
	djnz	titleLoop3

	ld	c, 2
	ld	de, 3*256+92
	call	grayHorizontalLine
	ld	c, 31
	ld	de, 3*256+33
	call	grayHorizontalLine
	ld	c, 31
	ld	de, 62*256+92
	call	grayHorizontalLine
	ld	c, 61
	ld	de, 33*256+62
	call	grayHorizontalLine
	ld	c, 3
	ld	de, 2*256+31
	call	grayVerticalLine
	ld	c, 33
	ld	de, 31*256+61
	call	grayVerticalLine
	ld	c, 62
	ld	de, 31*256+61
	call	grayVerticalLine
	ld	c, 92
	ld	de, 2*256+31
	call	grayVerticalLine
	
	ld	c, 16
	ld	de, 5*256+90
	call	grayHorizontalLine
	ld	c, 42
	ld	de, 1*256+31
	push	de
	call	grayHorizontalLine
	pop	de
	ld	c, 52
	call	grayHorizontalLine
	ld	c, 42
	ld	de, 64*256+94
	push	de
	call	grayHorizontalLine
	pop	de
	ld	c, 52
	call	grayHorizontalLine







	call	setUpGray
	call	$9898

titleWaitLoop:
	xor	a
	call	keyScan
	ld	a, b
	inc	a	;cp $FF 
	jr	nz, titleWaitLoop

	call	waitAThird

titleKeyLoop:
	ld	a, $FD	
	call	keyScan
	bit	6, b
	jp	z, quit
	bit	1, b
	call	z, raiseContrast
	bit	2, b
	call	z, lowerContrast
	call	contrastButtonHand

	ld	a, $EF
	call	keyScan
	bit	0, b
	jp	z, deleteHigh

	ld	a, $BF
	call	keyScan
	bit	5, b
	jr	nz, titleKeyLoop





;game part

gameStart:
	di
	call	clearScreen

	ld	hl, varStart
	ld	de, varStart+1
	ld	bc, varEnd-VarStart
	ld	(hl), 0
	ldir

	ld	hl, appVarName
	rst	20h
	bcall(_chkFindSym)
	jr	c, notSaved
	ld	a, b
	errhandon(errorz)
	or	a
	jr	z, alreadyRam
	bcall(_Arc_Unarc)
alreadyRam:
	ld	hl, appVarName
	rst	20h
	bcall(_chkFindSym)
	inc	de
	inc	de
	ex	de, hl
	ld	de, varStart
	ld	bc, varEnd-VarStart
	ldir

	bcall(_chkFindSym)
	bcall(_DelVar)
	
	call	setUpGray
	call	waitDone
	errhandoff()
	call	drawPlayingScreen
	call	$9898
	jp	pause
	


notSaved:
	ld	a, 60
	ld	(dropSave), a
	ld	a, 1
	ld	(level), a
	ld	(linesPerDrop), a
	ld	a, 5
	ld	(goal), a
	xor	a
	ld	(hold), a
	ld	(setCounter), a
	ld	(overrideCounter), a
	ld	a, $FF
	ld	(holded), a	

	ld	hl, queue
	ld	de, queue+1
	ld	bc, 10
	ld	(hl), 0
	ldir
	call	reloadQueue
	ld	b, 5
initQueue:
	push	bc
	call	increaseQueue
	pop	bc
	djnz	initQueue
	
	call	newTet

	call	drawPlayingScreen

	call	dispGhost
	call	dispCurrent

	call	waitDone

	call	setUpGray
	call	$9898

;#################################


gameLoop:
	ld	a, $FD
	call	keyScan
	bit	6, b
	jr	z, quit
	bit	1, b
	call	z, raiseContrast
	bit	2, b
	call	z, lowerContrast

	call	contrastButtonHand

	call	dispTheNumbers

	call	moveTet

	ld	a, (setCounter)
	or	a
	jr	z, atZero
	dec	a
	ld	(setCounter), a
atZero:


	ld	a, (overrideCounter)
	or	a
	jr	z, itsZeroz
	dec	a
	ld	(overrideCounter), a
	or	a
	jr	nz, itsZeroz
	ld	a, (dropOverride)
	cpl
	ld	(dropOverride), a
	or	a
	jr	z, itsZeroz
	ld	a, 30
	ld	(overrideCounter), a
itsZeroz:
	
	call	doTheDrop

	call	waitLoop


	jr	gameLoop


;##############

quit:
	call	disableGray
	DWAIT
	ld	a, (contrastSave)
	ld	(contrast), a
	ADD	A, $18 | $C0
	out	($10), a


	ld	hl, name
	rst	20h
	bcall(_chkFindSym)
	ld	de, ($96A5)
	or	a
	sbc	hl, de
	ld	a, h
	add	hl, de
	or	a
	ret	nz
	ld	($96A5), hl
	ret


name:
	.db	protProgObj, "TETRISM", 0

;#############

deleteHigh:
	call	disableGray
	bcall(_ClrLCDFull)
	ld	hl, delText
	ld	de, $0000
	ld	(curRow), de
	bcall(_putS)
	ld	de, $0401
	ld	(curRow), de
	bcall(_putS)
	ld	de, $0003
	ld	(curRow), de
	bcall(_PutS)
	ld	de, $0004
	ld	(curRow), de
	bcall(_PutS)
deleWaitLoop:
	xor	a
	call	keyScan
	cp	b
	jr	nz, deleWaitLoop
	call	waitAThird
deleLoop:
	xor	a
	call	keyScan
	cp	b
	jr	z, deleLoop
	bit	7, b
	jp	nz, top
	ld	a, $BF
	call	keyScan
	bit	7, b
	jp	nz, top
	
	ld	hl, highStart
	ld	de, highStart+1
	ld	bc, highEnd-highStart
	ld	(hl), 0
	ldir
	jp	top
	

;##############


pause:
	ld	hl, varEnd
	ld	de, varEnd+1
	ld	bc, 4
	ld	(hl), 0
	ldir
	ld	b, 16
	ld	de, 54*256+0
pauseClrLoop:
	ld	hl, varEnd
	push	bc
	push	de
	call	dispARow
	pop	de
	ld	a, 4
	add	a, e
	ld	e, a
	pop	bc
	djnz	pauseClrLoop
	
	ld	hl, pauseText
	ld	de, 64*256+27
	ld	b, 5
	call	putGrayText
pauseLoop:
	ld	a, $BF
	call	keyScan
	bit	7, b
	jp	z, saveGame
	bit	6, b
	jr	z, itWasPressed
	ld	a, (modePressed)
	or	a
	ld	a, $FF
	ld	(modePressed), a	
	call	z, waitAThird
	jr	pauseLoop
itWasPressed:
	ld	a, (modePressed)
	or	a
	jr	z, pauseLoop
	xor	a
	ld	(modePressed), a

	call	dispGrid
	call	dispGhost
	call	dispCurrent

	ld	a, (dropSave)
	ld	(dropCounter), a
	ld	a, 15
	ld	(setCounter), a

	jp	gameLoop
	

;#################

gameOver:
	ld	sp, (saveSP)
	call	dispQueue
	call	dispCurrent
	call	clrTextSpace
	ld	hl, gameOverText1
	ld	de, 57*256+27
	ld	b, 4
	call	putGrayText
	ld	de, 76*256+27
	ld	b, 4
	call	putGrayText
	
gameOverLoop:
	ld	a, $FD
	call	keyScan
	bit	6, b
	jr	nz, gameOverLoop
gamedOver:

	ld	de, highScores+2
	ld	b, 3
highCheckLoop:
	ld	hl, score+2
	ld	a, (de)
	ld	c, a
	ld	a, (hl)
	cp	c
	jr	nc, soFarSoGood
	inc	de
	inc	de
	inc	de
	djnz	highCheckLoop
	jp	top
soFarSoGood:
	jr	z, soFarSoGood2
	dec	de
	dec	de
	jr	thisScore
soFarSoGood2:
	dec	hl
	push	de
	ld	d, (hl)
	dec	hl
	ld	e, (hl)
	ex	de, hl
	ex	(sp), hl
	dec	hl
	ld	d, (hl)
	dec	hl
	ld	e, (hl)
	ex	(sp), hl
	ex	de, hl
	or	a
	sbc	hl, de
	add	hl, de
	pop	hl
	jr	c, thisScoreEarly
	ld	de ,5
	add	hl, de
	ex	de, hl
	djnz	highCheckLoop
	
	jp	top

thisScoreEarly:
	ex	de, hl
thisScore:
	push	bc
	push	de
	dec	b
	jr	z, shiftDone
	dec	b
	ld	hl, highScores+3
	ld	de, highScores+6
	ld	bc, 3
	ldir
	ld	hl, highName2
	ld	de, highName3
	ld	bc, 9
	ldir
	jr	z, shiftDone
	ld	hl, highScores
	ld	de, highScores+3
	ld	bc, 3
	ldir
	ld	hl, highName1
	ld	de, highName2
	ld	bc, 9
	ldir
shiftDone:
	pop	de
	ld	hl, score
	ld	bc, 3
	ldir
	
	call	disableGray
	call	clearScreen
	bcall(_ClrLCDFull)

	ld	hl, highText
	ld	de, 1*256+1
	ld	(curRow), de
	bcall(_putS)

	pop	bc
	ld	hl, highName3
	dec	b
	jr	z, nameFound
	ld	hl, highName2
	dec	b
	jr	z, nameFound
	ld	hl, highName1
nameFound:

	call	typeName
	jp	top


;###############
youWin:
	ld	sp, (saveSP)
	call	dispQueue
	xor	a
	ld	(goal), a
	ld	a, 15
	ld	(level), a
	call	dispTheNumbers
	call	clrTextSpace
	ld	hl, youWinText1
	ld	de, 60*256+27
	ld	b, 3
	call	putGrayText
	ld	de, 77*256+27
	ld	b, 3
	call	putGrayText
	jp	gameOverLoop

;###############
errorz:
	ld	sp, (saveSP)
	call	disableGray
	bcall(_clrLCDFull)
	bcall(_homeUp)
	ld	hl, errorText
	bcall(_putS)
errorLoop:
	ld	a, $FD
	call	keyScan
	bit	6, b
	jr	nz, errorLoop
	ret
	


;###############
interrupt:
	exx
	ex	af, af'
	xor	a
	out	(03), a
	ld	a, $45
	out	($30), a
	ld	a, 2
	out	($31), a
	ld	a, 32	;64 fps
	out	($32), a

	call	grayCopy
	ex	af, af'
	exx
	ei
	ret



interruptEnd:



;####################################
;wait a third of a second
;input: none
;output: none

waitAthird:
	call	waitDone
	ld	b, 10
thirdLoop:
	push	bc
	call	waitLoop
	pop	bc
	djnz	thirdLoop
	ret


;####################################
contrastButtonHand:
	ld	a, (contrastPressed)
	cp	$FF
	ret	z
	dec	a
	ld	(contrastPressed), a
	ret

;######################################
;raise Contrast
raiseContrast:
	ld	a, (contrastPressed)
	inc	a
	ld	a, 1
	ld	(contrastPressed), a
	ret	nz
	ld	a, (contrast)
	cp	39
	ret	z
	inc	a
	ld	(contrast), a
	add	a, $18 | $C0
	out	($10), a
	ret

;#####################################
;lower contrast
lowerContrast:
	ld	a, (contrastPressed)
	inc	a
	ld	a, 1
	ld	(contrastPressed), a
	ret	nz
	ld	a, (contrast)
	or	a
	ret	z
	dec	a
	ld	(contrast), a
	add	a, $18 | $C0
	out	($10), a
	ret
	



;######################################
;disable gray scale
disableGray:
	di
	im	1
	xor	a
	out	($30), a
	out	($31), a
	out	($33), a
	out	($34), a
	ld	a, %00001011
	out	(03), a
	ret


;#####################################
;Type name
;Input: hl = where to put typing
;output: name at hl

bufSize		equ	8

typeName:
	ld	(saveHL), hl
	ex	de, hl
	ei
	set	curAble, (iy + curFlags)
	ld	b, 0
	
	ld	hl, $0003
	ld	(curRow), hl
typeLoop:
	bcall(_GetCSC)
	or	a
	jr	z, typeLoop

	cp	skEnter
	jr	nz, notEnter

	xor	a
	ld	(de), a
	call	curOff
	res	curAble, (iy + curFlags)
	ret

notEnter:
	cp	skDel
	jr	z, delTa
	cp	skLeft
	jr	nz, notBackSpace
delTa:
	ld	a, b
	or	a
	jr	z, typeLoop
	call	curOff

	ld	hl, curCol
	dec	(hl)

	dec	de
	dec	b
	ld	a, ' '
	bcall(_PutMap)
	
	call	cursorOn
	jr	typeLoop

notBackSpace:
	cp	skClear
	jr	nz, notClear
	ld	a, b
	or	a
	jr	z, typeLoop

	call	curOff
	xor	a
	ld	(curCol), a
	ld	a, ' '
clearLoop:
	bcall(_putC)
	djnz	clearLoop
	ld	de, (saveHL)
	xor	a
	ld	(curCol), a
	call	cursorOn
	jr	typeLoop
	
notClear:
	ld	c, a
	ld	a, b
	cp	bufSize
	jr	z, typeLoop
	ld	a, c

	sub	skAdd
	jr	c, typeLoop
	cp	skMath-skAdd+1
	jr	nc, typeLoop

	ld	hl, charTable
	push	bc
	ld	c, a
	ld	b, 0
	add	hl, bc
	pop	bc
	call	curOff	;destroys A not HL
	ld	a, (hl)
	or	a
	jr	z, justKidding
	
	ld	(de), a
	inc	de
	inc	b

	bcall(_PutC)

	call	cursorOn
	jp	typeLoop

justKidding:
	call	cursorOn
	jp	typeLoop

cursorOn:
	res	curOn, (iy + curFlags)
	jr	readyk
curOff:
	set	curOn, (iy + curFlags)
readyk:
	ld	a, 1
	ld	(curTime), a
	ei
	halt
	ret


charTable:
	.db	$27, "WRMH", 0, 0
	.db	"?", $5B, "VQLG", 0, 0
	.db	":ZUPKFC", 0
	.db	" YTOJEB", 0, 0
	.db	"XSNIDA"


;#####################################
;put gray text that only works in this prog
;input: hl = start of text
;	de = xy of first
;	b = number of chars
;output: hl = byte after end

putGrayText:
	push	bc
	push	de
	push	hl
	ld	a, (hl)
	call	drawSquare
	pop	hl
	pop	de
	push	de
	ld	a, 4
	add	a, e
	ld	e, a
	inc	hl
	ld	a, (hl)
	inc	hl
	push	hl
	call	drawSquare
	pop	hl
	pop	de
	ld	a, 4
	add	a, d
	ld	d, a
	pop	bc
	djnz	putGrayText
	ret



;#####################################
;clear text space
;input: none
;output: space is cleared

clrTextSpace:
	ld	hl, grid+45
	ld	de, grid+46
	ld	bc, 14
	ld	(hl), 0
	push	hl
	ldir
	pop	hl
	ld	de, 54*256+24
	ld	b, 3
clrTextLoop:
	push	de
	push	bc
	call	dispARow
	pop	bc
	pop	de
	ld	a, 4
	add	a, e
	ld	e, a
	djnz	clrTextLoop
	ret

;####################################
;key scan
;input: a = group
;output: b = buttons
;destorys: a

keyScan:
	out	(01), a
	nop
	nop
	nop
	nop
	in	a, (01)
	ld	b, a
	ld	a, $FF
	out	(01), a
	ret


;####################################
;display small center aligned text
;input: hl = start of text
;	de = xy of center 

putCenterText:
	push	hl
	ld	b, 0
centerLoopz:
	ld	a, (hl)
	or	a
	jr	z, lengthFound
	inc	hl
	inc	b
	jr	centerLoopz
lengthFound:
	pop	hl
	ld	a, b
	or	a
	ret	z

	ex	de, hl
	call	centerAlign
	ex	de, hl

	ld	a, e
	ld	e, d
	ld	d, a
	
	ld	(penCol), de
	bcall(_vPutS)
	ret




;#####################################
setUpGray:
	ld	a, $FF
	out	($20), a

	ld	de, $9898
	ld	hl, interrupt
	ld	bc, interruptEnd-interrupt
	ldir

	ld	de, $9901
	ld	hl, $9900
	ld	bc, 256
	ld	(hl), $98
	ldir

	im	2
	ld	a, $99
	ld	i, a

	xor	a
	out	(03), a
	ret



;######################################
;draw the playing field

drawPlayingScreen:
	ld	hl, gameText
	ld	de, 15*256+8
	ld	(penCol), de
	bcall(_vPutS)
	ld	de, 31*256+10
	ld	(penCol), de
	bcall(_vPutS)
	ld	de, 47*256+8
	ld	(penCol), de
	bcall(_vPutS)

	call	convert2Gray 

	ld	l, 1
	ld	de, 0*256+53
	ld	bc, 2*256+0
	call	multipleHoriz
	ld	bc, 3*256+61
	call	multipleHoriz

	ld	l, 12
	ld	de, 32*256+53
	ld	bc, 4*256+13
	call	multipleHoriz


	ld	l, 3
	ld	bc, 2*256+13
	ld	de, 0*256+33
moreLinesLoop:
	push	hl
	ld	l, 1
	push	bc
	call	multipleHoriz
	pop	bc
	pop	hl
	ld	a, 16
	add	a, c
	ld	c, a
	dec	l
	jr	nz, moreLinesLoop


	ld	de, 0*256+63
	ld	bc, 2*256+0
	call	multipleVert
	ld	bc, 2*256+32
	call	multipleVert
	ld	bc, 2*256+52
	call	multipleVert
	ld	bc, 2*256+94
	call	multipleVert


	ld	de, 0*256+13
	ld	c, 13
	call	grayVerticalLine

	call	dispTheNumbers

	call	dispQueue
	
	ld	a, (hold)
	or	a
	call	nz, dispHold

	call	dispGrid
	ret


;###################################
;clear the screen

clearScreen:
	ld	hl, plotSScreen
	ld	de, plotSScreen+1
	ld	bc, 767
	ld	(hl), 0
	ldir

	ld	hl, saveSScreen
	ld	de, saveSScreen+1
	ld	bc, 767
	ld	(hl), 0
	ldir
	ret
	

;###################################
;check to see if block should drop
doTheDrop:
	ld	a, (dropCounter)
	dec	a
	ld	(dropCounter), a
	jr	nz, dontDrop

	ld	a, (dropSave)
	ld	(dropCounter), a
	ld	a, (linesPerDrop)

	push	af

	call	eraseGhost
	call	eraseCurrent
	
	call	howFarDrop
	pop	bc
	ld	c, 0
	cp	b
	jr	nc, fullMovement
	ld	c, 1
	ld	b, a
fullMovement:
	ld	de, (blockY)
	ld	a, b
	add	a, e
	ld	(blockY), a
	push	bc

	call	dispGhost
	call	dispCurrent

	pop	bc

	ld	a, c
	or	a
	jr	z, dontDrop

	ld	a, (setCounter)
	or	a
	jr	z, timesUp
	ld	a, (dropOverride)
	or	a
	jr	nz, timesUp
skippinAreYa:
	ld	a, (overrideCounter)
	or	a
	jr	nz, dontDrop
	ld	a, 90
	ld	(overrideCounter), a
	jr	dontDrop
timesUp:
	call	setTet

	
dontDrop:
	ret



;###############################
;wait a frame


WaitLoop:
	IN	A, ($34)
	BIT	2, A
	JR	NZ, WaitDone
	IN	A, ($04)
	BIT	6, A
	JR	Z, WaitLoop
WaitDone:
	LD	A, $45
	OUT	($33), A
	XOR	A
	OUT	($34), A
	LD	A, 68
	OUT	($35), A
	ret



;###############################
;add hl to the score
;input: hl

addToScore:
	push	de
	push	af
	push	hl
	ld	de, (score)
	add	hl, de
	ld	(score), hl
	ld	a, (score+2)
	adc	a, 0
	ld	(score+2), a
	pop	hl
	pop	af
	pop	de
	ret


;################################
;set tetrimino and get a new one
;input: none
;output: none

setTet:
	ld	a, $FF
	ld	(holded), a
	ld	de, (blockY)
	call	getGridLoc
	ld	ix, blockDisp
	ld	de, (blockY)
	ld	b, 4
setLoop:
	push	bc
	push	de
	ld	b, 4
	ld	c, (ix)
innerSetLoop:
	sla	c
	jr	nc, noSet

	ld	a, (blockType)
	bit	0, d
	jr	nz, oddIsFine
	rlca
	rlca
	rlca
	rlca
oddIsFine:
	or	(hl)
	ld	(hl), a
noSet:
	bit	0, d
	jr	z, evenIsFine
	inc	hl
evenIsFine:
	inc	d
	djnz	innerSetLoop
	inc	hl
	inc	hl
	inc	hl
	pop	de
	pop	bc
	inc	ix
	djnz	setLoop




	call	clearLines

	
	call	eraseQueue
	call	increaseQueue
	call	newTet
	call	dispQueue
	call	dispGhost
	call	dispCurrent


	ret


;###############################
;erase ghost

eraseGhost:
	xor	a
	ld	(smc_ghost+1), a
	jr	doThis4

;##############################
;calc and disp ghost

dispGhost:
	ld	a, 8
	ld	(smc_ghost+1), a
doThis4:
	call	howFarDrop
	or	a
	ret	z
	ld	b, a
	ld	a, (blockX)
	sla	a
	sla	a
	add	a, 54
	ld	d, a
	ld	a, (blockY)
	add	a, b
	sla	a
	sla	a
	sub	12
	ld	e, a
smc_ghost:
	ld	a, 8
	call	dispTet
	ret
	
	



;##############################
;how far can it drop?
;output: a = distance you can drop block

howFarDrop:
	xor	a
	ld	de, tempDisp
	ld	hl, blockDisp
	ld	bc, 4
	ldir
	ld	de, (blockY)
howFarLoop:
	push	af
	inc	e
	push	de
	call	testTet
	jr	c, farDone
	pop	de
	pop	af
	inc	a
	jr	howFarLoop

farDone:
	pop	de
	pop	af
	ret




;##############################
;clear lines
clearLines:
	ld	hl, grid
	ld	c, 0
	ld	de, 0
lineCheckLoop:
	ld	b, 10
	push	de
	push	hl
lineCheckInnerLoop:
	ld	a, (hl)
	bit	0, d
	jr	z, moreEven
	rlca
	rlca
	rlca
	rlca
moreEven:
	and	%11110000
	jr	z, notThisRow
	bit	0, d
	jr	z, evenMoreEven
	inc	hl
evenMoreEven:
	inc	d
	djnz	lineCheckInnerLoop
	
	inc	c
	push	bc
	push	de
	push	hl

	ld	a, e
	sla	e
	sla	e
	add	a, e
	ld	d, 0
	ld	b, d
	ld	e, a
	ld	c, a
	ld	hl, grid
	add	hl, de

	dec	hl
	pop	de
	dec	de
	
	lddr

	pop	de
	call	shiftDown

	pop	bc
notThisRow:
	pop	hl
	ld	de, 5
	add	hl, de
	pop	de
	inc	e
	ld	a, e
	cp	19
	jr	nz, lineCheckLoop

	ld	a, c
	or	a
	jr	nz, cleared

	xor	a
	ld	(combo), a
	ret
cleared:
	dec	c
	ld	b, 0
	push	bc
	sla	c
	ld	hl, lineScoreChart
	add	hl, bc
	ld	e, (hl)
	inc	hl
	ld	d, (hl)
	ex	de, hl
	ld	a, (level)
	ld	e, a
	call	multHLbyE

	call	addToScore

	ld	a, (combo)
	ld	hl, 50
	ld	e, a
	call	multHLbyE
	ld	a, (level)
	ld	e, a
	call	multHLbyE
	call	addToScore

	ld	a, (combo)
	inc	a
	ld	(combo), a

	pop	bc
	add	a, c
	ld	b, a
	ld	a, (goal)
	sub	b
	ld	(goal), a
	jr	z, onZero
	ret	nc
onZero:
	ld	a, (level)
	inc	a
	ld	(level), a
	cp	16
	jp	z, youWin
	ld	e, a
	ld	hl, 5
	call	multHlbyE

	ld	a, l
	ld	(goal), a

	ld	a, (dropSave)
	srl	a
	ld	b, a
	srl	b
	add	a, b
	or	a
	jr	nz, notZero
	ld	a, (linesPerDrop)
	sla	a
	ld	(linesPerDrop), a
	ld	a, 1

notZero:
	ld	(dropSave), a

	call	levelAnimation

	ret


lineScoreChart:
	.dw	100, 300, 500, 800




;##############################
;display the cool level up animation

levelAnimation:
	ld	b, 19
animationLoop:
	push	bc
	ld	a, b
	cp	17
	jr	nc, noPutBackYet	

	add	a, 2
	ld	e, a
	ld	d, 0
	push	af

	call	getGridLoc

	pop	af
	sub	3
	rlca	
	rlca	
	ld	e, a
	ld	d, 54

	call	dispARow

noPutBackYet:
	pop	bc
	push	bc
	ld	a, -5
	add	a, b
	rlca
	rlca
	ld	e, a
	ld	d, 54
	ld	b, 10
dispLevelUpLoop:
	push	bc
	push	de
	ld	a, 9
	call	drawSquare
	pop	de
	ld	a, 4
	add	a, d
	ld	d, a
	pop	bc
	djnz	dispLevelUpLoop
	
	call	waitLoop

	pop	bc
	djnz	animationLoop

	ret
	



;##############################
;display a row
;input: hl = grid location
;	de = xy of first

dispARow:
	ld	b, 10
dispGridInnerLoop:
	push	bc
	push	hl
	push	de

	ld	a, (hl)
	bit	2, d
	jr	z, itsOddish
	rrca
	rrca
	rrca
	rrca
itsOddish:
	and	%00001111
	call	drawSquare
	pop	de
	pop	hl
	bit	2, d
	jr	nz, itsEvenAgain
	inc	hl
itsEvenAgain:
	ld	a, 4
	add	a, d
	ld	d, a
	pop	bc
	djnz	dispGridInnerLoop

	ret

	
;#############################
;shift the screen rows down
;input: e = row to kill
shiftDown:
	ld	a, e
	cp	4
	ret	c
	sub	3
	rlca
	rlca
	ld	b, a
	ld	e, a
	dec	e
	ld	d, 48
	call	grayGetPixel
	ex	de, hl
	ld	hl, 24*4
	add	hl, de
	call	checkBufCross
	ex	de, hl
rowDownLoop:
	push	bc
	ld	b, 2
quickLoop:
	ld	a, (de)
	and	%11111100
	ld	c, a
	ld	a, (hl)
	and	%00000011
	or	c
	ld	(de), a
	inc	hl
	inc	de
	djnz	quickLoop
	ld	bc, 10
	ldir
	push	de
	ld	de, -36
	add	hl, de
	call	checkBufCross
	ex	(sp), hl
	add	hl, de
	call	checkBufCross
	ex	(sp), hl
	pop	de
	pop	bc
	djnz	rowDownLoop

	ld	b, 4
	ld	de, 54*256+0
	ld	hl, grid+15
moreLooping:
	push	de
	push	bc
	call	dispARow
	pop	bc
	pop	de
	ld	a, 4
	add	a, e
	ld	e, a
	djnz	moreLooping
	



	ret




;#############################
;display the grid
dispGrid:
doThis3:
	ld	hl, grid+15
	ld	de, 54*256+0
	ld	b, 16
dispGridLoop:
	push	bc
	push	de
	call	dispARow
	pop	de
	pop	bc
	ld	a, 4
	add	a, e
	ld	e, a
	djnz	dispGridLoop

	ret








;##############################
;move the current tetrimino

moveTet:
	ld	a, $FE
	call	keyScan
	ld	a, b
	and	%00000110
	jr	z, noSideways		;both equals none
	cp	%00000110
	jr	z, noSideways	;gotta press at least one


	ld	a, (sideWaysCounter)
	cp	$FF
	jr	z, firstMove
	or	a
	jr	z, secondMove
	dec	a
	ld	(sideWaysCounter), a
	jr	sideDone

firstMove:
	ld	a, 9
secondMove:
	inc	a
	ld	(sideWaysCounter), a
	push	bc
	bit	1, b
	jr	z, toMoveLeft
toMoveRight:
	call	moveRight
	pop	bc
	ld	a, 15
	ld	(setCounter), a
	jr	sideDone

toMoveLeft:
	call	MoveLeft
	pop	bc
	ld	a, 15
	ld	(setCounter), a
	jr	sideDone

noSideWays:
	ld	a, $FF
	ld	(sidewaysCounter), a
sideDone:

	push	bc
	bit	3, b
	jr	nz, notUp


	ld	a, (upPressed)
	inc	a	;cp $FF
	jr	nz, upDone

	xor	a
	ld	(upPressed), a
	ld	a, 15
	ld	(setCounter), a

_2ndEntry:

	call	eraseCurrent
	call	eraseGhost


	ld	hl, blockDisp
	ld	de, tempDisp
	ld	bc, 4
	ldir
	
	call	clockRotate
	ld	de, (blockY)
	call	testTet
	call	c, wallBounce
	jr	c, dontRotate

	ld	hl, tempDisp
	ld	de, blockDisp
	ld	bc, 4
	ldir

dontRotate:
	call	dispGhost
	call	dispCurrent
	jr	upDone

notUp:
	ld	a, $FF
	ld	(upPressed), a

upDone:
	pop	bc

	bit	0, b
	jr	nz, notDown

	ld	a, (downPressed)
	inc	a	;cp $FF
	jr	nz, notDown

	xor	a
	ld	(downPressed), a
	
	call	moveDown	
	jr	c, arrowsDone

	ld	a, (dropSave)
	ld	(dropCounter), a

	ld	hl, 1
	call	addToScore
	jr	arrowsDone

	
notDown:
	ld	a, $FF
	ld	(downPressed), a

arrowsDone:
	ld	a, $EF
	call	keyScan
	bit	7, b
	jr	nz, noHardDrop

	ld	a, (xtonPressed)
	cp	255
	ret	nz
	xor	a
	ld	(xtonPressed), a
	
	call	eraseCurrent
	call	eraseGhost

	call	howFarDrop
	
	ld	l, a
	sla	l
	ld	h, 0
	call	addToScore
	
	ld	de, (blockY)
	add	a, e
	ld	e, a
	ld	(blockY), a

	call	dispCurrent
	call	setTet
	jr	hardDropDone
		
noHardDrop:
	ld	a, $FF
	ld	(xtonPressed), a
hardDropDone:
	
	ld	a, $F7
	call	keyScan
	bit	7, b
	jr	nz, noStat

	ld	a, (statPressed)
	inc	a	;cp $FF
	ret	nz

	xor	a
	ld	(statPressed), a

	ld	a, (holded)
	inc	a	;cp $FF
	ret	nz

	xor	a
	ld	(holded), a
	
	call	eraseGhost
	call	eraseCurrent

	ld	a, (hold)
	or	a
	jr	z, noHold

	call	eraseHold
	call	eraseGhost
	call	eraseCurrent
	ld	a, (hold)
	ld	b, a
	ld	a, (blockType)
	ld	(hold), a
	ld	a, b
	jr	holdCombine




noHold:
	ld	a, (blockType)
	ld	(hold), a
	call	eraseQueue
	call	increaseQueue

holdCombine:
	call	newTet
	call	dispQueue
	call	dispGhost
	call	dispCurrent
	call	dispHold
	jr	holdDone



noStat:
	ld	a, $FF
	ld	(statPressed), a
holdDone:
	ld	a, $BF
	call	keyScan
	bit	5, b
	jr	nz, no2nd
	ld	a, (_2ndPressed)
	inc	a	;cp $FF
	jr	nz, _2ndDone
	
	xor	a
	ld	(_2ndPressed), a
	ld	a, 15
	ld	(setCounter), a
	ld	b, $FF
	push	bc
	jp	_2ndEntry

no2nd:
	ld	a, $FF
	ld	(_2ndPressed), a
_2ndDone:
	bit	6, b
	jr	nz, noMode
	ld	a, (modePressed)
	or	a
	jr	z, modeDone
	xor	a
	ld	(modePressed), a
	pop	af
	jp	pause
noMode:
	ld	a, $FF
	ld	(modePressed), a
modeDone:
	bit	7, b
	jr	nz, noDel
	pop	af
	jr	saveGame
noDel:
	ld	a, $DF
	call	keyScan
	bit	7, b
	jr	nz, noAlpha
	ld	a, (alphaPressed)
	inc	a 	;cp $FF
	ret	nz

	xor	a
	ld	(alphaPressed), a
	ld	a, 15
	ld	(setCounter), a
	
	call	eraseCurrent
	call	eraseGhost


	ld	hl, blockDisp
	ld	de, tempDisp
	ld	bc, 4
	ldir
	
	call	counterRotate
	ld	de, (blockY)
	call	testTet
	call	c, wallBounce
	jr	c, dontRotate2

	ld	hl, tempDisp
	ld	de, blockDisp
	ld	bc, 4
	ldir

dontRotate2:
	call	dispGhost
	call	dispCurrent
	ret
	
noAlpha:
	ld	a, $FF
	ld	(alphaPressed), a
	ret


;#####################################
;save game

saveGame:
	errhandon(errorz)
	ld	hl, appVarName
	rst	20h
	bcall(_chkFindSym)
	jr	c, notHere2
	bcall(_delVarArc)
notHere2:
	ld	hl, varEnd-VarStart
	bcall(_createAppVar)

	inc	de
	inc	de
	
	ld	hl, varStart
	ld	bc, varEnd-VarStart
	ldir

	ld	hl, appVarName
	rst	20h
	bcall(_Arc_Unarc)

	errhandoff()

	
	jp	quit

	



;#####################################
;Wall bounce
;input: tempDisp with blockDisp
;output: changes (blockY)
;	carry set if fail

wallBounce:
	ld	de, (blockY)
	call	outerBounceTest
	inc	e
	call	outerBounceTest
	dec	e
	dec	e
	call	outerBounceTest
	inc	e
	inc	e
	inc	e
	call	outerBounceTest
	dec	e
	dec	e
	dec	e
	dec	e
	call	outerBounceTest
	scf
	ret

outerBounceTest:
	call	bounceTest
	dec	d
	call	bounceTest
	inc	d
	inc	d
	call	bounceTest
	dec	d
	ret


bounceTest:
	push	de
	call	testTet
	pop	de
	ret	c
	pop	af
	pop	af
	ld	(blockY), de
	or	a
	ret





;#####################################
;erase hold

eraseHold:
	ld	a, $AF
	ld	(smc_hold), a
	jr	doThis5
;####################################
;disp the hold

dispHold:
	xor	a
	ld	(smc_hold), a
doThis5:
	ld	a, (hold)
	push	af
	ld	c, a
	sla	c
	ld	b, 0
	ld	hl, shapes
	add	hl, bc
	ld	b, (hl)
	ld	a, 4
	sub	b
	sla	a
	add	a, 15
	ld	d, a	;x coordinate
	ld	e, 4

	ld	bc, tempDisp
	inc	hl
	call	unpackTet

	pop	af
smc_hold:
	nop
	call	dispTet

	ret

;##################################
;move tetrimino down
;input: none
;output: carry if fail

moveDown:
	ld	a, $1C	;inc	e
	ld	(smc_leftRight), a
	jr	doThis2
;##################################
;move tetrimino right
;input: none
;output: carry if fail

moveRight:
	ld	a, $14	;inc	d
	ld	(smc_leftRight), a
	jr	doThis2
;##################################
;moves tetrimino left
;input: none
;output: carry if fail

moveLeft:
	ld	a, $15	;dec	d
	ld	(smc_leftRight), a
doThis2:
	call	eraseCurrent
	call	eraseGhost
	ld	hl, blockDisp
	ld	de, tempDisp
	ld	bc, 4
	ldir
	ld	de, (blockY)
smc_leftRight:
	dec	d
	push	de
	call	testTet
	pop	de
	push	af
	jr	c, dontMoveLeft
	ld	(blockY), de
dontMoveLeft:
	call	dispGhost
	call	dispCurrent

	pop	af		;keeps the carry set
	ret


;##################################
;get grid location
;input: de = xy
;output: hl = grid location
;destroys: af bc

getGridLoc:
	ld	c, d
	sra	c

	ld	a, e
	rlca
	rlca
	add	a, e
	add	a, c
	ld	c, a
	ld	b, 0
	jp	p, notNeg
	ld	b, $FF
notNeg:
	ld	hl, grid
	add	hl, bc
	ret


;##################################
;test to see if tetrimino will fit
;input: de = desired xy blocks
;	tempDisp = shape
;output: carry set if denied

testTet:
	call	getGridLoc

	ld	ix, tempDisp
	
	ld	b, 4
testLoop:
	push	bc
	push	de
	ld	b, 4
	ld	c, (ix)
innerTestLoop:
	sla	c
	jr	nc, noProb

	ld	a, d
	or	a
	jp	m, fail
	cp	10
	jr	nc, fail

	ld	a, e
	or	a
	jp	m, fail
	cp	19
	jr	nc, fail

	ld	a, (hl)
	bit	0, d
	jr	z, evenNumber
	and	%00001111
	jr	afterEven
evenNumber:
	and	%11110000
afterEven:
	jr	nz, fail
noProb:
	bit	0, d
	jr	z, evenNumber2
	inc	hl
evenNumber2:
	inc	d
	djnz	innerTestLoop
	inc	hl
	inc	hl
	inc	hl
	inc	ix
	pop	de
	inc	e
	pop	bc
	djnz	testLoop

	or	a
	ret

fail:
	pop	af
	pop	af
	scf
	ret



;##############################
;rotate clockwise
;input: none
;output: tempDisp is rotated

clockRotate:
	ld	hl, tempDisp
	push	hl
	ld	b, (hl)
	inc	hl
	ld	c, (hl)
	inc	hl
	ld	d, (hl)
	inc	hl
	ld	e, (hl)
	pop	hl

	ld	a, (blockWidth)
	sub	2
	ret	z
	push	hl
	dec	a
	jr	z, _3Square
	ld	l, 4
_4Loop:
	xor	a
	sla	b
	rra
	sla	c
	rra
	sla	d
	rra
	sla	e
	rra
	ex	(sp), hl
	ld	(hl), a
	inc	hl
	ex	(sp), hl
	dec	l
	jr	nz, _4Loop
	pop	hl
	ret

_3Square:
	ld	l, 3
_3Loop:
	xor	a
	sla	b
	rra
	sla	c
	rra
	sla	d
	rra
	ex	(sp), hl
	ld	(hl), a
	inc	hl
	ex	(sp), hl
	dec	l
	jr	nz, _3Loop
	pop	hl
	ret
	


;##############################
;rotate counterclockwise
;input: none
;output: tempDisp is rotated

counterRotate:
	ld	hl, tempDisp
	push	hl
	ld	b, (hl)
	inc	hl
	ld	c, (hl)
	inc	hl
	ld	d, (hl)
	inc	hl
	ld	e, (hl)
	pop	hl

	ld	a, (blockWidth)
	sub	2
	ret	z
	dec	a
	jr	z, _3Square2
	inc	hl
	inc	hl
	inc	hl
	push	hl
	ld	l, 4
_4Loop2:
	xor	a
	sla	e
	rra
	sla	d
	rra
	sla	c
	rra
	sla	b
	rra
	ex	(sp), hl
	ld	(hl), a
	dec	hl
	ex	(sp), hl
	dec	l
	jr	nz, _4Loop2
	pop	hl
	ret

_3Square2:
	inc	hl
	inc	hl
	push	hl
	ld	l, 3
_3Loop2:
	xor	a
	sla	d
	rra
	sla	c
	rra
	sla	b
	rra
	ex	(sp), hl
	ld	(hl), a
	dec	hl
	ex	(sp), hl
	dec	l
	jr	nz, _3Loop2
	pop	hl
	ret



;##############################
;erases the current tetrimino
;input: none
;output: erased

eraseCurrent:
	ld	a, $AF
	ld	(smc_eraseCurrent), a	
	jr	doThis
;#############################
;display the current tetrimino
;input: none
;output: displayed

dispCurrent:
	xor	a
	ld	(smc_eraseCurrent), a
doThis:
	ld	hl, blockDisp
	ld	de, tempDisp
	ld	bc, 4
	ldir
	ld	a, (blockX)
	sla	a
	sla	a
	add	a, 54
	ld	d, a
	ld	a, (blockY)
	sla	a
	sla	a
	sub	12
	ld	e, a
	ld	a, (blockType)
smc_eraseCurrent:
	nop
	call	dispTet
	ret


;#############################
;start a new tetrimino
;input: a = type
;output: it is initialized

newTet:
	ld	(blockType), a
	ld	e, a
	sla	e
	ld	d, 0
	ld	hl, shapes
	add	hl, de
	ld	a, (hl)
	ld	(blockWidth), a
	ld	e, a
	inc	hl
	ld	bc, blockDisp
	call	unpackTet
	dec	e
	srl	e
	ld	a, 4
	sub	e
	ld	(blockX), a
	ld	a, 2
	ld	(blockY), a
	ld	a, (dropSave)
	ld	(dropCounter), a
	xor	a
	ld	(dropOverride), a
	ld	(overrideCounter), a
	ld	a, 15
	ld	(setCounter), a
	ld	hl, blockDisp
	ld	de, tempDisp
	ld	bc, 4
	ldir
	ld	de, (blockY)
	call	testTet
	ret	nc
	jp	gameOver



;#############################
;convert to dark gray
;input: none
;output: stretches plotSScreen over saveSScreen
;destroys: 
;remarks: useful for text

convert2Gray:
	ld	hl, plotSScreen+767
	ld	de, saveSScreen+766
	call	grayRoutine
	ld	de, plotSScreen+766
	call	grayRoutine
	ret

grayRoutine:
	ld	c, 2
grayLoop:
	ld	b, 192
innerGrayLoop:
	ld	a, (hl)
	ld	(hl), 0
	ld	(de), a
	dec	hl
	dec	de
	dec	de
	djnz	innerGrayLoop
	dec	c
	jr	nz, grayLoop
	ret



;#############################
;multiple horiz
;input: b = number of lines
;	c = y start
;	de = x start end
;	l = add to y factor
multipleHoriz:
	push	hl
	push	de
	push	bc
	call	grayHorizontalLine
	pop	bc
	pop	de
	pop	hl
	ld	a, l
	add	a, c
	ld	c, a
	djnz	multipleHoriz
	ret

;#############################
;multiple vert
;input: b = number of lines
;	c = x start
;	de = y start end
multipleVert:
	push	de
	push	bc
	call	grayVerticalLine
	pop	bc
	pop	de
	inc	c
	djnz	multipleVert
	ret


;#################################

grayCopy:
	ld	a, $80
	out	($10), a

	ld	a, (grayCarry)
	srl	a
	ld	a, (grayMask)
	rla
	ld	(grayMask), a
	push	af
	ld	a, 0
	jr	nc, noCarry
	ld	a, 1
noCarry:
	ld	(grayCarry), a
	ld	hl, plotSScreen
	ld	b, $20

	DWAIT
	ld	a, b
	out	($10), a


outerLoop:
	pop	af
	push	bc
	push	af
innerLoop:
	ld	b, 32
	ld	de, 23
loop:
	pop	af
	rra
	push	af	
	and	(hl)	
	inc	hl	
	ld	c, a	
	pop	af
	push	af	
	cpl		
	and	(hl)	
	or	c	
	ld	c, a
	DWAIT
	ld	a, c
	out	($11), a	
	add	hl, de	
	djnz	loop	


	bit	4, h
	jr	nz, toSaveSScreen
					;so this is at the end of saveSScreen
	ld	de, plotSScreen-SaveSScreen-766
	add	hl, de
	pop	af
	pop	bc
	push	af
	inc	b
	DWAIT
	ld	a, b
	out	($10), a
	cp	$2C
	jr	z, getOut
	
	jr	outerLoop

toSaveSScreen:
	ld	de, saveSScreen-plotSScreen-768
	add	hl, de
	jr	innerLoop

getOut:
	pop	af
	ret



grayMask:
	.db	%10110110
grayCarry:
	.db	1




;################################
;increase the queue up one notch
;input: none
;output: A = next tetrimino
;destroys: f bc de hl

increaseQueue:
	ld	hl, queue+1
	ld	de, queue
	ld	a, (de)
	ld	bc, 10
	ldir
	ex	de, hl
	ld	(hl), 0
	push	af
	ld	a, (queue+4)
	or	a
	call	z, reloadQueue
	pop	af
	ret



;###############################
;reload the queue with 7 different blocks
;input: none
;output: none
;destroys: af bc de hl

reloadQueue:
reloadLoop:
	call	random
	ld	hl, queue+4
	ld	b, 7
	and	%00000111
	jr	z, reloadLoop
innerReloadLoop:
	cp	(hl)
	jr	z, reloadLoop
	inc	hl
	djnz	innerReloadLoop
	
	ld	c, a
	
	xor	a
	ld	hl, queue+4
	ld	b, 6
innerReloadLoop2:
	cp	(hl)
	jr	z, foundASpot
	inc	hl
	djnz	innerReloadLoop2
	ld	(hl), c
	ret
	
foundASpot:
	ld	(hl), c
	jr	reloadLoop
	







	
;################################
eraseQueue:
	ld	a, $AF		;xor a
	ld	(smc_eraseQueue), a
	jr	doTheQueue
;################################
;displays the queue

dispQueue:
	xor	a
	ld	(smc_eraseQueue), a
doTheQueue:
	ld	hl, queue
	ld	b, 5
	ld	e, 4
dispQueueLoop:
	push	bc
	push	hl
	push	de
	ld	a, (hl)
	push	af
	ld	c, a
	sla	c
	ld	b, 0
	ld	hl, shapes
	add	hl, bc
	ld	b, (hl)
	ld	a, 4
	sub	b
	sla	a
	add	a, 35
	ld	d, a	;x coordinate

	ld	bc, tempDisp
	inc	hl
	call	unpackTet

	pop	af
smc_eraseQueue:
	nop
	call	dispTet

	pop	de
	ld	a, 12
	add	a, e
	ld	e, a
	pop	hl
	inc	hl
	pop	bc
	djnz	dispQueueLoop
	ret
	

	






;#################################
;unpacks a tetrimino
;input: bc = loc to unpack to
;	hl = packed data
;destroys: af bc

unpackTet:
	ld	a, (hl)
	and	%11110000
	ld	(bc), a
	inc	bc
	ld	a, (hl)
	and	%00001111
	rlca
	rlca
	rlca
	rlca
	ld	(bc), a
	xor	a
	inc	bc
	ld	(bc), a
	inc	bc
	ld	(bc), a
	ret





;###############################
;display a full tetrimino
;input: a = type
;	de = xy of top left
;	(tempDisp) = shape

dispTet:
	ld	b, 4
	ld	(smc_blockType+1), a
	ld	hl, tempDisp
dispTetLoop:
	push	bc
	push	hl
	push	de
	ld	c, (hl)
	ld	b, 4
innerTetLoop:
	sla	c
	push	bc
	jr	nc, notHere
smc_blockType:
	ld	a, 00
	push	de
	call	drawSquare
	pop	de
notHere:
	ld	a, 4
	add	a, d
	ld	d, a
	pop	bc
	djnz	innerTetLoop
	pop	de
	pop	hl
	inc	hl
	pop	bc
	ld	a, 4
	add	a, e
	ld	e, a
	djnz	dispTetLoop
	ret



;#################################
;gray Vertical Line
;Input:	C = x
;	D = top
;	E = bottom
;Output: a line

grayVerticalLine:
	LD	A, C
	AND	%00000111
	LD	b, A
	LD	A, %10000000
	JR	Z, NoAdjustment
AdjustLoop:
	rrca
	djnz	AdjustLoop
NoAdjustment:	
	push	af

	LD	A, E
	SUB	D
	INC	A
	LD	B, A

	LD	e, D
	LD	d, C

	CALL	grayGetPixel
	
	POP	AF
	LD	C, A
	LD	DE, 23
VerticalLineLoop:
	LD	A, C
	OR	(HL)
	LD	(HL), A
	ld	a, c
	inc	hl
	or	(hl)
	ld	(hl), a
	ADD	HL, DE
	call	checkBufCross
	DJNZ	VerticalLineLoop

	RET



;#################################
;displays score lines and level
;input: none
;output: none

dispTheNumbers:
	ld	de, 5
	call	grayGetPixel
	ld	b, 5
	ld	de, 20
comboClearLoop:
	push	bc
	ld	b, 2
combo1:
	ld	a, (hl)
	and	%11000000
	ld	(hl), a
	inc	hl
	djnz	combo1
	ld	b, 2
combo2:
	ld	a, (hl)
	and	%00000111
	ld	(hl), a
	inc	hl
	djnz	combo2
	add	hl, de
	pop	bc
	djnz	comboClearLoop


	ld	hl, temp1
	ld	a, (combo)
	ld	(hl), a
	inc	hl
	ld	(hl), 0
	inc	hl
	ld	(hl), 0
	call	convHex
	ld	c, 2
	ld	de, 7*256+5
	call	smallFont

	ld	hl, score
	ld	de, temp1
	ld	bc, 3
	ldir
	
	call	convHex
	ld	c, 3
	ld	de, 17*256+23
	call	smallFont

	ld	de, 8*256+39
	call	grayGetPixel
	ld	b, 5
	ld	de, 20
goalClearLoop:
	push	bc
	ld	b, 4
goalLoop:
	ld	(hl), 0
	inc	hl
	djnz	goalLoop
	add	hl, de
	pop	bc
	djnz	goalClearLoop

	ld	hl, temp1
	ld	a, (goal)
	ld	(hl), a
	inc	hl
	ld	(hl), 0
	inc	hl
	ld	(hl), 0

	call	convHex
	ld	c, 3
	ld	de, 17*256+39
	call	smallFont

	ld	a, (level)
	ld	hl, temp1
	ld	(hl), a
	inc	hl
	ld	(hl), 0
	inc	hl
	ld	(hl), 0

	call	convHex
	ld	c, 3
	ld	de, 17*256+55
	call	smallFont
	ret


;############################
;Convert Temp1 to decimal
;Input: (temp1) = 3 byte number
;Output: B = number of numbers
;	stack = number with biggest on top

ConvHex:
	POP	HL
	LD	(smc_ret1+1), HL
	LD	B, 1
ConvHexLoop:
	ld	a, (Temp1+2)
	or	a
	jr	nz, keepGoin

	ld	hl, (temp1)
	LD	DE, 10
	or	a
	sbc	hl, de
	add	hl, de
	JR	C, Next

keepGoin:
	INC	B
	PUSH	BC		;Chars
	ld	hl, temp1
	ld	de, temp2
	ld	bc, 3
	ldir

	LD	E, 10	
	ld	ix, temp1+2
	ld	bc, 3
	call	xDiv

	ld	hl, temp1
	ld	de, temp3
	ld	bc, 3
	ldir

	ld	e, 10
	ld	ix, temp1
	ld	bc, 3
	call	xMult

	
	ld	hl, temp2+2
	ld	de, temp1+2
	call	sub24s

	ld	hl, temp3
	ld	de, temp1
	ld	bc, 3
	ldir

	ld	a, (temp2)
	
	pop	bc
	push	af


	JR	ConvHexLoop
Next:
	ld	a, l
	push	af
smc_ret1:
	jp	0000



sub24s:
	ld	a, (de)
	ld	b, a
	ld	a, (hl)
	sub	b
	ld	(hl), a
	dec	hl
	dec	de
	ld	a, (de)
	ld	b, a
	ld	a, (hl)
	sbc	a, b
	ld	(hl), a
	dec	hl
	dec	de
	ld	a, (de)
	ld	b, a
	ld	a, (hl)
	sbc	a, b
	ld	(hl), a
	ret

;#####################################
;multiply a big number
;input: bc = number of bytes
;	e = to multiply by
;	ix = start of big number
;output: number is multiplied in ram

xMult:
	ld	d, 0
MultLoop:
	ld	l, (IX)
	ld	h, 0
	call	multHLbyE
	ld	a, d
	add	a, l
	ld	(ix), a
	ld	d, h
	inc	ix
	dec	bc
	ld	a, b
	or	c
	jr	nz, multLoop
	ret

multHLbyE:
	push	bc
	push	de
	ex	de, hl
	ld	a, l
	ld	hl, 0
	ld	b, 8
multzLoop:
	rrca
	jr	nc, multSkip
	add	hl, de
multSkip:
	sla	e
	rl	d
	djnz	multzLoop
	pop	de
	pop	bc
	ret
	


;#######################################
;divide a big number
;input: bc = number of bytes
;	e = to divide by
;	ix = end of big number
;output: number is divided in ram

XDiv:
	LD	D, 0
DivLoop:
	LD	H, D
	LD	L, (IX)
	CALL	DivHLByE
	LD	(IX), L
	LD	D, A
	DEC	IX
	DEC	BC
	LD	A, B
	OR	C
	JR	NZ, DivLoop
	RET
	
DivHLByE:
	PUSH	BC
	XOR	A
	LD	B, 16
_2Loop:
	ADD	HL, HL
	RLA
	JR	C, OverFlow
	CP	E
	JR	C, _2Skip
OverFlow:
	SUB	E
	INC	L
_2Skip:
	DJNZ	_2Loop
	POP	BC
	RET













;#################################
;Display Small Font
;Input: B = number of chars
;	C = 0 = 0 right aligned
;	    1 = left aligned
;	    2 = center aligned
;	de = xy of first or last or center
;	stack = chars
;Output: the number
;Remarks: no clipping

SmallFont:
	POP	HL
	LD	(smc_ret2+1), HL

	EX	DE, HL

	ld	a, c
	or	a
	JR	z, rightAlignment
	dec	a
	jr	z, smallFontLoop

	call	centerAlign
	jr	smallFontLoop		
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& change this if copying out this routine

centerAlign:
	push	bc
	dec	h
	srl	b
	jr	c, itsOdd
	inc	h
	inc	h
itsOdd:
	ld	a, b
	or	a
	jp	z, dontShift
	ld	a, h
	ld	h, 4
centerShift:
	sub	h
	djnz	centerShift
	ld	h, a
dontShift:
	pop	bc
	ret
	



rightAlignment:
	PUSH	BC
	DEC	B
	JR	Z, AfterRightAligned
	LD	DE, $FC00
RightAlignedLoop:
	ADD	HL, DE
	DJNZ	RightAlignedLoop
AfterRightAligned:
	POP	BC
SmallFontLoop:
	POP	DE	;next char

	PUSH	BC
	
	LD	A, D
	SLA	D
	SLA	D
	ADD	A, D
	ld	d, 0
	LD	E, A
	LD	IX, Numbers
	add	ix, de
	
	LD	B, 5
	PUSH	HL

	ex	de, hl
	
	CALL	graySprite
	
	POP	HL
	POP	BC
	
	LD	DE, $0400
	ADD	HL, DE

	DJNZ	SmallFontLoop
	
smc_ret2:
	jp	0000




;#################################
;Random Number generator
;Input: none
;Output: A = random number
	
Random:
	PUSH	HL
	PUSH	DE
	LD	HL, 0
	LD	A, R
	ADD	A, (HL)
	INC	HL
	RRCA
	ADD	A, (HL)
	INC	HL
	RRCA
	XOR	(HL)
	INC	HL
	rrca
	rrca
	LD	(Random + 3), HL
	LD	DE, $3700
	sbc	hl, de
	JR	c, RandomSkip
	LD	HL, 0
	LD	(Random + 3), HL
RandomSkip:
	POP	DE
	POP	HL
	RET
	
	

	

;##############################
;gray Horizontal Line
;Input:	C = y
;	D = startx
;	E = endx
;Output: Line


grayHorizontalLine:
	LD	A, E
	SUB	D
	INC	A
	LD	B, A

	XOR	A
	LD	(LeftMask), A
	LD	(RightMask), A

	LD	A, D
	AND	%00000111
	JR	Z, LeftAligned
	LD	L, A
	ADD	A, B
	SUB	8
	LD	B, A

	LD	A, %11111111
LeftLoop:
	SRL	A
	DEC	L
	JR	NZ, LeftLoop
	LD	(LeftMask), A

LeftAligned:	
	LD	A, B
	AND	%00000111
	JR	Z, RightAligned
	LD	L, A
	LD	A, %11111111
RightLoop:
	SRL	A
	DEC	L
	JR	NZ, RightLoop
	CPL
	LD	(RightMask), A

RightAligned:
	SRA	B
	SRA	B
	SRA	B

	jp	p, NotTiny
	LD	A, (RightMask)
	LD	HL, LeftMask
	AND	(HL)
	LD	(HL), A
	XOR	A
	LD	B, A
	LD	(RightMask), A

NotTiny:

	LD	e, C
	
	CALL	grayGetPixel
	
	
	LD	A, (LeftMask)
	OR	A
	JR	Z, LeftSkip
	push	af
	OR	(HL)
	LD	(HL), A
	INC	HL
	pop	af
	or	(hl)
	ld	(hl), a
	inc	hl
	call	checkBufCross
LeftSkip:
	LD	A, B
	OR	A
	JR	Z, NoActualLine
LineStart:
	LD	A, %11111111
LineLoop:
	LD	(HL), A
	INC	HL
	ld	(hl), a
	inc	hl
	call	checkBufCross
	DJNZ	LineLoop
NoActualLine:
	LD	A, (RightMask)
	push	af
	OR	(HL)
	LD	(HL), A
	pop	af
	inc	hl
	or	(hl)
	ld	(hl), a

	RET





;#################################
;dispay a tetris square
;Input: de = xy
;	a  = type
;Output: Displays a sprite

drawSquare:
	push	de

	ld	d, 0
	rlca
	rlca
	ld	e, a
	ld	ix, blocks
	add	ix, de
	
	pop	de
	ld	a, e
	or	a
	ret	m
	cp	64
	ret	nc
	ld	b, 4
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;fall through to graySprite


;#################################
;display a gray sprite
;input: b = rows
;	de = xy
;	ix = start of picture
;output: a sprite
;remarks: picture: %darklite

graySprite:
	call	grayGetPixel
	and	7
	jr	z, aligned

notAligned:
	LD	C, A
	LD	DE, 22
RowLoop:
	push	bc
	ld	b, c
	ld	a, %11110000
eraseShiftLoop:
	srl	a
	rr	c
	djnz	eraseShiftLoop
	cpl
	and	(hl)
	ld	(hl), a
	inc	hl
	inc	hl
	call	checkBufCross
	ld	a, c
	cpl
	and	(hl)
	ld	(hl), a
	dec	hl
	dec	hl
	call	checkBufCross
	
	pop	bc
	push	bc

	ld	b, c
	ld	a, (ix)
	bit	0, l		;dark pixels are een
	jr	z, darkHalf
	rlca	
	rlca
	rlca
	rlca
darkHalf:
	and	%11110000
	ld	c, 0
ShiftLoop:
	srl	a
	rr	c
	DJNZ	ShiftLoop
	OR	(HL)
	LD	(HL), A
	inc	hl
	inc	hl		;2 cus of the opposite between
	call	checkBufCross
	LD	A, C
	OR	(HL)
	LD	(HL), A
	
	dec	hl
	call	checkBufCross
	bit	0, l
	jr	nz, downHere

	ADD	HL, DE
	call	checkBufCross
	INC	IX
	POP	BC
	DJNZ	RowLoop

	ret
	
downHere:
	pop	bc
	jr	rowLoop


Aligned:
	ld	c, %00001111
	ld	de, 22
PutLoop:
	ld	a, (hl)
	and	c	;clear out the pixels first
	ld	(hl), a
	ld	a, (IX)
	bit	0, l		;dark pixels are even
	jr	z, darkHalf2
	rlca
	rlca
	rlca
	rlca
darkHalf2:
	and	%11110000
	or	(hl)
	ld	(hl), a

	inc	hl
	bit	0, l		;darks redo for light
	jr	nz, putLoop

	inc	ix
	add	hl, de
	call	checkBufCross
	djnz	putLoop
	
	ret


;###############################
;checks to see if crossing to other pic buffer
checkBufCross:
	push	de
	push	bc
	ld	de, plotSScreen+768
	or	a
	sbc	hl, de
	add	hl, de
	jr	nc, wentPastPlot
	
	ld	de, saveSScreen
	or	a
	sbc	hl, de
	add	hl, de
	jr	c, wentUnderSave
	
quitFromThis:
	pop	bc
	pop	de
	ret

wentPastPlot:
	ld	de, saveSScreen-plotSScreen-768
	add	hl, de
	jr	quitFromThis

wentUnderSave:
	ld	de, plotSScreen-saveSScreen+768
	add	hl, de
	jr	quitFromThis

;##########################
;gray Get Pixel
;Input: D = x displayed position
;	E = y displayed position
;Output: HL = location of byte
;	A = x
;Destorys: F DE 

grayGetPixel:
	ld	a, d
	ld	h, 0
	ld	d, h
	ld	l, e
	ADD	HL, HL
	ADD	HL, DE
	ADD	HL, HL
	ADD	HL, HL
	add	hl, hl

	LD	E, A
	SRL	E
	SRL	E
	srl	e
	sla	e
	ADD	HL, DE

	LD	DE, PlotSScreen
	ADD	HL, DE

	call	checkBufCross
	RET






;#########################################
;		Text
;#########################################

gameText:
	.db	"Score", 0
	.db	"Goal", 0
	.db	"Level", 0

appVarName:
	.db	appVarObj, "TetrisM", 0

startText:
	.db	"Tetris", 0
	.db	"Marathon", 0
	.db	"By Brian Coventry", 0
	.db	"v1.1", 0




gameOverText1:
	.db	10, 11, 12, 13
	.db	14, 13, 15, 16 
gameOverText2:
	.db	17, 16, 18, 19
	.db	15, 16, 20, 13

youWinText1:
	.db	21, 19, 17, 16, 22, 16
youWinText2:
	.db	23, 13, 24, 16, 25, 13

pauseText:
	.db	26, 28, 12, 13, 22, 16
	.db	27, 29, 15, 16

highText:
	.db	"New High Score", 0

_83text:
	.db	"You need an 84+", 0

errorText:
	.db	"Error", 0

delText:
	.db	"Delete", 0
	.db	"high scores?", 0
	.db	"DEL - yes", 0
	.db	"Other - no", 0


;A0f7
;b47f

;########################################
;	high score stuff
;########################################

highStart:
highName1:
	.db	"BRIAN", 0, 0, 0, 0
highName2:
	.db	"BRIAN", 0, 0, 0, 0
highName3:
	.db	"BRIAN", 0, 0, 0, 0

highScores:
	.db	0, 0, 0
	.db	0, 0, 0
	.db	0, 0, 0
highEnd:



;#######################################
;		shapes
;######################################

shapes:
	.db	0	
	.db	%00000000	;garbage

	.db	2		;O
	.db	%11001100

	.db	4		;I
	.db	%00001111

	.db	3		;S
	.db	%01101100

	.db	3		;L
	.db	%00101110

	.db	3		;Z
	.db	%11000110

	.db	3		;J
	.db	%10001110

	.db	3		;T
	.db	%01001110	

;########################################
;		Pictures
;########################################

blocks:	;dark then light buffer

	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000

	.db	%0000 1111
	.db	%0110 1001
	.db	%0110 1001
	.db	%0000 1111

	.db	%0000 1111
	.db	%0110 1111
	.db	%0110 1111
	.db	%0000 1111

	.db	%1111 0000
	.db	%1001 0000
	.db	%1001 0000
	.db	%1111 0000

	.db	%1111 0000
	.db	%1001 0110
	.db	%1001 0110
	.db	%1111 0000

	.db	%1111 0000
	.db	%1111 0110
	.db	%1111 0110
	.db	%1111 0000

	.db	%1111 1111
	.db	%1001 1111
	.db	%1001 1111
	.db	%1111 1111

	.db	%1111 1111
	.db	%1111 1001
	.db	%1111 1001
	.db	%1111 1111

	.db	%0000 1111
	.db	%0000 1111
	.db	%0000 1111
	.db	%0000 1111

	.db	%0110 0110	;9
	.db	%1111 1111
	.db	%0110 0110
	.db	%0110 0110

;text for gameOver

	.db	%0110 0000
	.db	%1000 0000
	.db	%1010 0000
	.db	%1010 0000

	.db	%0110 0000	;011
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000

	.db	%0100 0000	
	.db	%1010 0000
	.db	%1110 0000
	.db	%1010 0000

	.db	%1010 0000	;101
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000

	.db	%1010 0000
	.db	%1110 0000
	.db	%1110 0000
	.db	%1010 0000

	.db	%1110 0000		;15
	.db	%1000 0000
	.db	%1100 0000
	.db	%1000 0000

	.db	%1110 0000	;111
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000

	.db	%1110 0000
	.db	%1010 0000
	.db	%1010 0000
	.db	%1010 0000

	.db	%1010 0000
	.db	%1010 0000
	.db	%1010 0000
	.db	%0100 0000

	.db	%0100 0000	;010
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000

	.db	%1100 0000		;20
	.db	%1010 0000
	.db	%1100 0000
	.db	%1010 0000

	.db	%1010 0000
	.db	%1010 0000
	.db	%0100 0000
	.db	%0100 0000

	.db	%1010 0000
	.db	%1010 0000
	.db	%1010 0000
	.db	%1010 0000

	.db	%1010 0000
	.db	%1010 0000
	.db	%1010 0000
	.db	%1110 0000

	.db	%1110 0000
	.db	%0100 0000
	.db	%0100 0000
	.db	%0100 0000

	.db	%1100 0000		;25
	.db	%1010 0000
	.db	%1010 0000
	.db	%1010 0000

	.db	%1100 0000
	.db	%1010 0000
	.db	%1100 0000
	.db	%1000 0000

	.db	%0110 0000
	.db	%1000 0000
	.db	%0100 0000
	.db	%0010 0000

	.db	%1000 0000	;100
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000

	.db	%1100 0000	;110
	.db	%0000 0000
	.db	%0000 0000
	.db	%0000 0000


;##########################
;Numbers

Numbers:
	.db	%01000000
	.db	%10100000
	.db	%10100000
	.db	%10100000
	.db	%01000000

	.db	%01000000
	.db	%11000000
	.db	%01000000
	.db	%01000000
	.db	%11100000
	
	.db	%11000000
	.db	%00100000
	.db	%01000000
	.db	%10000000
	.db	%11100000

	.db	%11000000
	.db	%00100000
	.db	%01000000
	.db	%00100000
	.db	%11000000
	
	.db	%10000000
	.db	%10100000
	.db	%11100000
	.db	%00100000
	.db	%00100000

	.db	%11100000
	.db	%10000000
	.db	%11000000
	.db	%00100000
	.db	%11000000

	.db	%01100000
	.db	%10000000
	.db	%11100000
	.db	%10100000
	.db	%11100000

	.db	%11100000
	.db	%00100000
	.db	%01000000
	.db	%10000000
	.db	%10000000

	.db	%11100000
	.db	%10100000
	.db	%11100000
	.db	%10100000
	.db	%11100000

	.db	%11100000
	.db	%10100000
	.db	%11100000
	.db	%00100000
	.db	%11000000






.end
.end