gameserverclient.s

;;apple game server client

;; (c) 2012, 2017 Egan Ford (egan@sense.net)

;; apple //e vectors

cout	=	$FDED		; character out
crout	=	$FD8E		; cr out
warm	=	$FF69		; back to monitor
clear	=	$FC58		; clear screen
movecur	=	$FB5B		; move cursor to ch,a
rdkey	=	$FD0C		; read key
bell	=	$FBDD		; ding
a80soff	=	$C000		; page between main and main
a80sta	=	$C001		; page between main and aux
a80off	=	$C00C		; 80 col mode on
a80on	=	$C00D		; 80 col mode on
altoff	=	$C00E		; alt char set off
alton	=	$C00F		; alt char set on
textoff	=	$C050		; text mode off
texton	=	$C051		; text mode on
hiresoff=	$C056		; hires off
mixedon	=	$C053		; mixed mode lowres/text
mixedoff=	$C052		; mixed mode lowres/text off
mixed	=	$C01B		; mixed flag
page1on	=	$C054		; page2off/page1on
page2on	=	$C055		; page2on
setan3	=	$C05E		; double lowres
clran3	=	$C05F		; disable double lowres
auxmove	=	$C311		; aux memory move
rstvecp	=	$03F2		; reset vector pointer

;; my vectors

org	=	$800		; my start
rstvec	=	$2D0		; my reset vector code

;; zero page parameters

pointer	=	$00		; pointer used for anything
current	=	$02		; current title
counter	=	$03		; generic counter
tmp	=	$03		; generic counter
ptr	=	$04		; pointer backup
gridx	=	$06		; grid x end (row)
gridy	=	$07		; grid y end (col)
wndleft	=	$21		; window left
wndtop	=	$22		; window top
ch	=	$24		; cursor horizontal position
cv	=	$25		; cursor verticle position
a1l	=	$3C		; auxmove source start low
a1h	=	$3D		; auxmove source start high
a2l	=	$3E		; auxmove source end low
a2h	=	$3F		; auxmove source end high
a4l	=	$42		; auxmove dest low
a4h	=	$43		; auxmove dest high

;; other vars

length	=	s002-s001	; Length of titles
ttab	=	(40-length+1)/2	; center of screen for titles
ttop	=	5		; top of scrolling window
downarrow=	$8A
uparrow	=	$8B
returnkey=	$8D

				; Optional (recommend for c2t or DOS)
				; DOS header location and size LSB/MSB
	;.byte	<start,>start,<(end-start),>(end-start)

	.org	org		; start here
;; setup reset vector
	lda	#<rstvec	; start of reset vector
	sta	rstvecp
	lda	#>rstvec
	sta	rstvecp+1
	eor	#$A5		; something Apple //e needs as a check
	sta	rstvecp+2

;; copy main program to aux
	lda	#$00
	sta	a1l		; store source and dest low
	sta	a4l
	lda	#$08
	sta	a1h		; store source and dest high
	sta	a4h
	lda	#$FF
	sta	a2l		; store target high
	lda	#$87
	sta	a2h
	sec			; copy from main to aux
	jsr	auxmove

	ldx	#0		; copy maintoaux program to reset vector
setupvector:
	lda	maintoaux,x
	sta	rstvec,x
	inx
	cpx	#maintoauxend-maintoaux
	bne	setupvector

	jmp	start		; start program

;; copy aux to main
maintoaux:
	jsr	clear		; clear screen if possible
	lda	#$00
	sta	a1l
	sta	a4l
	lda	#$08
	sta	a1h
	sta	a4h
	lda	#$FF
	sta	a2l
	lda	#$87
	sta	a2h
	clc			; copy from main to aux
	jsr	auxmove
	jmp	start
maintoauxend:

start:
				; copy tape code to high memory
	ldx	#0		; this will get hosed on game load
moveit:				; as will just about everything else
	lda	tapecode,x	; in main memory
	sta	$BE00,x
	lda	tapecode+256,x
	sta	$BF00,x
	inx
	bne	moveit

;; fresh start, clear screen, reset other settings
	sta	clran3		; disable double lowres
	sta	mixedoff	; disable mixed
	sta	texton		; text mode on
	sta	a80off		; 40 col
	sta	a80soff		; page between main and main
	sta	page1on		; page one one
	jsr	clear		; clear screen
	lda	#40		; set wndleft to 40 col
	sta	wndleft

