.include	"m8def.inc"

.NOLIST
.LIST




.def	w = r16
.def	delayt = r19
.def	delayt1 = r20
.def	textx = r14
.def	texty = r15
.def	nibblex = r12
.def  	nibbley = r13


;constants and pins

.equ	lcd_con = portd
.equ	lcd_reset= 2
.equ	lcd_dc = 4
.equ	lcd_sce = 3

.equ	vramL = 0x08
.equ	vramH = 0x02
.equ	b_port = pinb
.equ	b_u = 1
.equ	b_d	=0
.equ	b_l = 7
.equ 	b_r = 6
.equ	b_1 = 6
.equ	b_2 = 7
.equ	p_port = portc	;piezo port
.equ	pez = 0			;pezo pin


;variable for Softag:
.equ	stag_stat = 0x0066 			; some status bits



;variables in sram
.equ	menu_pos = 0xA0


;variables for 'snakes'
.equ	snake_len = 0x70
.equ	score = 0x71
.equ	level = 0x72

.equ	s_pointer =0		;points to snake_pos mem location

.def	snake_x = r10
.def	snake_y = r11
.def	snake_dir = r25		;direction snake is moving
.def	snake_dir_old = r9  ;direction snake WAS moving


.equ	snake_posL = 0x80		;store snake x and y cordinates
.equ	snake_posH = 0x00

;variables for 'tetris'
.equ	tet_boardL = 0x80		;Tetris board memory map
.equ	tet_boardH = 0x00
	
.def		blockX = r10		;multi use block cordinates
.def		blockY = r11
.def		block_no =	r9		;tetris block number
.def		block_pos = r8		;rotation angle
.def		tet_stat = r25		;status bits

reset_vect:
	rjmp	initalise_hw

.org $004	
	rjmp		stag_jmp
.org $00B
	rjmp		stag_jmp

;---start of code--

.org $013
stag_jmp:
	jmp		stag

initalise_hw:			
		;setup stack
    LDI R16,HIGH(RAMEND) ; Upper byte
    OUT SPH,R16 ; to stack pointer
    LDI R16, LOW(RAMEND) ; Lower byte
    OUT SPL,R16 ; to stack pointer

		;-----setup Rs232 --------------------
	clr		r16
	out		UBRRH,r16
	ldi		r16, 8		;5600 @ 8 mhz
	out		UBRRL,r16

	ldi		r16, (1<<RXEN)|(1<<TXEN)
	out		UCSRB,r16

	ldi		r16, (1<<URSEL)|(1<<USBS)|(3<<UCSZ0)
	out		UCSRC,r16


	ldi		YH,0
	ldi		YL,0x60

	ldi		r16,0xff
	st		Y+,r16
	ldi		r16,0xc2
	st		Y,r16
	;ldi	r16,255				;callibration byte
	;out	osccal,r16
;--
	ldi		r16,128				;stag
	out		TIMSK,r16
	ldi		r16,1
	out		TCCR2,r16
	ldi		r16,0x11
	out		OCR2,r16
;---




	;sbi		UCSRB,TXCIE
	call	del
	call	del

;	sbi		UCSRB,UDRIE

	ldi		r16,0
	sts		stag_stat,r16
;	sbi		UCSRA,udre			;start off ints
;	sei
	nop
	nop
	nop
	nop
	nop
;	call	del
	ldi		r16,1
	sts		stag_stat,r16

	nop
	nop
	nop
	nop
	nop

	;ldi		r16,0x40			INT0	
	;out		GICR,r16

	;ldi		r16,128
;	out		SPSR,r16



	ldi		r18,255
	ldi		r16,4
	clr		r16
	ldi		r16,3
;	call	del


	;setup SPI and ports

	ldi		r17 ,0b00111100			;set portb directions
	out		DDRB,r17
	ldi		r17	,0b00111100
	out 	DDRD,r17				;portd dir		
	ldi		r17 ,0b00000101
	out 	DDRC,r17
	
	ldi		r17,80					;spi config byte
	out		SPCR,r17


	;setup LCD
	;call	tone1

	sbi		lcd_con,lcd_reset		;un-reset
	sbi		lcd_con,lcd_sce			;un-select lcd chip


	ldi		r16, 0x21				;  // LCD Extended Commands.
	call	lcdsend

	ldi		r16, 0xc8				;  // Set LCD Vop (Contrast).
	call	lcdsend


	ldi		r16, 0x06				;  // Set Temp coefficent.
	call	lcdsend
		
	ldi		r16, 0x13				;  // LCD bias mode 1:48.
	call	lcdsend
		
	ldi		r16, 0xcb				;  // LCD CONTRAST
	call	lcdsend

	ldi		r16, 0x20 				;  // LCD Standard Commands, Horizontal addressing mode.
	call	lcdsend

	ldi		r16, 0x0c				;  // LCD in normal mode.
	call	lcdsend

;-------------------------------------Initialse Timer0 for random numbers
	ldi		r16,1
	out		TCCR0,r16


;------------------------------------- Initialise variables
	ldi		r16,0
	sts		menu_pos,r16
	sts		s_pointer,r16

	ldi		r16,15
	sts		snake_len,r16					;inital snake lenght
	clr		tet_stat


	rjmp		main
;-----------------------------
spi_tx_wait:					;******wiat till finished sending SPI
	sbis	SPSR,SPIF
	rjmp	spi_tx_wait
	ret
;-----------------------------
lcdsend:						;*****send lcd command in r16

	cbi		lcd_con,lcd_sce		;select chip
	nop
	cbi		lcd_con,lcd_dc		;select command
	out		SPDR,r16

	call	spi_tx_wait
	sbi		lcd_con,lcd_sce		;unselect 
	nop
	ret
;----------------------
clear_vram:						;********sets all of Vram to 0
	ldi		XL,vramL			;set start of clear (indierct mem ad)
	ldi		XH,vramH
	ldi		r18,0
clear_vram_loop:

	st		X+,r18				;copt r16 to ram

	sbrs	XH,2				;test for end of vram
	rjmp	clear_vram_loop
	ret
;---------------------------
refresh:						;********copy all Vram to LCD
	ldi		r16, 0b10000000		;set to (0,0)
	call	lcdsend
	ldi		r16, 0b01000000		;set to (0,0)
	call	lcdsend

								;refresh Vram to lcd
	cbi		lcd_con,lcd_sce		;select chip
	nop
	sbi		lcd_con,lcd_dc		;select data

	ldi		XL,vramL			;set start of output
	ldi		XH,vramH
refresh_loop:
	ld		r16,X+
	out		SPDR,r16
	call	spi_tx_wait

	sbrs	XH,2				;test for end of vram
	rjmp	refresh_loop

	ldi		r16, 0b10000000		;set to (0,0)
	call	lcdsend
	ldi		r16, 0b01000000		;set to (0,0)
	call	lcdsend

	ret
