assembly.txt

;kartan består av 32*32 bitar, där varje bit bestämmer om det är ett hinder i den cellen.
;32 * 32 bitar = 1024 bitar = 64 words

;var äpplet befinner sig bestäms av en word som beskriver X, och Y. 

;krävs en word för att bestämma en cell (5 bitar för X, 5 bitar för Y. 2^5 = 32)
;varje orm har en cirkulär array av celler den ockuperar, eller har ockuperat.
;finns en head, och en tail, för varje orm som beskriver var i arrayen ormen börjar, och var den slutar.
;en orm kan vara max 62 celler lång, så arrayen är 64 words (två extra för head och tail)

;menyn behöver en statisk bild att visa. Den är 32*32*4 bitar stor = 256 words

;karta över PM:
;programmet börjar på 0 och växer neråt
;return adress ligger på $AF8
;Orm1 head ligger på $AF9
;Orm1 tail ligger på $AFA
;Orm2 head ligger på $AFB
;Orm2 tail ligger på $AFC
;Score ligger på $AFD
;Orm1 föregående håll ligger på $AFE
;Orm2 föregående håll ligger på $AFF
;menybild ligger på minesadress $B00 - $BFF
;orm1 ligger på minnesadress $C00 - $C3F = 3072 - 3135
;orm2 ligger på minnesadress $C40 - C7F = 3136 - 3199
;kartan ligger på minnesadress $C80 - $CBF = 3200 - 3263
;äpplet ligger på minnesadress $CC0 = 3264
;spelhastigheten (frame-tid i ms) ligger på minssadress $CC1 = 3265
;random minne för implementationer läggs på $D00 - slut = 3328 - slut

;Tiles:
;	0000 = 0, tomt
;   1111 = F, hinder
;   0010 = 2, orm1
;	0011 = 3, orm2
;	0100 = 4, äpple

;menyn fungerar så att joystick1 bestämmer spelhastighet med antingen höger, vänster, upp eller ner. Därefter går vi direkt till spelet

;---------------------------------------MENU-DELEN-------------------

MENU
	LOAD #0, Gr12; ladda in 0 som startvärde för x
	LOAD #0, Gr13; ladda in 0 som startvärde för y

MENULOOPX
	LOAD #MENULOOPXRETURN, Gr14;
	BRA #TOGMEM;
MENULOOPXRETURN
	;Nu innehåller Gr15 Y-adressen konkatenerat med X-adressen, redo för GMEM
	
	;Behöver indexera minnesrymden som innehåller menybilden.
	STORE $D00, Gr13; Lägg y * (32bitar = 8 words) i Gr2 som är word-index i statiska bilden
	LOAD $D00, Gr2;
	;MUL #8, Gr2;
	LSL #3, Gr2;
	STORE $D00, Gr12; Lägg till x // 4 till Gr3, för att få rätt word-offset i x-led
	LOAD $D00, Gr3; 
	;DIV #4, Gr3; heltalsdivision (avrunda nedåt)
	LSR #2, Gr3; heltalsdivision
	STORE $D00, Gr3;
	ADD $D00, Gr2;
	;nu innehåller Gr2 hela adressen till det word som vår sökta tile ligger i
	
	;behöver ta reda på vilken tile i detta word vi är ute efter
	STORE $D00, Gr12; Spara (x mod 4) till Gr3, vilket är tile-index i wordet
	LOAD $D00, Gr3;
	;MOD #4, Gr3;
	AND #$0003, Gr3; MOD #4
	;SUB #1, Gr3;
	;nu innehåller Gr3 tile-index i wordet
	
	LOAD $B00, Gr4, Gr2; Ladda in rätt word från bilden till register 4
	;MUL #4, Gr3; multiplicera tile-index för att få hur långt vi måste shifta i wordet
	LSL #2, Gr3;
	STORE $D00, Gr4; Shifta wordet så att vår tile hamnar längs till vänster (MSBs, vilket är vad GMEMet tar från bussen)
	LSL $D00, Gr4
	AND Gr4, #$F000; ANDa bort de bitar som låg efter vår tile i wordet
	
	;Nu innehåller Gr4 den tile som ska ut på bussen och in i GMEM! :D
	;Gr15 innehåller den adress i GMEM som tilen ska sparas på, vilket är enligt överenskommelse.
	GSTORE Gr4;
	
	ADD #1, Gr12;
	CMP #32, Gr12;
	BNE #MENULOOPX; om vi inte loopat fördigt på x, gör det igen
	;annars, gå vidare ner till Y
	
	;LOOP Y
	ADD #1, Gr13;
	CMP #32, Gr13;
	LOAD #0, Gr12; nollställ X, på nästa rad
	BNE #MENULOOPX; om vi inte loopat färdigt på Y, fortsätt loopa
	;annars (vi har loopat färdigt), gå vidare
	
	;---------------------
	
	
	