;; print header
	;jsr	clear		; clear screen
	sta	alton		; use alt char set for lower case inverse
				; center title
	lda	#19-(titleend-title-1)/2
	sta	ch		; sta hort. position
	lda	#<title		; load LSB of title:
	ldy	#>title		; load MSB of title:
	jsr	printinv	; print title:
	jsr	crout		; print CR
	jsr	crout		; print CR
				; center instructions 1
	lda	#19-(ins1end-ins1-1)/2
	sta	ch		; sta hort. position
	lda	#<ins1		; load LSB of ins1:
	ldy	#>ins1		; load MSB of ins1:
	jsr	print		; print ins1:
	jsr	crout		; print CR
				; center instructions 2
	lda	#19-(ins2end-ins2-1)/2
	sta	ch		; sta hort. position
	lda	#<ins2		; load LSB of ins2:
	ldy	#>ins2		; load MSB of ins2:
	jsr	print		; print ins2:
	jsr	crout		; print CR
;; print line
	ldx	#40		; length of line
        jsr	line		; draw line
;; window setup
	lda	#ttop		; load 5 into A
	sta	wndtop		; set top of window for scrolling
;; print initial list
	lda	#<first		; set pointer to first item
	sta	pointer
	lda	#>first
	sta	pointer+1
;; print items
	ldx	#(24-ttop)
initloop:
	jsr	crout		; print CR
	lda	#ttab		; hort. tab for title center
	sta	ch		; store it
	jsr	print2		; print item
;; inc pointer with length
	clc			; clear carry flag
	lda	pointer		; load LSB of pointer
	adc	#length		; add length of titles
	sta	pointer		; store it
	lda	pointer+1	; load MSB of pointer
	adc	#0		; adc 0 + carry flag to MSB
	sta	pointer+1	; store it
	dex			; x=x-1
	bne	initloop	; if x != 0 goto initloop
;; reset pointer to first item
	lda	#<first		; set point to first item
	sta	pointer
	lda	#>first
	sta	pointer+1
	lda	#0		; set current to first item
	sta	current		; current will be used to track the item
	lda	#5		; set vert cursor position
	sta	cv		; cv will be used to track the bar
mainloop:
	lda	#ttab		; hort. tab for title center
	sta	ch		; sta hort. position
	lda	cv		; sta vert position
	jsr	movecur		; move cursor
	jsr	printinv2	; highlight current item

	;jsr	rdkey		; get keyboard input
	jsr	getkey		; get keyboard input
	ora	#$80		; just in case getkey returns $0x.
	pha			; push key to stack
				; clear light bar
	lda	#ttab		; hort. tab for title center
	sta	ch		; sta hort. position
	jsr	print2		; un-highlight current item
	pla			; pop key from stack
down:
	cmp	#downarrow	; down arrow
	bne	up		; check up: if not down
	lda	current		; load up current
				; last item?
	cmp	#(last-first)/length
	bne	down1		; last item, cannot go down
	jmp	none
down1:
	inc	current		; increment current position

;; do we go down or scroll screen
;; if current < (24-ttop)/2+1, then down

	lda	current		; load current item number
	cmp	#(24-ttop)/2+1	; see if in of first 9 or so items
	bcc	down2		; skip to down2 if so

;; if current > (last-first)/length - (24-ttop)/2 + 1, then down

				; see if in bottom of last 9 or so items
	cmp	#((last-first)/length-(24-ttop)/2+1)
	bcs	down2		; skip to down2 if so

;; else scroll up display

	lda	pointer		; backup pointer
	sta	ptr
	lda	pointer+1
	sta	ptr+1
				; add 9 or so to pointer to display next line
	clc			; clear carry flag
	lda	pointer		; load LSB of pointer
				; add length of titles
	adc	#length*((24-ttop)/2+1)
	sta	pointer		; store it
	lda	pointer+1	; load MSB of pointer
	adc	#0		; adc 0 + carry flag to MSB
	sta	pointer+1	; store it
	lda	#23		; lda vert position to last line
	jsr	movecur		; move cursor
	jsr	crout		; print CR to scroll display
	lda	#ttab		; hort. tab for title center
	sta	ch		; sta hort. position
	jsr	print2		; print item at bottom
	lda	ptr		; restore pointer
	sta	pointer
	lda	ptr+1
	sta	pointer+1
				; put cv back - 1
	lda	#((24-ttop)/2 + ttop - 1)
	sta	cv		; maintain cv at middle of window