;------------------------------
lcd_goto_XY_text:					;********set X,Y Vram cordinates (textx,texty)
	push	r18
	push	r19

	ldi		r18,84				;get to right line
	mul		r18,texty

	movw	r2,r0				;temp store this value

	ldi		r18,6				;chr width
	mul		r18,textx


	add		r0,r2				;add x value
	adc		r1,r3

	movw	XL,r0				;move to X reg for indirect data...stuff
	
	ldi		r18,vramL			;add vram location offset
	ldi		r19,vramH
	add		Xl,r18
	adc		XH,r19


	pop		r19
	pop		r18

	ret
;----------------------------
lcd_chr_ram:					;*******put chr in r16 at current XY, and  incrmenet
	push	ZL					;retain Z value
	push	ZH
	push	r18
	push	r19

	ldi		ZH,high(font<<1)	;set to start of font table offset
	ldi		ZL, low(font<<1)

	ldi		r18,6				;width of characters
	mul		r18,r16				;get pos chr offset in font table, into r1:r0

	add		ZL,r0				;add chr offset
	adc		ZH,r1

	ldi		r18,6				;width of chrs
lcd_chr_ram_loop:
	lpm		r19,Z+				;copy font to r16
	st		X+,r19				;copy r16 to ram
	dec		r18					;loop counter
	brne	lcd_chr_ram_loop

	inc		textx
	
	pop		r19
	pop		r18
	pop		ZH
	pop		ZL
	ret

;----------------------------
inverse_line:					;******inverse Y text line in Vram, line no in r16
	ldi		r18,84
	mul		r18,r16				;get y line offset

	ldi		XL,vramL			;set start of clear (indierct mem ad)
	ldi		XH,vramH
	
	add		XL,r0				;add Y offset to Vram start
	adc		XH,r1
	ldi		r19,84
inverse_line_loop:
	ld		r18,X				;put data from ram inro r18
	com		r18					;inverse it
	st		X+,r18				;put it back and incrememtn

	dec		r19					;loop counter
	brne	inverse_line_loop

	ret
;--------------------------------
menu_line:						;******diplays a menu label (r16) at a given line (r17)
	push	r18

	ldi		ZH,high(menu_lable<<1)	;set to start of menu table offset
	ldi		ZL, low(menu_lable<<1)

	ldi		r18,14				;chrs per line, getting menu chrs
	mul		r18,r16				;get menu labele pos

	add		ZL,r0				;add menu number offset
	adc		ZH,r1				;now is in correct place to star reading menu chrs

	clr		textx				;furthest left (0,x)
	mov		texty,r17			;enter line number

	call	lcd_goto_XY_text			;goto position



	ldi		r18,14				;chrs per line, for counter(MAKE BETTER!!)
menu_line_loop:
	lpm		r16,Z+				;copy menu chr to r16 and inc
	subi	r16,32
	call	lcd_chr_ram			;place chr

	dec		r18					;loop counter
	brne	menu_line_loop

	pop		r18
	ret
;---------------------------------
	nibble_plot:					;*********set/clear/invert nibble in (r12,r13)
	push	r19
	push	r18
	push	XL
	push	XH
											
								;r16: 1 = set, 2 = clear, 4 = invert, 8 = alt set (for tetris)
	mov		r19,nibbley			;get the correct line (0-5) from nibbley
	lsr		r19					;divide by 2, and loose lsb

	ldi		r18,84
	mul		r18,r19				;get y line offset

	ldi		XL,vramL			;set start of line (indierct mem ad)
	ldi		XH,vramH
	
	add		XL,r0				;add Y offset to Vram start
	adc		XH,r1

	ldi		r18,4
	mul		r18,nibblex				;get x offset

	add		XL,r0				;add X offset to Vram start
	adc		XH,r1


	sbrc	r16,0						;choose if set/clear or invert(set)
	jmp		nibble_plot_set

	sbrc	r16,1						;choose if set/clear or invert(clear)
	jmp		nibble_plot_clear

	sbrc	r16,2						;choose if set/clear or invert(invert)
	jmp		nibble_plot_invert

	sbrc	r16,3						;choose if set/clear or invert(altset)
	jmp		nibble_plot_altset


nibble_plot_set:
	ldi		r18,4
nibble_plot_set_loop:
	ld		r19,X						;load data
		
	sbrc	nibbley,0					;up/lower nibbles
	sbr		r19,0xF0


	sbrs	nibbley,0					;lower
	sbr		r19,0x0F

	st		X+,r19
	
	dec		r18					;loop counter
	brne	nibble_plot_set_loop	

	pop		XH
	pop		XL
	pop		r18
	pop		r19
	ret
;---
nibble_plot_altset:
	ldi		r18,3
nibble_plot_altset_loop:
		ld		r19,X						;load data
		
		sbrc	nibbley,0					;up/lower nibbles
		sbr		r19,0xE0


		sbrs	nibbley,0					;lower
		sbr		r19,0x0E

		st		X+,r19
	
		dec		r18					;loop counter
	brne	nibble_plot_altset_loop	

	pop		XH
	pop		XL
	pop		r18
	pop		r19
	ret
;---
nibble_plot_clear:
	ldi		r18,4
nibble_plot_clear_loop:
	ld		r19,X						;load data
		
	sbrc	nibbley,0					;up/lower nibbles
	cbr		r19,0xF0


	sbrs	nibbley,0					;lower
	cbr		r19,0x0F

	st		X+,r19
	
	dec		r18					;loop counter
	brne	nibble_plot_clear_loop	

	pop		XH
	pop		XL
	pop		r18
	pop		r19
	ret

;---
nibble_plot_invert:
	pop		XH
	pop		XL
	pop		r18
	pop		r19
	ret
;-------------------------

beep:
	ldi		r17,2
	ldi		r18,100
beep_loop:

	sbi		p_port,pez
	call	del
	cbi		p_port,pez
	call	del

	dec		r17
	brne	beep_loop

	dec		r18

	ldi		r17,2

	jmp		beep_loop



	jmp		beep

;--------
tone1:
	push	r17
	push	r18

	ldi		r17,100
	ldi		r18,2
tone1_loop:

	sbi		p_port,pez
	call	del
	cbi		p_port,pez
	call	del

	dec		r17
	brne	tone1_loop


	pop		r18
	pop		r17
	ret
;--------
tone2:
	push	r17
	push	r18

	ldi		r17,50
	ldi		r18,1
tone2_loop:

	sbi		p_port,pez
	call	del
	cbi		p_port,pez
	call	del

	dec		r17
	brne	tone2_loop


	pop		r18
	pop		r17
	ret


main:



	;
	;sbi		portd,5
	;call	tone1
	;call	tone2
;	call	tetris
	call	tone2
;	call	start_snakes
	call	clear_vram

	

	ldi		r16,0				;menu lable
	ldi		r17,0				;line number
	call	menu_line

	ldi		r16,1
	ldi		r17,1
	call	menu_line

	ldi		r16,2
	ldi		r17,2
	call	menu_line

	ldi		r16,3
	ldi		r17,3
	call	menu_line

	ldi		r16,4
	ldi		r17,4
	call	menu_line

	ldi		r16,5
	ldi		r17,5
	call	menu_line

	ldi		r16,6
	ldi		r17,6
	call	menu_line

	ldi		r16,0
	call	inverse_line

	call	refresh
	call	tone1
	call	tone2
	call	tone1
	call	tone2