MENULOOP
	SPI Gr0; ladda SPI-data till gr0
	AND #$000F, Gr0; anda bort andra joysticks
	CMP #1, Gr0;
	BEQ #UPDIRSPEED;
	CMP #2, Gr0;
	BEQ #RIGHTDIRSPEED;
	CMP #3, Gr0;
	BEQ #DOWNDIRSPEED;
	CMP #4, Gr0;
	BEQ #LEFTDIRSPEED;
	BRA #MENULOOP; var inget håll, fortsätt kolla.

UPDIRSPEED
	LOAD  #1000, Gr0;
	BRA #STORESPEED;
RIGHTDIRSPEED
	LOAD  #800, Gr0;
	BRA #STORESPEED,
DOWNDIRSPEED
	LOAD  #600, Gr0;
	BRA #STORESPEED;
LEFTDIRSPEED
	LOAD  #400, Gr0;
	BRA #STORESPEED;

STORESPEED
	STORE #$CC1, Gr0; lägg in vald hastighet på rätt minnesplats
	;gå vidare till UART

;-------------------------------------------UART-DELEN----------------
	
UART
	;kartan består av 64 words. vi hämtar dem och räknar upp varje gång
	LOAD #0, Gr0;
UARTLOOP
	BOU #UARTREADY ;kolla om uart har ett word redo att hämtas
	BRA #UARTLOOP ;fortsätt vänta
UARTREADY
	UART Gr1; ladda Uart-wordet till Gr1
	STORE #$C80, Gr1, Gr0; Lägg till wordet på rätt ställe. använder Gr0 som index
	ADD #1, Gr0; incrementera countern
	CMP #64, Gr0; kolla om vi är färdiga
	BEQ #GAME; isf, hoppa till spelet
	BRA #UARTLOOP; annars, fortsätt leta words
	
;-----------------------------------GAME INIT-----------------------------
	
GAME
	LOAD #0, Gr0;
	STORE $AFD, Gr0; reseta score
	
	LOAD #1, Gr1;
	STORE $AFE, Gr1; orm1 börjar åt höger
	
	LOAD #3, Gr1;
	STORE $AFF, Gr1; orm2 börjar åt vänster
	
	LOAD #16, Gr12; sätt äpplet i mitten
	LOAD #16, Gr13;
	LOAD #GAMERETURN, Gr14; förbered TOGMEM-kall
	BRA #TOGMEM;
GAMERETURN
	STORE $CC0, Gr15; spara adressen till äpplet
	
	
	;reseta ormarnas arrays
	LOAD #0, Gr0; loop-variabel
	LOAD #0, Gr1; konstant 0
RESETSNAKESLOOP
	STORE $C00, Gr1, Gr0; sätt 0 på cur i orm1
	STORE $C40, Gr1, Gr0; - || -          orm2
	ADD #1, Gr0; inkrementera countern
	CMP #64, Gr0; kolla om kommit genom hela arrayen
	BNE #RESETSNAKESLOOP; om vi inte är färdiga, gör om
	;annars (vi är färdiga), gå vidare

	LOAD #4, Gr12; X och Y för orm1 start
	LOAD #4, Gr13;
	LOAD #SETSTARTRETURN1, Gr14;
	BRA #TOGMEM;
