changed screen size

ass1/bonus-snake.asm

@@ -1,102 +1,150 @@
+. graphical screen settings:
+. Address: 0x00A000
+. Columns: 16
+. Rows: 16
+. Pixel size: 24
+.
+. keyboard settings: 
+. Address: 0x00C000
+
 SNAKE   START   0
 
-FIRST   LDS     #255
+FIRST   JSUB    RENDER
-        LDA     G_SCRN
+
-        STA     @CURSCR
+        .if (food was eaten) temp = snake[LEN - 1], generate new food:
-        STA     @SVEC
+
-LOOP    JSUB    DRAW
+        .propagate position through the snake
-        ADD     #4
+        .for (i = LEN - 2, i >= 0 ) snakex/y[i + 1] = snakex/y[i] 
-        STA     @SVEC
+
-        J       LOOP
+        .if (eaten) LEN++, snake[LEN - 1] = temp    
+
+        LDA     @KEY_IN
+        COMP    #0x41           .A
+        JEQ     LEFT
+        COMP    #0x57           .W
+        JEQ     UP
+        COMP    #0x44           .D
+        JEQ     RIGHT
+        COMP    #0x53           .S
+        JEQ     DOWN
+
+L3      RMO     A, X            .make horizontal move
+        LDA     @SNAKEX
+        ADDR    X, A
+        STA     @SNAKEX
+        J       L5
+
+L4      RMO     A, X            .make vertical move
+        LDA     @SNAKEY
+        ADDR    X, A
+        STA     @SNAKEY
+
+L5      .check bounds
+        .for (pos : snakex/y) assert x/y >= 0 && x/y <= 15
+
+        J       FIRST
 
 HALT    J       HALT  
 
-DRAW    JSUB    PUSH
+.store direction
+LEFT    LDA     #-1
+        STA     DIREC
+        J       L3
+UP      LDA     #-0x10
+        STA     DIREC
+        J       L4
+RIGHT   LDA     #1
+        STA     DIREC
+        J       L3
+DOWN    LDA     #0x10
+        STA     DIREC
+        J       L4
+
+.draws the snake
+.no arguements, no return
+.changes A
+RENDER  RMO     L, A
+        JSUB    PUSH            .prolouge
+        RMO     X, A
+        JSUB    PUSH
         RMO     T, A
         JSUB    PUSH
-        RMO     S, A
-        JSUB    PUSH   
 
-        LDA     #0      .COUNTER      
+        CLEAR   X               .draw head
-        LDT     @OFFSET
+        JSUB    OFFSET
-STRT   COMP    @LEN
+        ADD     SCREEN
-        JEQ     END
+        STA     ADR
-
-        JSUB    PUSH
-        LDA     SVEC
-        ADD     @OFFSET
-        STA     ADDR
-        LDA     @ADDR
-        STA     @BASEY
-
-        CLEAR A
-        
-LOOP1   COMP    FOUR
-        JEQ     LEND
-        LDS     @BASE
-        MUL     #64
-        ADDR    A, S
-        DIV     #64
-        STS     @BASEY
-        JSUB    PUSH
         CLEAR   A
+        LDCH    #240
+        STCH    @ADR           
 
-LOOP2   COMP    FOUR
+L1      RMO     X, A            .draw others
-        JEQ     LEND2
-        LDS     @BASEY
-        ADDR    A, S
-        STS     @CUR
-
-        LDS     #255
-        STS     @CUR
-
         ADD     #1
-        J       LOOP2 
+        RMO     A, X
-
-LEND2     JSUB    POP
-        ADD     #1
-        J       LOOP1      
-
-LEND    JSUB    POP
-        ADD     #1
-        JSUB    PUSH
-        LDA     #3
-        ADDR    A, T
-        JSUB    POP
-        J       STRT
-
-END     JSUB    POP
-        RMO     A, T
-        JSUB    POP
-        RMO     A, S
-        JSUB    POP
-        RSUB
         
+        COMP    LEN
+        JEQ     L2
 
-PUSH    STA     @S_PTR
+        JSUB    OFFSET          
-        LDA     S_PTR
+        ADD     SCREEN
+        STA     ADR
+        CLEAR   A
+        LDCH    #255
+        STA     @ADR
+
+        J       L1
+
+L2      JSUB    POP             .epilouge
+        RMO     A, T
+        JSUB    POP             
+        RMO     A, X
+        JSUB    POP
+        RMO     A, L
+        RSUB
+
+.calculates the offset of the snake cell at index X for rendering
+.offset = 16 * snakey[index] + snakex[index]
+.arguements: X - index
+.return: A - offset
+.changes A, T  
+OFFSET  RMO     X, A
+        MUL     #3          
+        ADD     SNAKEY
+        STA     ADR
+        LDA     @ADR
+        MUL     #16             
+        RMO     A, T
+
+        RMO     X, A
+        MUL     #3          
+        ADD     SNAKEX
+        STA     ADR
+        LDA     @ADR
+        ADDR    T, A
+        RSUB
+
+.pushes A to stack
+.changes A 
+PUSH    STA     @ST_PTR         
+        LDA     ST_PTR
         ADD     #3
-        STA     S_PTR
+        STA     ST_PTR
         RSUB
 
-POP     LDA     S_PTR
+.pops top of stack into A
+POP     LDA     ST_PTR         
         SUB     #3
-        STA     S_PTR
+        STA     ST_PTR
-        LDA     @S_PTR
+        LDA     @ST_PTR
         RSUB
 
-FOUR    WORD    X'000004'
+LEN     WORD    0               .snake length
-ADDR    WORD    X'000000'
+SCREEN  WORD    X'00A000'       .screen pointer
-CUR     WORD    X'000000'
+KEY_IN  WORD    X'00C000'       .input pointer
-BASE    WORD    X'000000'
+ST_PTR  WORD    X'000200'       .stack pointer, 2kB of space
-BASEY   WORD    X'000000'
+SNAKEX  WORD    X'000A00'       .pointer to an array of snake x coords, first input is head, SNAKEX + LEN is tail, 3 byte elements, upper left corner is 0, 0
-LEN     WORD    X'000000'
+SNAKEY  WORD    X'000C00'       .pointer to an array of snake y coords, offset 0x200 from SNAKEX
-G_SCRN  WORD    X'00A000'
+ADR     WORD    0               .actual address of the x / y coord since sic/xe doesnt support indirect and indexed addressing
-CURSCR  WORD    X'000000'
+DIREC   WORD    0               .movement direction, gets added to snake's head 
-KEY_IN  WORD    X'00C000'
-S_PTR   WORD    X'000100'
-SVEC    WORD    X'001000'
-SVECMV  WORD    X'003000'
-OFFSET  WORD    X'000000'
 
-        END FIRST
+        END     FIRST