main_loop:	
	sbis	b_port,b_u
	call	menu_move_up
	nop
	nop

	sbis	b_port,b_d
	call	menu_move_down
	nop
	nop

	sbis	pind,6
	call	menu_select
	nop
	nop





	jmp		main_loop
;----------------------------
menu_move_down:
	call	tone1
	lds		r16,menu_pos
	call	inverse_line		;inverse current line
	inc		r16
	sts		menu_pos,r16
	call	inverse_line		;inverse new line
	call	refresh
	call	debounce
menu_move_down_loop:			;wait for button to be de-pressed

	call	debounce
	sbis	b_port,b_d
	jmp		menu_move_down_loop

	ret
;----------------------------
menu_move_up:
	call	tone1
	lds		r16,menu_pos
	call	inverse_line		;inverse current line
	dec		r16
	sts		menu_pos,r16
	call	inverse_line		;inverse new line
	call	refresh
	call	debounce
menu_move_up_loop:			;wait for button to be de-pressed

	call	debounce
	sbis	b_port,b_u
	jmp		menu_move_up_loop

	ret
;--------------------------

menu_select:
	lds		r16,menu_pos
	clr		r17

	cp		r16,r17
	breq	Menu_1

	inc		r17
	cp		r16,r17
	breq	Menu_2

	inc		r17
	cp		r16,r17
	breq	Menu_3

	inc		r17
	cp		r16,r17
	breq	Menu_4

	inc		r17
	cp		r16,r17
	breq	Menu_5

	inc		r17
	cp		r16,r17
	breq	Menu_6

	
	ret

;----
menu_1:
	jmp		Start_snakes


	ret
menu_2:
	jmp		tetris

	ret
menu_3:
	ldi	r16,255				;callibration byte
	out	osccal,r16

	ret

menu_4:
	push	r16
	ldi		r16,'E'
	call	tx_rs
	ldi		r16,'M'
	call	tx_rs
	ldi		r16,0
	call	tx_rs
	ldi		r16,'B'
	call	tx_rs
	pop		r16
poo:	
	rjmp	poo

	ret

menu_5:
	call	font_test
	call	refresh	

	ret

menu_6:

	ldi		r20,20
test:

	call	debounce

	dec		r20
	brne	test




	sbi		portd,5
	ret

;-------------------------------
;-------------------------------
;-----SNAKES CODE---------------
;-------------------------------
;-------------------------------

start_snakes:
	
	call	reset_pos
	;call	shuf_snake_pos
	call	draw_snake
	call	refresh

	ldi		snake_dir,4
	ldi		r24,50
snake_loop:	
	call	shuf_snake_pos
	
	;inc		snake_x

	ldi		XL,snake_posL
	ldi		XH,snake_posH

	st		X+,snake_x
	st		X,snake_y

	call	draw_snake
	call	refresh




	ldi		r18,30
but_test:
	sbis	b_port,b_d
	ldi		snake_dir,1

	sbis	b_port,b_u
	ldi		snake_dir,2

	sbis	b_port,b_r
	ldi		snake_dir,4

	sbis	b_port,b_l
	ldi		snake_dir,8

	;sbis	pind,7
	;sts		snake_len,r24
	
	call	debounce
	;call	tone2

	dec		r18
	brne 	but_test
	call	tone2

	sbrc	snake_dir,0
	inc		snake_y	

	sbrc	snake_dir,1
	dec		snake_y	

	sbrc	snake_dir,2
	inc		snake_x	

	sbrc	snake_dir,3
	dec		snake_x	

	





	jmp		snake_loop
	nop
	nop

;-------------------
reset_pos:
	push	r18
	push	r20
	push	r21
	push	XL
	push	XH

	lds		r18,snake_len

	ldi		XL,snake_posL
	ldi		XH,snake_posH
	ldi		r20,15			;x pos front of snake starts
	ldi		r21,6			;ypos snake starts (middle)
	
	mov		snake_x,r20
	mov		snake_y,r21

reset_pos_loop:
	st		X+,r20			;store x pos
	st		X+,r21			;store y pos
	dec		r20
	dec		r18
	brne	reset_pos_loop
	
	pop		XH
	pop		XL
	pop		r21
	pop		r20
	pop		r18
	ret
;------------------
draw_snake:						;draw snake to vram
	push	r18
	push	r20
	push	r21

	call	clear_vram

	lds		r18,snake_len

	ldi		YL,snake_posL
	ldi		YH,snake_posH
	ldi		r16,1				;set nibbles
draw_snake_loop:
	ld		nibbleX,Y+
	ld		nibbleY,Y+
	call	nibble_plot

	dec		r18
	brne	draw_snake_loop
	
	pop		r21
	pop		r20
	pop		r18

	ret
;-----------------
shuf_snake_pos:					;move all snake positions down one mem location
	push	r18




	ldi		YL,snake_posL		;read from Y, store using X
	ldi		YH,snake_posH

	ldi		XL,snake_posL		;read from Y, store using X
	ldi		XH,snake_posH

	lds		r18,snake_len
	lsl		r18
	;inc		r18					;can only do PRE decrement (!?)

	clr		r16
	add		YL,r18
	adc		YH,r16
	
	inc		r18					;Y is shifted 2 places down
	inc		r18

	add		XL,r18
	adc		XH,r16

	lds		r18,snake_len
	inc		r18		;counter
shuf_snake_pos_loop:
	ld		r20,-Y
	st		-X,r20

	ld		r20,-Y
	st		-X,r20

	dec		r18
	brne 	shuf_snake_pos_loop	

	pop		r18
	ret

;-----------------------
;--END OF SNAKES--------
;-----------------------
;-----------------------
;-----------------------



;-------------------------------
;-------------------------------
;-----TETRIS CODE---------------
;-------------------------------
;-------------------------------
tetris:


	call	clear_vram

tet_draw_border:
	ldi		YL,tet_boardL			;start of tet memory board
	ldi		YH,tet_boardH



	ldi		ZH,high(tet_blocks<<1)	;set to start of tetris table offset
	ldi		ZL, low(tet_blocks<<1)


	ldi		r18,12
tet_draw_border_loop:

	ldi		r16,0			;0
	st		Y+,r16

	dec		r18
	brne 	tet_draw_border_loop

	ldi		r18,12
tet_draw_border_loop1:

	ldi		r16,128			;128
	st		Y+,r16

	dec		r18
	brne 	tet_draw_border_loop1



;	call	draw_tetris
;	call	refresh

;temp92:	jmp	temp92


	ldi		YL,tet_boardL			;start of tet memory board(draw border)
	ldi		YH,tet_boardH
	ldi		r16,255
	st		Y,r16
	ldi		r17,11
	add		YL,r17
	st		Y+,r16
	st		Y,r16
	add		YL,r17
	st		Y,r16