SETSTARTRETURN1
	STORE $C00, Gr15; spara X, Y på första stället i orm1-array
	LOAD #0, Gr0; sätt orm1 head och tail-pekare till 0
	STORE $AF9, Gr0; head
	STORE $AFA, Gr0; tail
	
	
	LOAD #27, Gr12; X och Y för orm2 start
	LOAD #27, Gr13;
	LOAD #SETSTARTRETURN2, Gr14;
	BRA #TOGMEM;
SETSTARTRETURN2
	STORE $C40, Gr15; spara X, Y på första stället i orm1-array
	LOAD #0, Gr0; sätt orm2 head och tail-pekare till 0
	STORE $AFB, Gr0; head
	STORE $AFC, Gr0; tail	

;----------------PRINTA KARTAN
PRINTMAP
	LOAD #0, Gr0;
	LOAD #0, Gr1;
	
PRINTMAPLOOPX
	STORE $F00, Gr0; kopiera X och Y till in-register till TOGMEM
	STORE $F01, Gr1;
	LOAD $F00, Gr12;
	LOAD $F01, Gr13;
	LOAD #PRINTMAPRETURN, Gr14; return-adress
	BRA #TOGMEM
PRINTMAPRETURN
	;nu har vi X och Y på GMEM-form i Gr15
	LOAD #PRINTMAPRETURN2, Gr14;
	BRA #GETOBSTACLEBYGMEM
PRINTMAPRETURN2
	;nu har vi FFFF i Gr11 om det är ett hinder på pos
	GSTORE Gr11; F är tile-värdet för hinder
	ADD #1, Gr0; öka X
	CMP #32, Gr0; 
	BNE #PRINTMAPLOOPX; om vi inte är färdiga med raden
	;annars ( vi är färdiga med raden) fortsätt ner

PRINTMAPLOOPY
	LOAD #0, Gr0;
	ADD #1, Gr1;
	CMP #32, Gr1;
	BNE #PRINTMAPLOOPX; om vi inte är färdiga, fortsätt loopa
	;annars (vi är färdiga) gå vidare
	
	
;--------------------------------------GAME LOOP-------------
	
	
GAMELOOP


SNAKELOADOLD1
	;först spara positionen gamla huvudet är på. 
	LOAD $AF9, Gr0; ladda head-pointern till Gr0
	;dags att förberade subrutinkall till FROMGMEM
	LOAD $C00, Gr15, Gr0; ladda Gr15 med gamla huvudets position (Gr0 som index)
	LOAD #SNAKERETURNA, Gr14; returadress
	BRA #FROMGMEM; Lägger X, Y i Gr12, Gr13
SNAKERETURNA
	
	; nu: Gr12, Gr13 innehåller X, Y
	; ska ge dem rätt värde utifrån rörelseriktning
	
	SPI Gr0;
	AND #$000F, Gr0; anda bort andra joysticks
	CMP #1, Gr0;
	BEQ #SNAKEUP1;
	CMP #2, Gr0;
	BEQ #SNAKERIGHT1;
	CMP #3, Gr0;
	BEQ #SNAKEDOWN1;
	CMP #4, Gr0;
	BEQ #SNAKELEFT1;
	;annars (inget håll nedtryckt):
	LOAD $AFE, Gr1; ladda in gammal direction
	CMP #0, Gr1;
	BEQ #SNAKEUP1;
	CMP #1, Gr1;
	BEQ #SNAKERIGHT1;
	CMP #2, Gr1;
	BEQ #SNAKEDOWN1;
	CMP #3, Gr1;
	BEQ #SNAKELEFT1;
	;har vi inte hittat nåt håll än, you dun goofed
	
SNAKEUP1
	LOAD #0, Gr2; spara håll till store senare
	SUB #1, Gr13; minska Y med 1
	BRA #SNAKESTOREHEADPOS
SNAKERIGHT1
	LOAD #1, Gr2; spara håll till store senare
	ADD #1, Gr12; öka X med 1
	BRA #SNAKESTOREHEADPOS
SNAKEDOWN1
	LOAD #2, Gr2; spara håll till store senare
	ADD #1, Gr13; öka Y med 1
	BRA #SNAKESTOREHEADPOS
SNAKELEFT1
	LOAD #3, Gr2; spara håll till store senare
	SUB #1, Gr12; minska X med 1
	BRA #SNAKESTOREHEADPOS
	
	
