.DEF rTemp         = r20
.DEF rDirection    = r21

.DEF rD = r23
.DEF rB = r24
.DEF rC = r25
.DEF i0 = r0 //immidiate 0
.DEF i1 = r1 //immidiate 1
.DEF i2 = r2 //immidiate 2
.DEF i4 = r3 //immidiate 4
.DEF i8 = r4 //immidiate 8
.DEF i16 = r5 //immidiate 16
.DEF i32 = r6 //immidiate 32

.DEF length = r10
.DEF snakePos = r15

.DEF rRow = r22

.DSEG
    matrix:   .BYTE 8

	bodyDirection: .BYTE 16

	interupt: .BYTE 1

.CSEG
// Interrupt vector table
.ORG 0x0000
     jmp init // Reset vector

.ORG 0x0020
jmp isr_timerOF // Timer 0 overflow vector

//... fler interrupts
.ORG INT_VECTORS_SIZE

    //interrupt handler for timer
isr_timerOF:
	push r18
	ldi r18, 1
	st X, r18
	pop r18
	reti


init:
	 ldi ZH, HIGH(bodyDirection)
	 ldi ZL, LOW(bodyDirection)


     // Sätt stackpekaren till högsta minnesadressen
     ldi rTemp, HIGH(RAMEND)
     out SPH, rTemp
     ldi rTemp, LOW(RAMEND)
     out SPL, rTemp

	 ldi XH, HIGH(interupt)
     ldi XL, LOW(interupt)

     ldi r16, 0b11001111
     out DDRC, r16

     ldi r16, 0b11111111
     out DDRD, r16

     ldi r16, 0b11111111
     out DDRB, r16


	 //sätter värdet på olika icke-immediate register så att vi kan lättare få tillgång till användbara siffror
	 sub r0, r0
	 ldi r18, 1
	 mov r1, r18
	 ldi r18, 2
	 mov r2, r18
	 ldi r18, 4
	 mov r3, r18
	 ldi r18, 8
	 mov r4, r18
	 ldi r18, 16
	 mov r5, r18
	 ldi r18, 32
	 mov r6, r18

	 mov r10, r0

	 ldi r18, 0b00110011
	 mov snakePos, r18
     //Global Interrupt Enable
     sei

     //Enable Timer Interrupt
     ldi r18, 0b00000001
     sts TIMSK0, r18

     //  A/D Omvandlare
     ldi r16, 0b01000000
     sts ADMUX, r16

     ldi r16, 0b10000111
     sts ADCSRA, r16

     mov r17, i0
     //
       // Första fyra bitarna representerar analog input 4 (y axeln)
    ldi r16, 0b01000010
    sts ADMUX, r16

    //Sätter bit 6 till 1. För att starta omvandling
    ldi r16, 0b11100011
    sts ADCSRA, r16

	mov r7, i0




start:
    //Laddar in matrisen "matrix" i Y
    ldi ZH, HIGH(matrix)
    ldi ZL, LOW(matrix)
    ldi r19, 0
    //st Y, i0

    //Skriv spel logik här  vvvvv

	//tar fram X värdet från snakePos och pushar den till bitarna längst till höger
	ldi r16, 0b11110000
	and r16, snakePos
	LSR r16
	LSR r16
	LSR r16
	LSR r16

	//tar fram Y värdeet från snakePos
	ldi r17, 0b00001111
	and r17, snakePos




	//itererar ner till rätt rad i Y värdet
miniy:
	cp r17, i0
	breq miniyend
	sub r17, i1
	adiw Z, 1

	jmp miniy

miniyend:


	//itererar till rätt X värde i kolumnen
	ldi r18, 0b10000000
minix:
	cp r16, i0
	breq minixend
	sub r16, i1
	LSR r18
	jmp minix

minixend:
	ld r17, Z
	or r18, r17
	ldi r18, 0b11111111
	st Z, r18

	ldi YH, HIGH(matrix)
    ldi YL, LOW(matrix)

	//ser till att vi loopar alla rader 32 gånger innan den kör spel logiken igen
	add r7, i1
	cp r7, i32
	breq loop

	mov r7, i0

    /*
    ldi r18, 0b10000001
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b01000010
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b00100100
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b00000000
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b0011000
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b00100100
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b01000010
    st Y+, r18
    //adiw Y, 1
    ldi r18, 0b10000001
    st Y, r18*/

    //                      ^^^^^

loop:
    //Skriver r18 till en plats i Y
    //Detta stycket borde också finnas med i spel logiken senare
    ldi r20, 0b00000011
    out TCCR0B, r20
    ld rRow, Y
    mov rD, rRow




    add r11, i1
    cp r11, i8
    brne dontset0

    mov r1, i0


dontset0:
    //Byter plats på bits. 7 är vänster, 0 är höger
    bst rRow, 7
    bld rD, 6
    bst rRow, 6
    bld rD, 7

    bst rRow, 5
    bld rD, 0
    bst rRow, 0
    bld rD, 5

    bst rRow, 4
    bld rD, 1
    bst rRow, 1
    bld rD, 4

    bst rRow, 3
    bld rD, 2
    bst rRow, 2
    bld rD, 3


    //Kopierar rD till rB
    mov rB, rD

    //sparar de relevanta bitsen i rD till portD
    andi rD, 0b11000000

    //sparar de relevanta bitsen i rB till portB
    andi rB, 0b00111111



//Start av indexering
//Switch case funktion gör olika saker beroende på vilken rad
index0:
    cpi r19, 0
    brne index1

    ldi rC, 0b00000001

    rjmp indexEnd
index1:
    cpi r19, 1
    brne index2

    ldi rC, 0b00000010

    rjmp indexEnd
index2:
    cpi r19, 2
    brne index3

    ldi rC, 0b00000100

    rjmp indexEnd
index3:
    cpi r19, 3
    brne index4

    ldi rC, 0b00001000

    rjmp indexEnd
index4:
    cpi r19, 4
    brne index5

    ori rD, 0b00000100

    rjmp indexEnd
index5:
    cpi r19, 5
    brne index6

    ori rD, 0b00001000

    rjmp indexEnd
index6:
    cpi r19, 6
    brne index7

    ori rD, 0b00010000

    rjmp indexEnd
index7:
    cpi r19, 7
    brne indexEnd

    ori rD, 0b00100000

indexEnd:

    //Tänder lampor
    out PORTD, rD
    out PORTB, rB
    out PORTC, rC

noppp:
	ld r8, X
	cp r8, i0
	breq noppp
	st X, i0

    //rensar alla lampor
    ldi r18, 0b00000000
    mov rD, r18
    mov rB, r18
    mov rC, r18
    out PORTC, rC
    out PORTB, rB
    out PORTD, rD
//Iteration
    adiw Y, 1
    subi r19, -1
	//lägg till register som "klocka"



    //onödig loop för tillfället

    cpi r19, 8
    brne nojump

    rjmp start


nojump:
    rjmp loop