;	call	tet_delete_lines

;initial position
tet_new_piece:
	ldi		r16,4
	mov		blockY,r16

	ldi		r16,8
	mov		blockX,r16


	in		r16,TCNT0			;used to get random number
	swap	r16					;move top 3 bits to bottom
	lsr		r16
	andi	r16,0b00000111

	ldi		r17,4				;generate block number
	mul		r17,r16
	mov		block_no,r0

	;ldi		r16,12
	;mov		block_no,r16

	;sbr		tet_stat,2
	call	place_block
	call	draw_tetris
	call	refresh


	clr		block_pos
tetris_main_loop:
	
	ldi		r24,20
tet_button_loop:

	dec		r24
	breq	tet_move_down		;timeout

	
	sbis	b_port,b_d
	call	tet_move_left

	sbis	b_port,b_u
	call	tet_move_right

	sbis	b_port,b_l
	call	tone2

	sbis	pind, b_1
	call	tet_rotate_left


	sbis	pind, b_2
	call	tet_rotate_right



	sbis	b_port,b_r
	jmp		tet_move_down

	call	debounce

	jmp		tet_button_loop



;----
tet_move_down:
	cbr		tet_stat,2			;clear old postion
	call	place_block
	
	inc		blockY

	call	test_block			;check if can move

	sbrc	tet_stat,0			;check colision bit
	jmp		tet_block_bottom	;if colision

	
	sbr		tet_stat,2			;set new postion
	call	place_block
	call	draw_tetris
	call	refresh



	call	debounce

	jmp		tetris_main_loop
;---
tet_block_bottom:
	dec		blockY
	
	sbr		tet_stat,2			;set new postion
	call	place_block

	call	tet_delete_lines

	call	draw_tetris
	call	refresh

	call	tone1
	jmp		tet_new_piece




;-----
tet_move_left:

	cbr		tet_stat,2			;clear old postion
	call	place_block
	
	dec		blockX

	call	test_block			;check if can move

	sbrc	tet_stat,0			;check colision bit
	jmp		tet_move_left_fail	;if colision

	
	sbr		tet_stat,2			;set new postion
	call	place_block
	call	draw_tetris
	call	refresh

tet_move_left_loop:

	call	debounce

	dec		r24
	breq	tet_move_down		;timeout



	sbis	b_port,b_d
	jmp		tet_move_left_loop

	ret
tet_move_left_fail:
	inc		blockX
	call	tone2
	jmp		tet_move_left_loop
;----
tet_move_right:

	cbr		tet_stat,2			;clear old postion
	call	place_block
	
	inc		blockX

	call	test_block			;check if can move

	sbrc	tet_stat,0			;check colision bit
	jmp		tet_move_right_fail	;if colision

	
	sbr		tet_stat,2			;set new postion
	call	place_block
	call	draw_tetris
	call	refresh

tet_move_right_loop:

	call	debounce

	dec		r24
	breq	temp1234		;timeout

	sbis	b_port,b_u
	jmp		tet_move_right_loop

	ret
tet_move_right_fail:
	dec		blockX
	call	tone2
	jmp		tet_move_right_loop

	ret
;--------

temp1234:					;ahhhh, out of range relative jmp
	jmp		tet_move_down

;----

tet_rotate_right:
	push	block_pos
	push	block_no

	cbr		tet_stat,2			;clear old postion
	call	place_block
	
	ldi		r19,4

	inc		block_pos
	inc		block_no

	sbrc	block_pos,2				;test for bit 2 (angle 4)
	sub		block_no,r19

	sbrc	block_pos,2				;test for bit 2 (angle 4)
	clr		block_pos


	call	test_block			;check if can move

	sbrc	tet_stat,0			;check colision bit
	jmp		tet_rotate_right_fail	

	pop		r19					;get stack back in sync
	pop		r19

	sbr		tet_stat,2			;set new postion
	call	place_block
	call	draw_tetris
	call	refresh


tet_rotate_right_loop:
	call	debounce

	dec		r24
	breq	temp1234		;timeout

	sbis	pind,b_2
	jmp		tet_rotate_right_loop

	ret

tet_rotate_right_fail:
	pop		block_no
	pop		block_pos
	call	tone2
	jmp		tet_rotate_right_loop
;-----

tet_rotate_left:
	ret


;-----
tet_delete_lines:
	;call	tone2				

	ldi		YL,tet_boardL			;start of the memory board
	ldi		YH,tet_boardH
	ldi		r16,10
	;add		YL,r16

	inc		YL						;dont test boarder

	ser		r18
tet_delete_lines_test:				;tests for complete line in top half
		ld		r17,Y+
		and		r18,r17

		dec		r16
		brne	tet_delete_lines_test
	
		tst		r18						;test for zero, if zero, then no complete lines
	breq	tet_delete_lines2		;now test bottom row

;	call	tone2

	clr		r17

	;ldi		r18,16					;TEST

tet_delete_lines_test1:				;finds first complete line		
		;call	tone2				
		sec								;set carry

		ror		r17						;generate mask byte

		sbrs	r18,7	
		lsl		r18

		sbrs	r18,7	
	jmp		tet_delete_lines_test1		



	ldi		YL,tet_boardL			;start of the memory board
	ldi		YH,tet_boardH
	ldi		r16,10
	;add		YL,r16
	
	inc		YL						;dont test borader

tet_delete_lines_loop:

	ld		r19,Y					;get line data
	mov		r20,r19					;copy to another reg

	and		r20,r17					;mask off bottom bits
	com		r17						;invert mask
	lsr		r17						;fing

	and		r19,r17					;mask top bits

	lsl		r19						;move down
	or		r19,r20					;combine registers
	st		Y+,r19
	
	sec								;set carry
	rol		r17
	com		r17	
					
	dec		r16
	brne	tet_delete_lines_loop

	jmp		tet_delete_lines

return:
	ret

tet_delete_lines2:	
;	call	tone1
	ldi		YL,tet_boardL			;start of the memory board
	ldi		YH,tet_boardH
	ldi		r16,13
	add		YL,r16

	ldi		r16,10						;dont test boarder

	ldi		r18,127
tet_delete_lines2_test:				;tests for complete line in top half
	ld		r17,Y+
	and		r18,r17

	dec		r16
	brne	tet_delete_lines2_test
	
	tst		r18						;test for zero, if zero, then no complete lines
	breq	return								;return from routine

	call	tone1
	clr		r17


tet_delete_lines2_test1:				;finds first complete line		
	sec								;set carry

	ror		r17						;generate mask byte

	sbrs	r18,7	
	lsl		r18

	sbrs	r18,7	
	jmp		tet_delete_lines2_test1	

	ldi		YL,tet_boardL			;start of the memory board
	ldi		YH,tet_boardH
	;ldi		r16,13
	;add		YL,r16
	inc		YL
	ldi		r16,10						;dont test boarder