SNAKESTOREHEADPOS
	STORE $AFE, Gr2; spara håll till orm1s senaste valda håll
	LOAD #SNAKERETURNB, Gr14;
	BRA #TOGMEM; formatera tillbaka till GMEM-form
SNAKERETURNB 
	;Nu ligger första ormens nya huvudposition i Gr15, formaterat för Gmem
	STORE $D00, Gr15; Spara huvudets position för senare användning
	
	; ORM 2: ---------------------------------------------------------------------------------------
SNAKELOADOLD2
	;först spara positionen gamla huvudet är på. 
	LOAD $AFB, Gr0; ladda head-pointern till Gr0
	;dags att förberade subrutinkall till FROMGMEM
	LOAD $C40, Gr15, Gr0; ladda Gr15 med gamla huvudets position (Gr0 som index)
	LOAD #SNAKERETURN2A, Gr14; returadress
	BRA #FROMGMEM; Lägger X, Y i Gr12, Gr13
SNAKERETURN2A

	; nu: Gr12, Gr13 innehåller X, Y
	; ska ge dem rätt värde utifrån rörelseriktning
	
	SPI Gr0;
	AND #$00F0, Gr0; anda bort andra joysticks
	LSR #4, Gr0
	CMP #1, Gr0;
	BEQ #SNAKEUP2;
	CMP #2, Gr0;
	BEQ #SNAKERIGHT2;
	CMP #3, Gr0;
	BEQ #SNAKEDOWN2;
	CMP #4, Gr0;
	BEQ #SNAKELEFT2;
	;annars (inget håll nedtryckt):
	LOAD $AFF, Gr1; ladda in gammal direction
	CMP #0, Gr1;
	BEQ #SNAKEUP2;
	CMP #1, Gr1;
	BEQ #SNAKERIGHT2;
	CMP #2, Gr1;
	BEQ #SNAKEDOWN2;
	CMP #3, Gr1;
	BEQ #SNAKELEFT2;
	;har vi inte hittat nåt håll än, you dun goofed
	
SNAKEUP2
	SUB #1, Gr13; minska Y med 1
	BRA #SNAKESTOREHEADPOS2
SNAKERIGHT2
	ADD #1, Gr12; öka X med 1
	BRA #SNAKESTOREHEADPOS2
SNAKEDOWN2
	ADD #1, Gr13; öka Y med 1
	BRA #SNAKESTOREHEADPOS2
SNAKELEFT2
	SUB #1, Gr12; minska X med 1
	BRA #SNAKESTOREHEADPOS2

	
SNAKESTOREHEADPOS2
	LOAD #SNAKERETURNB2, Gr14;
	BRA #TOGMEM; formatera tillbaka till GMEM-form
SNAKERETURNB2
	;Nu ligger andra ormens nya huvudposition i Gr15, formaterat för Gmem
	STORE $D01, Gr15; Spara huvudets position för senare användning	
	
	
	;nu ligger nya huvud-positionerna  $D00 och $D01
	;dags att flytta fram head och lägga in rätt värde på head-platsen i arraysen
	
	LOAD $AFB, Gr0; orm 2 head pointer till gr0
	ADD #1, Gr0; 
	;MOD #64, Gr0; cirkulär lista. orm-array max 62 lång.
	AND #$003F, Gr0; MOD 64
	LOAD $D01, Gr1; ladda in nya huvudpos till Gr1
	STORE $C40, Gr1, Gr0; spara nya huvudpos på huvudplatsen i orm-arrayen
	STORE $AFB, Gr0; lägg tillbaka nya huvudplatsen
	
	; /orm 2-----------------------------------------------------------
	
	;Dags att kolla kollision med kartan eller äpple
	
;-------------ÄPPLE
	
	;äpple
	LOAD $D00, Gr0; ladda orm1s huvudposition till Gr0
	CMP $CC0, Gr0; jämför med äpplets position
	BEQ #APPLEHIT; om träff, hoppa dit
	;annars, testa också orm2s huvud
	LOAD $D01, Gr0; ladda andra ormens huvud
	CMP $CC0, Gr0; jämför med äpplets position
	BNE #SNAKECHECKMAP1; om ej träff, hoppa förbi träff
	;annars (om träff) går vi automatiskt till APPLEHIT
	;--fixa score