down2:
	inc	cv		; move verticle cursor down
				; increment pointer
	clc			; clear carry flag
	lda	pointer		; load LSB of pointer
	adc	#length		; add length of titles
	sta	pointer		; store it
	lda	pointer+1	; load MSB of pointer
	adc	#0		; adc 0 + carry flag to MSB
	sta	pointer+1	; store it
	jmp	mainloop	; back to main loop
up:
	cmp	#uparrow	; up arrow
	bne	return		; check return: if not up
	lda	current		; load up current
	beq	none		; current zero?, then do nothing
	dec	current		; dec current position

;; do we go up or scroll screen
;; if current < (24-ttop)/2+1, then up

	lda	current		; load current item number
	cmp	#(24-ttop)/2+0	; see if in of first 9 or so items
	bcc	up2		; skip to up2 if so

;; if current > (last-first)/length - (24-ttop)/2 + 1, then up

				; see if in bottom of last 9 or so items
	cmp	#((last-first)/length-(24-ttop)/2+0)
	bcs	up2		; skip to up2 if so

;; else scroll down display

	jsr	scrolldown

;; print missing item

	lda	pointer		; backup pointer
	sta	ptr
	lda	pointer+1
	sta	ptr+1
				; sub 9 or so to pointer to display next line
	sec			; set carry flag
	lda	pointer		; load LSB of pointer
				; add length of titles
	sbc	#length*((24-ttop)/2+1)
	sta	pointer		; store it
	lda	pointer+1	; load MSB of pointer
	sbc	#0		; sub 0 + carry flag to MSB
	sta	pointer+1	; store it
	lda	#ttop		; lda vert position to last line
	jsr	movecur		; move cursor
	lda	#ttab		; hort. tab for title center
	sta	ch		; sta hort. position
	jsr	print2		; print item at bottom

	lda	ptr		; restore pointer
	sta	pointer
	lda	ptr+1
	sta	pointer+1
				; put cv back + 1
	lda	#((24-ttop)/2 + ttop + 1)
	sta	cv		; maintain cv at middle of window
up2:
	dec	cv		; move verticle cursor up
				; dec pointer
	sec			; set carry flag
	lda	pointer		; load LSB of pointer
	sbc	#length		; sub length of titles
	sta	pointer		; store it
	lda	pointer+1	; load MSB of pointer
	sbc	#0		; sub 0 - carry flag to MSB
	sta	pointer+1	; store it
	jmp	mainloop	; back to main loop
return:
	cmp	#returnkey	; RETURN
	bne	none		; read another key if not RETURN
	jmp	done		; got RETURN, jump to done
none:
	;; ring bell?
	jsr	bell
	jmp	mainloop
done:
	;; take current pointer and do something with it
	lda	#0		; load 0 into A
	sta	wndtop		; reset top of window 
	jsr	clear		; clear screen
				; double lores mode
	sta	textoff		; text mode off
	sta	hiresoff	; hires mode off
	sta	mixedon		; mixed graphics/text on
	sta	a80on		; 80 col mode on
	sta	setan3		; double lowres
	sta	a80sta		; use main/aux for page1/page2
;; clear screen
	sei			; disable interupts, enable after
				; double lores fun
	sta	page1on		; turn on page1
	jsr	dlrclr		; double low res clear to white
	sta	page2on		; turn on page2
	jsr	dlrclr		; double low res clear to white
	sta	page1on		; turn on page1
	lda	#80		; set wndleft to 80 col
	sta	wndleft
;; print help
	lda	#40-(ins3end-ins3)/2
	sta	ch		; sta hort. position
	lda	#21		; move to line 21
	jsr	movecur		; move cursor
	lda	#<ins3		; load LSB of ins3:
	ldy	#>ins3		; load MSB of ins3:
	;jsr	print
	jsr	printinv80
	lda	#40-(ins4end-ins4)/2
	sta	ch		; sta hort. position
	lda	#22		; move to line 22
	jsr	movecur		; move cursor
	lda	#<ins4		; load LSB of ins4:
	ldy	#>ins4		; load MSB of ins4:
	;jsr	print
	jsr	printinv80