tet_delete_lines2_loop:
	clc									;clear carry (no bits above board)

	ld		r19,Y					;load top row
	ldi		r20,12
	add		YL,r20
	ld		r20,Y						;load bottom row
	mov		r21,r20						;make a copy


	;mov		r20,r19
	;rol		r19							;

	and		r21,r17					;mask off bottom bits
	com		r17						;invert mask
	lsr		r17						;fing

	and		r20,r17					;mask top bits

	clc	
	rol		r19						;shift top line
	rol		r20						;move down(with carry from top line)
	or		r20,r21					;combine registers

	st		Y,r20					;store bottom line

	ldi		r19,11
	sub		YL,r19					;back to first line
	
	sec								;set carry
	rol		r17
	com		r17	
					
	dec		r16
	brne	tet_delete_lines2_loop

	jmp		tet_delete_lines



bo:
	cbr		tet_stat,2
	call	place_block
	sbis	b_port,b_d
	dec		blockX

	sbis	b_port,b_u
	inc		blockX

	sbis	b_port,b_l
	dec		blockY

	sbis	b_port,b_r
	inc		blockY

	;
	call	test_block

	sbrc	tet_stat,0
	call	tone2

	sbr		tet_stat,2

	call	place_block
	call	draw_tetris
	call	refresh

	call	debounce
	;call	debounce
	call	debounce


	jmp		bo
	call	tone1

lt:
	jmp		lt

;---------------------------
place_block:						;place block number in block_no blockX and blockY cordinates
									;2nd bit in tet_stat determins if place or delete
	sbr		tet_stat,128			;internal variable...set so test_block will write block instead
	call	test_block

	cbr		tet_stat,128
	ret		
place_block1:						;called from test_block

	ld		r20,Y				;load board data to test with

	sbrc	tet_stat,1			;if set, draw block
	jmp		place_block_set

	jmp		place_block_clear

place_block_set:

	
	or		r20,r19					;OR of data
	st		Y,r20					;store data back into memory map

	ret


place_block_clear:

	com		r19
	and		r20,r19
	st		Y,r20

	ret



			
;-------------------
;-------------------
;-------------------
test_block:							;tests if a block will fit in pos blockX and blockY 
									;block can be in 3 'zones' (above or at first half OR overlaping



	push	r21
	push	r20
	push	r19							
	push	r18								;first and second half OR blowe or at second half
	push 	r17
	push	r16
	push	blockX
	push	blockY
	push	YL
	push	YH
	push	ZL
	push	ZH

	cbr		tet_stat,1				;clear test bit

	ldi		YL,tet_boardL			;start of the memory board
	ldi		YH,tet_boardH


	ldi		ZH,high(tet_blocks<<1)	;set to start of tetris table offset
	ldi		ZL, low(tet_blocks<<1)	;setup Z for block access

	ldi		r16,4					;get block position offset
	mul		r16,block_no

	add		ZL,r0					;add block offset, in correct place now.
	adc		ZH,r1




	ldi		r16,8			;test if in first half
	cp		r16,blockY
	brge	test_block_1

	ldi		r16,16			;test if below second half
	cp		blockY,r16
	brge	test_block_3

	jmp		test_block_2	;if not already branched, then must be in overlap

;------
test_block_1:				;first half (blockY <= 8)
	

	add		YL,blockX			;get to memboard pointer to correct place


	ldi		r16,4			;sub 4 from X pos to find if less than 4 (off board)
	sub		blockX,r16
	sub		YL,r16


	ldi		r17,11
test_block_1_loop:
		ldi		r17,11

	cp		r17,blockX				;test to see if off board..if < than 12 then in board
	brsh	test_block_1_dotest		;...and do test!


test_block_1_loop_return:			;have return addess
	ldi		r17,1
	inc		YL
	add		ZL,r17
	adc		ZH,r17					;add carry (better way??)
	dec		ZH
	inc		blockX					;if not on board then get here
	dec		r16
	brne	test_block_1_loop;

	pop		ZH
	pop		ZL
	pop		YH
	pop		YL
	pop		blockY
	pop		blockX
	pop		r16
	pop		r17
	pop		r18
	pop		r19
	pop		r20
	pop		r21
	ret

test_block_1_dotest:
	lpm		r19,Z				;get block data

	ldi		r18,8				;calculate number of Logic shifts needed
	sub		r18,blockY

	tst		r18					;see if blockY = 8 basically
	breq	test_block_1_dotest1



test_block_1_dotest_loop:		;shift block data correct number of times
	lsr		r19

	dec		r18
	brne	test_block_1_dotest_loop




test_block_1_dotest1:			;hummm,, only here so i can skip rotation if needed..change!


	sbrc	tet_stat,7			;if set, then its a block place instead of test
	call	place_block1
			
	;st		Y+,r19				;print data onto board, TESTING 


	ld		r20,Y				;load board data to test with

	and		r20,r19				;test if any bits the same

	breq	test_block_1_loop_return	;if Z, then loop

	sbr		tet_stat,1					;not zero, so set colision flag

	jmp		test_block_1_loop_return


;----

test_block_3:
	ldi		r16,4			;sub 4 from X pos to find if less than 4 (off board)
	sub		blockX,r16

	add		YL,blockX			;get to memboard pointer to correct place

	ldi		r17,12
	add		YL,r17

test_block_3_loop:
	ldi		r17,11
	cp		r17,blockX				;test to see if off board..if < than 12 then in board
	brsh	test_block_3_dotest		;...and do test!


test_block_3_loop_return:			;have return addess

	ldi		r17,1
	inc		YL
	add		ZL,r17
	adc		ZH,r17					;add carry (better way??)
	dec		ZH

	inc		blockX					;if not on board then get here
	dec		r16
	brne	test_block_3_loop

	
	pop		ZH
	pop		ZL
	pop		YH
	pop		YL
	pop		blockY
	pop		blockX
	pop		r16
	pop		r17
	pop		r18
	pop		r19
	pop		r20
	pop		r21

	ret

test_block_3_dotest:
	lpm		r19,Z				;get block data
	
	mov		r20,blockY
	ldi		r18,16				;calculate number of Logic shifts needed
	sub		r20,r18

	tst		r20					;see if blockY = 8 basically
	breq	test_block_3_dotest1



test_block_3_dotest_loop:		;shift block data correct number of times
	lsl		r19

	dec		r20
	brne	test_block_3_dotest_loop




test_block_3_dotest1:			;hummm,, only here so i can skip rotation if needed..change!

	sbrc	tet_stat,7			;if set, then its a block place instead of test
	call	place_block1

	;st		Y+,r19				;print data onto board, TESTING 


	ld		r20,Y				;load board data to test with

	and		r20,r19				;test if any bits the same

	breq	test_block_3_loop_return	;if Z, then loop

	sbr		tet_stat,1					;not zero, so set colision flag

	jmp		test_block_3_loop_return


	ret



;------
test_block_2:				; overlap (8 < blockY < 16)
	
	ldi		r16,4			;sub 4 from X pos to find if less than 4 (off board)
	sub		blockX,r16

	add		YL,blockX			;get to memboard pointer to correct place


	
test_block_2_loop:
	ldi		r17,11
	cp		r17,blockX				;test to see if off board..if < than 12 then in board
	brsh	test_block_2_dotest		;...and do test!


test_block_2_loop_return:			;have return addess
	ldi		r17,1
	inc		YL
	add		ZL,r17
	adc		ZH,r17					;add carry (better way??)
	dec		ZH

	inc		blockX					
	dec		r16
	brne	test_block_2_loop

	
	pop		ZH
	pop		ZL
	pop		YH
	pop		YL
	pop		blockY
	pop		blockX
	pop		r16
	pop		r17
	pop		r18
	pop		r19
	pop		r20
	pop		r21

	ret

test_block_2_dotest:
;--top row half---
	lpm		r19,Z			;get block data, also add 12 to get to next line

	mov		r21,r19			;store data in temp reg

	mov		r20,blockY
	ldi		r18,8				;calculate number of Logic shifts needed
	sub		r20,r18
	mov		r18,r20




test_block_2_dotest_loop:		;shift block data correct number of times
	lsl		r19

	dec		r18
	brne	test_block_2_dotest_loop

	sbrc	tet_stat,7			;if set, then its a block place instead of test
	call	place_block1

	;st		Y,r19				;print data onto board, TESTING 


	ld		r20,Y				;load board data to test with adn add 12

	and		r20,r19				;test if any bits the same
	breq	test_block_2_dotest2	;if Z, then skip next

	sbr		tet_stat,1					;not zero, so set colision flag

	



test_block_2_dotest2:
	ldi		r18,16				;calculate logical shifts
	sub		r18,blockY


test_block_2_dotest2_loop:		;shift block data correct number of times
	lsr		r21
	dec		r18
	brne	test_block_2_dotest2_loop


	mov		r19,r21

	ldi		r18,12
	add		YL,r18

	sbrc	tet_stat,7			;if set, then its a block place instead of test
	call	place_block1
	;st		Y,r21				;print data onto board, TESTING 


	ld		r20,Y				;load board data to test with adn add 12

	

	ldi		r18,12
	sub		YL,r18


	and		r20,r19				;test if any bits the same
	breq	test_block_2_loop_return	;if Z, then loop

	sbr		tet_stat,1					;not zero, so set colision flag

	jmp		test_block_2_loop_return



	RET
;----------------------------
draw_tetris:						;draw tetris board into vram
	push	r16
	push	r17
	push	r18
	push	r19


	ldi		r16,11					;start left of board
	mov		nibbleY,r16

	ldi		r16,5					;top of board
	mov		nibbleX,r16



	ldi		r18,12					;size of board (12 blocks wide)

	ldi		YL,tet_boardL			;start of tet memory board
	ldi		YH,tet_boardH

draw_tetris_loop:					;outer loop -loop thought board bytes
	ld		r17,Y+
	ldi		r19,8					;8 bits in byte
draw_tetris_loop1:					;inner loop -loop thought board bytes bits

	sbrs	r17,0					;test bits, if set, then set nibble
	ldi		r16,2					;testing...sets r16 to be passed to nibble setting routine (2 is clear)


	sbrc	r17,0					
	ldi		r16,8					;8 is alternative set 

	call	nibble_plot				;registers now set up

	inc		nibbleX					;next bit
	ror		r17						;next bit

	dec		r19						;bit loop
	brne 	draw_tetris_loop1

	dec		nibbleY					;move to next y line

	mov		r16,nibbleX				;subtace 8 to get back to correct line
	subi	r16,8
	mov		nibbleX,r16


	dec		r18						;byte loop
	brne 	draw_tetris_loop		;next line.....

	ldi		r18,12	

	ldi		r16,11					;back to left of board
	mov		nibbleY,r16

	ldi		r16,8					;add 8 to get to correct line
	add		nibbleX,r16


	ldi		r17,21					;if r16 is 20, then done second line :-)
	cpse	nibbleX,r17
	jmp		draw_tetris_loop

	pop		r19
	pop		r18
	pop		r17
	pop		r16

	ret