APPLEHIT
	LOAD $AFD, Gr3; ladda Score till Gr3
	ADD #1, Gr3; öka med ett
	ADD #1, Gr3; öka med ett
	STORE $AFD, Gr3; spara tillbaka den inkrementade scoren
	;--fixa nytt äpple
PLACEAPPLELOOP
	RAND Gr12; cell X
	RAND Gr13; cell Y
	;förbered kall till TOGMEM
	LOAD #PLACEAPPLERETURN, Gr14;
	STORE $DB0, Gr0; spara undan Gr0 och Gr1
	STORE $DB1, Gr1; 
	BRA #TOGMEM;
PLACEAPPLERETURN1
	;nu innehåller Gr15 X och Y på GMEM-format
	;förbered kall till GETOBSTACLEBYGMEM
	LOAD #PLACEAPPLERETURN2, Gr14;
	BRA #GETOBSTACLEBYGMEM;
PLACEAPPLERETURN2
	;nu innehåller Gr11 info om kartan på X, Y
	CMP #$FFFF, Gr11; 
	BEQ #PLACEAPPLELOOP; om det är upptaget, fortsätt loopa
	;annars (det var inte ett hinder ivägen), kolla om det är en orm ivägen
	;TODO: FIXA DETTA. orkar inte fixa förän det behövs. Kanske kan skippa
	;nu bara lägger jag ut den utan att ta i akt ormarna
	STORE $CC0, Gr15; Spara (X, Y) som äpplets pos
	LOAD #$4000, Gr8; måla (X, Y) med äppel-tile
	GSTORE Gr8; adressen ligger redan i (X, Y)
	GSTORE Gr8; adressen ligger redan i (X, Y)
	
	
	
	
;-------------KOLLA OM ORM TRÄFFAR KARTA
SNAKECHECKMAP1
	;karta
	;förbered för GETOBSTACLEBYGMEM
	LOAD $D00, Gr15; huvudpos sen tidigare sparad
	LOAD #SNAKEHITRETURN1, Gr14; returnadress
	BRA #GETOBSTACLEBYGMEM; gör kallet
SNAKEHITRETURN1
	;nu ligger det FFFF i Gr11 om det är ett hinder på pos
	CMP #$FFFF, Gr11;
	BEQ #MEUN; om hinder i vägen, gå till menyn
	;annars, testa med andra spelarens huvud
	;förbered GETOBSTACLEBYGMEM igen
	LOAD $D01, Gr14; orm2s huvudpos sen tidigare
	LOAD #SNAKEHITRETURN2, Gr14; returnadress
	BRA #GETOBSTACLEBYGMEM; gör kallet
SNAKEHITRETURN2
	;nu ligger det FFFF i gr11 om det är ett hinder på orm2s huvudpos
	CMP #$FFFF, Gr11;
	BEQ #MENU; om hinder i vägen, har vi förlorat
	;annars, gå vidare

	;orm 1: ----------------------------------------------------------
	
SNAKEMOVETAIL1
	LOAD $AFA, Gr0; ladda in svanspekaren för orm 1
	LOAD $C00, Gr15, Gr0; ladda gamla svanspos tills senare
	ADD #1, Gr0; öka pekaren med ett
	;MOD #64, Gr0; cirkulär array
	AND #$003F, Gr0; MOD
	STORE $AFA, Gr0; lägg tillbaka inkrementerad pekre
	
	;dags att måla tomt där svansen var
	;har redan gamla svansposen i Gr15
	LOAD #$0000, Gr8; sudda, med tile 0000
	GSTORE Gr8; 

SNAKECHECKHITPLAYER1
	LOAD $AFC, Gr0; ladda andra ormens tail-pointer, som loopas över
	LOAD $AF9, Gr2; ladda denna orms huvud-pointer
	LOAD $C00, Gr2, Gr2; ladda denna orms huvudpos
	STORE $D00, Gr2; spara huvudpos på $D00 (var antagligen redan pos på $D00)