;; print qrcode
	lda	#<qrptrl	; load up ptr to first 128 (0-127) qr codes
	sta	ptr
	lda	#>qrptrl
	sta	ptr+1
	lda	current		; check if current is > 127
	bpl	@1		; if not then skip to @1:
	lda	#<qrptrh	; load up ptr to last qr codes
	sta	ptr
	lda	#>qrptrh
	sta	ptr+1
	lda	current		; check if current is > 127
	and	#$7F		; loose the high bit
@1:
	asl			; times by 2 (we are scaning words)
	tay			; copy A to Y
	lda	(ptr),y		; get address of qr code
	sta	qrptr+1		; store in qrptr (self mod code--evil)
	sta	pointer		; need to get first byte for grid size
	iny
	lda	(ptr),y
	sta	qrptr+2
	sta	pointer+1
;; setup x, y, gridx, gridy, for qr loop
	ldy	#0	
	lda	(pointer),y	; grid size
	sta	gridx		; temp storage
	lsr			; divide by 2
	sta	tmp		; use for temp storage
				; for various reasons x will be use for Y axis and vv.
	sec			; y coord start (cols)
	lda	#39		; 39 or 40 for center of screen
	sbc	tmp		; - grid size / 2
	sta	starty+1	; backup start of row location (self mod code)
	tay			; Y start

	sec			; x coord start (rows)
	lda	#23		; 23 for center of screen
	sbc	tmp		; - grid size / 2
	tax			; X start

	tya			; compute grid y end
	clc			; clear cary
	adc	gridx		; + grid size
	sta	gridy		; save it

	txa			; compute grid x end
	clc			; clear cary
	adc	gridx		; + grid size
	sta	gridx		; save it

	lda	#$80		; set bit counter to last bit
	sta	counter
	clc			; clear carry
;; main qr print loop
qrxloop:			; row loop
	lda	rowlo,x		; get row addr
	sta	ptr		; store in ptr
	lda	rowhi,x
	sta	ptr+1
qryloop:			; col loop
	clc			; don't want to roll carry into counter
	rol	counter		; roll high bit into carry on first pass
	bne	nextbit		; if not 0 get next bit
nextbyte:
	inc	qrptr+1		; inc LSB
	bne	rstcnt		; if not 0 (inc rollover) skip
	inc	qrptr+2		; then inc MSB
rstcnt: lda	#1		; reset counter to 2^0
	sta	counter
nextbit:
qrptr:	rol	$FFFF		; X and Y will be in use (self mod code)
	bcc	nexty		; got 0
				; got 1, print pixel
				; is y even or odd? need to know for page
	tya			; get (col)
	ror			; put LS bit in to carry
	bcs	page1		; odd number? skip to page1
	sta	page2on		; else enable page 2
	bcc	page2		; skip over page 1 on
page1:	sta	page1on		; turn page 1 on
page2:				; divide col / 2
	tya			; get (col)
	pha			; back it up to stack
	lsr			; divide / 2
	tay			; copy to Y
				; check x for odd/even
	txa			; copy x to a
	ror			; put LS bit in to carry
	lda	(ptr),y		; load up existing lores block
	bcc	even		; is x even
	eor	#$F0		; x is odd, clear top 1/2 byte
	bcs	odd		; skip to odd
even:	eor	#$0F		; x is even, clear bottom 1/2 byte
odd:	sta	(ptr),y		; write to screen

	pla			; retore old y (col) from stack
	tay			; A->Y
nexty:	iny			; y++
	cpy	gridy		; is y at right edge of grid?
	bcc	qryloop		; if not get next y pixel
				; reset iny to start
starty:	ldy	#0		; self mod code to retore y to col 0

	inx			; x++, next row
	cpx	gridx		; is x at bottom edge of grid
	bcc	qrxloop		; if not move to next row of pixels
				; qrcode done	
	cli			; enable interupts 

;; all done, jmp to tape code
	jmp	$BE00

;; end of main program

dlrclr:
	ldy	#40		; loop from 39 to 0
	lda	#$FF		; while top/bottom block