debounce:						;de-bounce keys,duhhhh
	push	r19
	push	r18

	ldi		r18,100
debounce1:
	ldi		r19,200
debounce1_loop:
	dec		r19
	nop
	nop
	nop
	brne	debounce1_loop

	dec		r18
	brne	debounce1

	pop		r18
	pop		r19
	ret
;----------------------
del:						
	push	r19
	push	r18

	;ldi		r18,255
del1:
	ldi		r19,150
del1_loop:
	dec		r19
	nop
	nop
	nop
	brne	del1_loop

	dec		r18
	brne	del1

	pop		r18
	pop		r19
	ret


stag:
;	rjmp	stag

	push	YH
	push	YL
	push	r19
	push	r18
	push	r17
	push	r16

	;call	tone1
	in		r18,sreg				;save status

	in		YL,SPL					;low stack pointer
	in		YH,SPH					;High stack pointer

	adiw	YL,7					;now add  (pushes - 1) x 2
	

	ld		r16,Y+					;NOTE 16 has HIGH byte
	ld		r17,Y					;NOTE 17 has LOW byte

	lds		r19,stag_stat
	sbrc	r19,0					;check if a step, therefore break
	rjmp	stag_break

	ldi		YL,0x60					;now start to compare break points
	clr		YH

	ld		r19,Y+					;compare first BP
	cp		r19,r16					;comp low byte
	ld		r19,Y+
	cpc		r19,r17					;comp high byte
	breq	stag_break				;break point found!!!

	ld		r19,Y+					;compare first BP
	cp		r19,r16					;comp low byte
	ld		r19,Y+
	cpc		r19,r17					;comp high byte
	breq	stag_break				;break point found!!!

	ld		r19,Y+					;compare first BP
	cp		r19,r16					;comp low byte
	ld		r19,Y+
	cpc		r19,r17					;comp high byte
	breq	stag_break				;break point found!!!

	ld		r19,Y+					;compare first BP
	cp		r19,r16					;comp low byte
	ld		r19,Y+
	cpc		r19,r17					;comp high byte
	breq	stag_break				;break point found!!!


	sbic	UCSRA,RXC				;check if recived a byte
	rjmp	stag_break


stag_exit:

	clr		r16
	out		TCNT2,r16

	out		sreg,r18
	sbi		UCSRA,UDRE	
	;sei
	pop		r16
	pop		r17
	pop		r18
	pop		r19
	pop		YL
	pop		YH
;	sei

	;sbi		UCSRA,UDRE	

	reti

stag_break:
	;call	tone1
	clr		r19
	sts		stag_stat,r19

	call	tx_rs				;send next Address
	mov		r16,r17
	call	tx_rs

stag_idle:
	call	stag_wait_rx
	
;	cbi		UCSRA,RXC
	