SNAKEHITLOOP1
	LOAD $C40, Gr3, Gr0; ladda nuvarande dels pos
	CMP $D00, Gr3; jämför current dels pos med huvudpos
	BNE #SNAKELOOPCONTINUE1; om inte träff
	BRA #MENU; annars har vi förlorat
SNAKELOOPCONTINUE1
	;kan passa på att rita ut ormen när vi ändå  loopar genom den
	LOAD $C40, Gr15, Gr0; spara cur dels pos i Gr15, för att rita ut till GMEM
	LOAD #$3000, Gr8; orm2-tile
	GSTORE Gr8; rita orm2-tile på cur dels pos.
	;sätt fram current-pointern och kolla slut etc
	ADD #1, Gr0;
	;MOD #64, Gr0; cirkulär lista
	AND #$003F, Gr0; MOD
	CMP $AFB, Gr0; Jämför nuvarande dels pointer med headpointer
	BNE #SNAKEHITLOOP1; om inte samma, fortsätt loopa
	;annars (samma, loopat klart), fortsätt programmet
	
	;orm2: ---------------------------------------------------------------------------
	
SNAKEMOVETAIL2
	LOAD $C7F, Gr0; ladda in svanspekaren för orm 1
	LOAD $C40, Gr15, Gr0; ladda gamla svanspos tills senare
	ADD #1, Gr0; öka den med ett
	STORE $C3F, Gr0; lägg tillbaka igen
	
	;dags att måla tomt där svansen var
	;har redan gamla svansposen i Gr15
	GSTORE #$0000; sudda, med tile 0000
	
SNAKECHECKHITPLAYER2
	LOAD $C3E, Gr0; ladda andra ormens head-pointer, som loopas över
	;LOAD $C7F, Gr1; tail-pointer, som skall loopas till
	LOAD $C7E, Gr2; ladda denna orms huvud-pointer
	LOAD $C40, Gr2, Gr2; ladda denna orms huvudpos
	STORE $D00, Gr2; spara huvudpos på $D00
SNAKEHITLOOP2
	LOAD $C00, Gr3, Gr0; ladda nuvarande dels pos
	CMP $D00, Gr3; jämför current dels pos med huvudpos
	BNE #SNAKELOOPCONTINUE2; om inte träff
	BRA #MENU; annars
SNAKELOOPCONTINUE2
	;kan passa på att rita ut ormen när vi ändår loopar genom den
	LOAD $C40, Gr15, Gr0; spara cur pos i Gr15, för att rita ut till GMEM
	GSTORE #$0002; rita orm2-tile på cur pos.
	;sätt fram cur-pointern och kolla slut etc
	ADD #1, Gr0;
	MOD #62, Gr0; cirkulär lista
	CMP $C3F, Gr0; Jämför nuvarande dels pointer med tailpointer
	BNE #SNAKEHITLOOP2; om inte samma, fortsätt loopa
	;annars (samma), fortsätt
	
	;/orm2--------------------------------------------------------------
	
;--------------------------SPELHASTIGHET----------------
; us och ms är egentligen verkligen inte en mikro eller millisekund
; de är mycket större än så

	LOAD #0, Gr0; usec counter
	LOAD #0, Gr1; msec counter
GAMEWAITLOOPU
	ADD #1, Gr0;
	CMP #$FFFF, Gr0;
	BNE #GAMEWAITLOOPU; om vi inte har loopat en ms än
	;annars (har loopat en ms)
	ADD #1, Gr1;
	CMP $CC1, Gr1; se om vi har väntat antal ms som står i spelhastighet
	BNE GAMEWAITLOOPU; om vi inte gjort det, forstätt loopa
	;om vi väntat färdigt, gå till game-loop igen
	BRA #GAMELOOP;
	
	
	
	;Kolla kollision med banan eller äpple CHECK
	;om inte äpple tagen: CHECK
	;	flytta fram tail CHECK
	;	måla tomt där tail va CHECK
	;kolla kollision mellan huvud och spelare CHECK
	;Måla orm på alla ställen mellan head och tail i arraysen CHECK
	
	
INCLUDE util.asm