clearloop:
	dey			; y--
	sta	$400,y		; lines 0,1
	sta	$480,y		; lines 2,3
	sta	$500,y		; lines 4,5
	sta	$580,y		; lines 6,7
	sta	$600,y		; lines 8,9
	sta	$680,y		; lines 10,11
	sta	$700,y
	sta	$780,y
	sta	$428,y
	sta	$4A8,y
	sta	$528,y
	sta	$5A8,y
	sta	$628,y
	sta	$6A8,y
	sta	$728,y
	sta	$7A8,y
	sta	$450,y
	sta	$4D0,y
	sta	$550,y
	sta	$5D0,y
	bne	clearloop
	ldy	#40		; loop from 39 to 0
	;lda	#$A0		; blankspace
	lda	#$20		; blankspace
clearloop2:
	dey			; y--
	sta	$650,y
	sta	$6D0,y
	sta	$750,y
	sta	$7D0,y
	bne	clearloop2
	rts

line:
	lda	#'-'
	ora	#$80
loop0:
	jsr	cout
	dex
	bne	loop0
	rts

print:
	sta	pointer
	sty	pointer+1
print2:
	ldy	#0
	lda	(pointer),y	; load initial char
@lp:	ora	#$80
	jsr	cout
	iny
	lda	(pointer),y
	bne	@lp
	rts

printinv80:
	sta	pointer
	sty	pointer+1
	ldy	#0
	lda	(pointer),y	; load initial char
@lp:	ora	#$0
	jsr	cout
	iny
	lda	(pointer),y
	bne	@lp
	rts

printinv:
	sta	pointer
	sty	pointer+1
printinv2:
	ldy	#0
	lda	(pointer),y	; load initial char
@lp:
	cmp	#$60
	bcs	@sane
	and	#$3F
@sane:
	jsr	cout
	iny
	lda	(pointer),y
	bne	@lp
	rts

getkey:	bit	$C000
	bpl	getkey
	lda	$C010 
	rts

scrolldown:
	ldy	#ttab		; left site of items
scrollloop:
	lda	$750,y		; copy line 22 -> 23
	sta	$7D0,y
	lda	$6D0,y		; copy line 21 -> 22
	sta	$750,y
	lda	$650,y		; copy line 20 -> 21
	sta	$6D0,y
	lda	$5D0,y		; copy line 19 -> 20
	sta	$650,y
	lda	$550,y		; copy line 18 -> 19
	sta	$5D0,y
	lda	$4D0,y		; copy line 17 -> 18
	sta	$550,y
	lda	$450,y		; copy line 16 -> 17
	sta	$4D0,y
	lda	$7A8,y		; copy line 15 -> 16
	sta	$450,y
	lda	$728,y		; copy line 14 -> 15
	sta	$7A8,y
	lda	$6A8,y		; copy line 13 -> 14
	sta	$728,y
	lda	$628,y		; copy line 12 -> 13
	sta	$6A8,y
	lda	$5A8,y		; copy line 11 -> 12
	sta	$628,y
	lda	$528,y		; copy line 10 -> 11
	sta	$5A8,y
	lda	$4A8,y		; copy line  9 -> 10
	sta	$528,y
	lda	$428,y		; copy line  8 ->  9
	sta	$4A8,y
	lda	$780,y		; copy line  7 ->  8
	sta	$428,y
	lda	$700,y		; copy line  6 ->  7
	sta	$780,y
	lda	$680,y		; copy line  5 ->  6
	sta	$700,y
	iny			; y++
				; right side of items
	cpy	#(ttab+length-1)
	bne	scrollloop
	rts

;; double lores addr table

rowlo:	.byte	$00,$00,$80,$80,$00,$00,$80,$80,$00,$00,$80,$80,$00,$00,$80,$80
	.byte	$28,$28,$A8,$A8,$28,$28,$A8,$A8,$28,$28,$A8,$A8,$28,$28,$A8,$A8
	.byte	$50,$50,$D0,$D0,$50,$50,$D0,$D0,$50,$50,$D0,$D0,$50,$50,$D0,$D0
rowhi:	.byte	$4,$4,$4,$4,$5,$5,$5,$5,$6,$6,$6,$6,$7,$7,$7,$7
	.byte	$4,$4,$4,$4,$5,$5,$5,$5,$6,$6,$6,$6,$7,$7,$7,$7
	.byte	$4,$4,$4,$4,$5,$5,$5,$5,$6,$6,$6,$6,$7,$7,$7,$7

;; string constants