stag_rx:
	;call	tone1

	in		r19,UDR				;read data


	cpi		r19,'R'
	breq	stag_rx_Run			;full speed run

	cpi		r19,'D'		
	breq	stag_rx_Debug		;debug run

	cpi		r19,'X'		
	breq	stag_rx_Reset		;reset

	cpi		r19,'S'
	breq	stag_rx_Step		;step

	cpi		r19,'G'
	breq	stag_rx_Reg_rx			;send registers

	cpi		r19,'B'
	breq	stag_rx_BP			;recive new Break point 


	rjmp	stag_exit
;----
stag_wait_rx:					;wait till a character is recived
	sbis	UCSRA,RXC
	rjmp	stag_wait_rx
	ret
;----

stag_rx_Reset:					;jump to reset vector...expermintal..
	jmp		0


stag_rx_Run:					;turn off debug mode and free run, turn on RX int
	call 	stag_ack

	call	stag_int_off
	rjmp	stag_exit

stag_rx_Debug:					;turn on debug mode
	call 	stag_ack
	call	stag_int_on

	rjmp	stag_exit
;----
stag_rx_Step:
	;call	tone2
	
	call 	stag_ack
	call	stag_int_on

	ldi		r19,1				;set step bit
	sts		stag_stat,r19

	rjmp	stag_exit
;----
stag_ack:
	ldi		r16,'O'				;send ack command 0
	call	tx_rs
	mov		r16,r19				;send BACK char too
	call	tx_rs
	ret
;----
stag_rx_BP:						;set a new break point

	call	stag_wait_rx
	in		r16,UDR
	lsl		r16					;mul by 2
	clr		YH
	ldi		YL,0x60
	add		YL,r16				;set which break point (0-2)



	call	stag_wait_rx
	in		r16,UDR
	st		Y+,r16


	call	stag_wait_rx
	in		r16,UDR
	st		Y+,r16

	call	stag_ack


	rjmp	stag_idle

stag_rx_Reg_rx:
						;send all register out rs232#
	call 	stag_ack
	;call	del

	clr		YH
	clr		YL

	ldi		r19,16

stag_Reg_rx_loop:				;send 0 to 15
	ld		r16,Y+
	call	tx_rs
	dec		r19
	brne	stag_Reg_rx_loop

									;NOTE, r16-19 and YL, YH are in the stack!
	in		YL,SPL					;low stack pointer
	in		YH,SPH					;High stack pointer
	adiw	YL,1					;add 1 get to 16

	ld		r16,Y+
	call	tx_rs
	ld		r16,Y+
	call	tx_rs
	ld		r16,Y+
	call	tx_rs
	ld		r16,Y+
	call	tx_rs

	ldi		YL,20

	ldi		r19,8					;counter, sending r20-r27
stag_Reg_rx_loop2:
	ld		r16,Y+
	call	tx_rs
	dec		r19
	brne	stag_Reg_rx_loop2

	in		YL,SPL					;low stack pointer
	in		YH,SPH					;High stack pointer
	adiw	YL,5					;add 5 to get YL,YH(r28,r29)

	ld		r16,Y+
	call	tx_rs
	ld		r16,Y+
	call	tx_rs

	mov		r16,r30
	call	tx_rs
	mov		r16,r31
	call	tx_rs


	rjmp	stag_idle



stag_int_on:
	ldi		r16,128				;int on
	out		TIMSK,r16
	cbi		UCSRB,RXCIE
	ret
stag_int_off:
	ldi		r16,0				;int off
	out		TIMSK,r16
	sbi		UCSRB,RXCIE
	ret


;-----------------------		;*********font screen test
font_test:
	ldi		ZH,high(font<<1)	;set to start of font table
	ldi		ZL, low(font<<1)

	ldi		XL,vramL			;set to start of Vram
	ldi		XH,vramH
font_test_loop:
	lpm		r16,Z+				;copy font to r16
	st		X+,r16				;copy to vram

	sbrs	XH,2				;test for end of vram
	rjmp	font_test_loop
	ret
;---------------------------
;--send serial--
tx_rs:

	sbis	UCSRA,UDRE
	rjmp	tx_rs
	;call	delay_1ms
	out		UDR,r16

	ret


.CSEG
menu_lable:
.db "Snakes        "
.db "Tetris        "
.db "Level         "
.db "Sound         "
.db "Font test     "
.db "Backlight Test"