title:	.asciiz	"Apple ][ Game Server Online! Client"
titleend:
ins1:	.asciiz	"UP/DOWN to select, RETURN to launch"
ins1end:
ins2:	.asciiz	"CTRL-RESET (or reboot) to return here"
ins2end:
ins3:	.asciiz	"Connect smartphone headphone jack to Apple //e cassette input jack (next to"
ins3end:
ins4:	.asciiz	"joystick port).  Turn volume to max.  Point QR scanner at screen."
ins4end:
;ins5:	.asciiz	"Visit http://asciiexpress.net/gameserver for more information."
;ins5end:

;; game titles

.include	"titles.inc"

;; game qrcodes

.include	"qrcodes.inc"

tapecode:
.scope tape
cout	=	$FDED		; character out sub
crout	=	$FD8E		; CR out sub
tapein	=	$C060		; read tape interface
warm	=	$FF69		; back to monitor
clear	=	$FC58		; clear screen
inflate	=	$BA00		; inflate code start

; zero page parameters

begload	=	$00		; begin load location LSB/MSB
endload	=	$02		; end load location LSB/MSB
chksum	=	$04		; checksum location
remain	=	$04		; checksum remainder location
pointer	=	$0C		; LSB/MSB pointer
inf_zp	=	$00		; inflate code zero page vars (10)

	.org	$BE00

	;jsr	resetscreen	; back to 40 col mode
	;jsr	warm

getparams:			; client params
	lda	#<ld_beg	; store begin location LSB
	sta	begload
	lda	#>ld_beg	; store begin location MSB
	sta	begload+1
				; end of params + 1 for checksum
	lda	#<end		; store end location LSB
	sta	endload
	lda	#>end		; store end location MSB
	sta	endload+1

retry:
	jsr	readtape	; get the code

;; new approach, check for error after rts
	bne	retry		; if readtape gets invalid length try again
				; this is required in the event the smartphone
				; QR scan app "dings" on detect

	jsr	resetscreen	; back to 40 col mode

	lda	#<param		; print param message
	ldy	#>param
	jsr	print
	jsr	sumcheck	; check the data
	lda	#<okm
	ldy	#>okm
	jsr	print
	jsr	crout		; 2 linefeeds
	jsr	crout
	lda	#<loadm		; print loading message
	ldy	#>loadm
	jsr	print

;; get the game

	lda	ld_beg		; store begin location LSB
	sta	begload
	lda	ld_beg+1	; store begin location MSB
	sta	begload+1
				; end of params + 1 for checksum
	lda	ld_end		; store end location LSB
	sta	endload
	lda	ld_end+1	; store end location MSB
	sta	endload+1

	jsr	readtape	; get the code
	beq	dosum		; if readtape ok to load code branch to dosum
	jmp	error		; else jmp to error
dosum:
	jsr	sumcheck	; check the data

	lda	inf_flag	; if inf_flag = 0 runit
	bne	inf
	jmp	runit
inf:
	jsr	crout
	lda	#<infm
	ldy	#>infm
	jsr	print

	lda	inf_src		;src lsb
	sta	inf_zp+0
	lda	inf_src+1	;src msb
	sta	inf_zp+1
	lda	inf_dst		;dst lsb
	sta	inf_zp+2
	lda	inf_dst+1	;dst msb
	sta	inf_zp+3

	jmp	lastpage	;jump to page BF since inflate will kill BE

resetscreen:
	sta	clran3		; disable double lowres
	sta	mixedoff	; disable mixed
	sta	texton		; text mode on
	sta	a80off		; 40 col
	sta	a80soff		; page between main and main
	sta	page1on		; page one one
	jsr	clear		; clear screen
	lda	#40		; set wndleft to 40 col
	sta	wndleft
	rts

readtape:
	lda	begload		; load begin LSB location
	sta	store+1		; store it
	lda	begload+1	; load begin MSB location
	sta	store+2		; store it

	ldx	#0		; set X to 0
	lda	#1		; set A to 0 

nsync:	bit	tapein		; 4 cycles, sync bit ; first pulse
	bpl	nsync		; 2 + 1 cycles

main:	ldy	#0		; 2 set Y to 0 

psync:	bit	tapein		; 
	bmi	psync

ploop:	iny			; 2 cycles
	bit	tapein		; 4 cycles
	bpl	ploop		; 2 +1 if branch, +1 if in another page
				; total ~9 cycles

	cpy	#$40		; 2 cycles if Y - $40 > 0 endcode (770Hz)
	bpl	endcode		; 2(3)

	cpy	#$15		; 2 cycles if Y - $15 > 0 main (2000Hz)
	bpl	main		; 2(3)

	cpy	#$07		; 2, if Y<, then clear carry, if Y>= set carry