font:
.DB 0x00, 0x00, 0x00, 0x00, 0x00 ;sp
.DB 0x00, 0x00, 0x2f, 0x00, 0x00 ;!
.DB 0x00, 0x07, 0x00, 0x07, 0x00 ;"
.DB 0x14, 0x7f, 0x14, 0x7f, 0x14 ;#
.DB 0x24, 0x2a, 0x7f, 0x2a, 0x12 ;$
.DB 0xc4, 0xc8, 0x10, 0x26, 0x46 ;%
.DB 0x36, 0x49, 0x55, 0x22, 0x50 ;&
.DB 0x00, 0x05, 0x03, 0x00, 0x00 ;'
.DB 0x00, 0x1c, 0x22, 0x41, 0x00 ;(
.DB 0x00, 0x41, 0x22, 0x1c, 0x00 ;)
.DB 0x14, 0x08, 0x3E, 0x08, 0x14 ;*
.DB 0x08, 0x08, 0x3E, 0x08, 0x08 ;+
.DB 0x00, 0x00, 0x50, 0x30, 0x00 ;,
.DB 0x10, 0x10, 0x10, 0x10, 0x10 ;-
.DB 0x00, 0x60, 0x60, 0x00, 0x00 ;.
.DB 0x20, 0x10, 0x08, 0x04, 0x02 ;/
.DB 0x3E, 0x51, 0x49, 0x45, 0x3E ;0
.DB 0x00, 0x42, 0x7F, 0x40, 0x00 ;1
.DB 0x42, 0x61, 0x51, 0x49, 0x46 ;2
.DB 0x21, 0x41, 0x45, 0x4B, 0x31 ;3
.DB 0x18, 0x14, 0x12, 0x7F, 0x10 ;4
.DB 0x27, 0x45, 0x45, 0x45, 0x39 ;5
.DB 0x3C, 0x4A, 0x49, 0x49, 0x30 ;6
.DB 0x01, 0x71, 0x09, 0x05, 0x03 ;7
.DB 0x36, 0x49, 0x49, 0x49, 0x36 ;8
.DB 0x06, 0x49, 0x49, 0x29, 0x1E ;9
.DB 0x00, 0x36, 0x36, 0x00, 0x00 ;:
.DB 0x00, 0x56, 0x36, 0x00, 0x00 ;;
.DB 0x08, 0x14, 0x22, 0x41, 0x00 ;<
.DB 0x14, 0x14, 0x14, 0x14, 0x14 ;=
.DB 0x00, 0x41, 0x22, 0x14, 0x08 ;>
.DB 0x02, 0x01, 0x51, 0x09, 0x06 ;?
.DB 0x32, 0x49, 0x59, 0x51, 0x3E ;@
.DB 0x7E, 0x11, 0x11, 0x11, 0x7E ;A
.DB 0x7F, 0x49, 0x49, 0x49, 0x36 ;B
.DB 0x3E, 0x41, 0x41, 0x41, 0x22 ;C
.DB 0x7F, 0x41, 0x41, 0x22, 0x1C ;D
.DB 0x7F, 0x49, 0x49, 0x49, 0x41 ;E
.DB 0x7F, 0x09, 0x09, 0x09, 0x01 ;F
.DB 0x3E, 0x41, 0x49, 0x49, 0x7A ;G
.DB 0x7F, 0x08, 0x08, 0x08, 0x7F ;H
.DB 0x00, 0x41, 0x7F, 0x41, 0x00 ;I
.DB 0x20, 0x40, 0x41, 0x3F, 0x01 ;J
.DB 0x7F, 0x08, 0x14, 0x22, 0x41 ;K
.DB 0x7F, 0x40, 0x40, 0x40, 0x40 ;L
.DB 0x7F, 0x02, 0x0C, 0x02, 0x7F ;M
.DB 0x7F, 0x04, 0x08, 0x10, 0x7F ;N
.DB 0x3E, 0x41, 0x41, 0x41, 0x3E ;O
.DB 0x7F, 0x09, 0x09, 0x09, 0x06 ;P
.DB 0x3E, 0x41, 0x51, 0x21, 0x5E ;Q
.DB 0x7F, 0x09, 0x19, 0x29, 0x46 ;R
.DB 0x46, 0x49, 0x49, 0x49, 0x31 ;S
.DB 0x01, 0x01, 0x7F, 0x01, 0x01 ;T
.DB 0x3F, 0x40, 0x40, 0x40, 0x3F ;U
.DB 0x1F, 0x20, 0x40, 0x20, 0x1F ;V
.DB 0x3F, 0x40, 0x38, 0x40, 0x3F ;W
.DB 0x63, 0x14, 0x08, 0x14, 0x63 ;X
.DB 0x07, 0x08, 0x70, 0x08, 0x07 ;Y
.DB 0x61, 0x51, 0x49, 0x45, 0x43 ;Z
.DB 0x00, 0x7F, 0x41, 0x41, 0x00 ;[
.DB 0x55, 0x2A, 0x55, 0x2A, 0x55 ;55
.DB 0x00, 0x41, 0x41, 0x7F, 0x00 ;]
.DB 0x04, 0x02, 0x01, 0x02, 0x04 ;^
.DB 0x40, 0x40, 0x40, 0x40, 0x40 ;_
.DB 0x00, 0x01, 0x02, 0x04, 0x00 ;'
.DB 0x20, 0x54, 0x54, 0x54, 0x78 ;a
.DB 0x7F, 0x48, 0x44, 0x44, 0x38 ;b
.DB 0x38, 0x44, 0x44, 0x44, 0x20 ;c
.DB 0x38, 0x44, 0x44, 0x48, 0x7F ;d
.DB 0x38, 0x54, 0x54, 0x54, 0x18 ;e
.DB 0x08, 0x7E, 0x09, 0x01, 0x02 ;f
.DB 0x0C, 0x52, 0x52, 0x52, 0x3E ;g
.DB 0x7F, 0x08, 0x04, 0x04, 0x78 ;h
.DB 0x00, 0x44, 0x7D, 0x40, 0x00 ;i
.DB 0x20, 0x40, 0x44, 0x3D, 0x00 ;j
.DB 0x7F, 0x10, 0x28, 0x44, 0x00 ;k
.DB 0x00, 0x41, 0x7F, 0x40, 0x00 ;l
.DB 0x7C, 0x04, 0x18, 0x04, 0x78 ;m
.DB 0x7C, 0x08, 0x04, 0x04, 0x78 ;n
.DB 0x38, 0x44, 0x44, 0x44, 0x38 ;o
.DB 0x7C, 0x14, 0x14, 0x14, 0x08 ;p
.DB 0x08, 0x14, 0x14, 0x18, 0x7C ;q
.DB 0x7C, 0x08, 0x04, 0x04, 0x08 ;r
.DB 0x48, 0x54, 0x54, 0x54, 0x20 ;s
.DB 0x04, 0x3F, 0x44, 0x40, 0x20 ;t
.DB 0x3C, 0x40, 0x40, 0x20, 0x7C ;u
.DB 0x1C, 0x20, 0x40, 0x20, 0x1C ;v
.DB 0x3C, 0x40, 0x30, 0x40, 0x3C ;w
.DB 0x44, 0x28, 0x10, 0x28, 0x44 ;x
.DB 0x0C, 0x50, 0x50, 0x50, 0x3C ;y
.DB 0x44, 0x64, 0x54, 0x4C, 0x44 ;z


tet_blocks:						;tetris blocks, 7 blocks, angle of each is defined
		
		
; #
;###

.DB 0x08, 0x0C, 0x08, 0x00
.DB 0x0E, 0x04, 0x00, 0x00
.DB 0x02, 0x06, 0x02, 0x00
.DB 0x00, 0x04, 0x0E, 0x00
								;each image is 4 bytes in a colum
;##
;##
.DB 0x00, 0x0C, 0x0C, 0x00		;4 rotations of (square so no change)
.DB 0x00, 0x0C, 0x0C, 0x00		;increase is clockwise rotation
.DB 0x00, 0x0C, 0x0C, 0x00
.DB 0x00, 0x0C, 0x0C, 0x00


;####
.DB 0x04, 0x04, 0x04, 0x04
.DB 0x00, 0x00, 0x0F, 0x00
.DB 0x04, 0x04, 0x04, 0x04
.DB 0x00, 0x00, 0x0F, 0x00


;test
;.DB 96, 144, 144, 224
;.DB 0xff, 0xff, 0xff, 0xff



; ##
;##
.DB 0x08, 0x0C, 0x04, 0x00
.DB 0x00, 0x06, 0x0C, 0x00
.DB 0x08, 0x0C, 0x04, 0x00
.DB 0x00, 0x06, 0x0C, 0x00


;##
; ##
.DB 0x00, 0x04, 0x0C, 0x08
.DB 0x00, 0x0C, 0x06, 0x00
.DB 0x00, 0x04, 0x0C, 0x08
.DB 0x00, 0x0C, 0x06, 0x00



;  #
;###
.DB 0x08, 0x08, 0x0C, 0x00
.DB 0x00, 0x1C, 0x10, 0x00
.DB 0x0C, 0x04, 0x04, 0x00
.DB 0x02, 0x0E, 0x00, 0x00


;#
;###
.DB 0x0C, 0x08, 0x08, 0x00
.DB 0x00, 0x1C, 0x04, 0x00
.DB 0x04, 0x04, 0x0C, 0x00
.DB 0x08, 0x0E, 0x00, 0x00

;;####
.DB 0x04, 0x04, 0x04, 0x04
.DB 0x00, 0x00, 0x0F, 0x00
.DB 0x04, 0x04, 0x04, 0x04
.DB 0x00, 0x00, 0x0F, 0x00