store:	rol	store+1,x	; 7, roll carry bit into store
	ldy	#0		; 2
	asl			; 2 A*=2
	bne	main		; 2(3)
	lda	#1		; 2
	inx			; 2 cycles
	bne	main		; 2(3)
	inc	store+2		; 6 cycles
	jmp	main		; 3 cycles
				; 34 subtotal max
				; 36 subtotal max
endcode:  
	txa			; write end of file location + 1
	clc
	adc	store+1
	sta	store+1
	bcc	endcheck	; LSB didn't roll over to zero
	inc	store+2		; did roll over to zero, inc MSB
endcheck:			; check for match of expected length
	lda	endload
	cmp	store+1

	;bne	error
	bne	enderror	; return and check for bne from caller

	lda	endload+1
	cmp	store+2
	;bne	error		; fix need to reset screen, etc...
enderror:			; return and check for bne from caller
	rts			; return to caller

sumcheck:
	sec			; set carry for sub operation
	lda	endload		; load end low
	sbc	begload		; sub beg load low with carry
	sta	remain		; save remainder
	;tay			; y will be our number of byte starting
				; with remainder of bytes to chksum
	lda	endload+1	; load end high
	sbc	begload+1	; sub beg load high with carry
	tax			; x will be our number of 256 byte blocks
	inx			; + 1

	lda	begload		; setup pointer low
	sta	pointer
	lda	begload+1	; setup pointer high
	sta	pointer+1
	dec	pointer+1

	lda	#$ff		; init checksum
sumblockloop:
	ldy	#0
	inc	pointer+1
	dex
	bne	sumloop
	ldy	remain		; load remainder
	beq	endsum		; 0?
remainder:
	dey			; array base 0
	eor	(pointer),y
	cpy	#0
	bne	remainder
	beq	endsum
sumloop:
	eor	(pointer),y
	iny
	bne	sumloop
	beq	sumblockloop
endsum:


;sumcheck:
;	lda	#0
;	sta	pointer
;	lda	begload+1
;	sta	pointer+1
;	lda	#$ff		; init checksum
;	ldy	begload
;sumloop:
;	eor	(pointer),y
;	;last page?
;	ldx	pointer+1
;	cpx	endload+1
;	beq	last
;	iny
;	bne	sumloop
;	inc	pointer+1
;	bne	sumloop
;last:
;	iny
;	cpy	endload
;	bcc	sumloop

	sta	chksum		; for debugging
	lda	chksum

	bne	sumerror	; chksum = 0?
	rts			; return to caller
sumerror:
	lda	#<chkm
	ldy	#>chkm
	jsr	print
error:
	bit	mixed		; still in mixed mode?
	bpl	errorcont	; no then carry on
	jsr	resetscreen	; else reset screen first
errorcont:
	lda	#<errm
	ldy	#>errm
	jsr	print
	jmp	warm	
ok:
	lda	#<okm
	ldy	#>okm
print:
	sta	pointer
	sty	pointer+1
	ldy	#0
	lda	(pointer),y	; load initial char
print1:	ora	#$80
	jsr	cout
	iny
	lda	(pointer),y
	bne	print1
	rts

lastpage:
	jsr	inflate		; decompress

	lda	inf_end		;dst end +1 lsb
	cmp	inf_zp+2
	bne	error
	lda	inf_end+1	;dst end +1 msb
	cmp	inf_zp+3
	bne	error
runit:
	lda	warm_flag	; if warm_flag = 1 warm boot
	bne	warmit
	jmp	(runcode)	; run it
warmit:
	jmp	warm		; warm it

param:	.asciiz	"LOADING PARAMETERS "
chkm:	.asciiz	"CHKSUM "
okm:	.asciiz	"OK"
errm:	.asciiz	"ERROR"
infm:	.byte	$0D,"INFLATING ",$00
ld_beg:
	.org	*+2
ld_end:
	.org	*+2
inf_src:
	.org	*+2
runcode:
inf_dst:
	.org	*+2
inf_end:
	.org	*+2
inf_flag:
	.org	*+1
warm_flag:
	.org	*+1
loadm:
	.org	*+60
chk:
	.org	*+1
end:
.endscope