Add emulator graphic mode, add test snake game. Commit from aitplane

drunkbatya · drunkbatya · commit a647c7c7b94a · 2025-09-08T08:14:18.000+03:00
diff --git a/emulator/js/DrunkPC.js b/emulator/js/DrunkPC.js
@@ -18,7 +18,7 @@ const IO_KBD_ADDR = 0b00100000 // A5 = 1 - device 1
 const COMPACT_FLASH_BASE = 0b01000000  // A6 = 1 - device 2
 
 let ram = new Uint8Array(0xFFFF + 1);
-let romLocked = false;
+let romLocked = true;
 let video = new RA6963();
 let keyboard = new Keyboard();
 let cf = new CompactFlash();
diff --git a/emulator/js/RA6963.js b/emulator/js/RA6963.js
@@ -244,13 +244,12 @@ function RA6963() {
         }
         if (graphicMode) {
             for (let canvasY = 0; canvasY < canvas.height; canvasY++) {
-                for (let canvasX = 0; canvasX < (canvas.width / 8); canvasX++) {
-                    const dataByte = vram[graphicHomeAddressPtr + (canvasY * DISPLAY_WIDTH / 8) + canvasX];
-                    for(let bit = 7; bit >= 0; bit--) {
+                for (let canvasX = 0; canvasX < (canvas.width / 6); canvasX++) {
+                    const dataByte = vram[graphicHomeAddressPtr + (canvasY * DISPLAY_WIDTH / 6) + canvasX];
+                    for(let bit = 5; bit >= 0; bit--) {
                         if ((dataByte >> bit) & 0x01) {
-                            canvasSetPixelState((canvasX * 8) + (8 - bit), canvasY);
+                            canvasSetPixelState((canvasX * 6) + (6 - bit), canvasY);
                         } else {
-                            canvasSetPixelState(canvasX + (8 - bit), canvasY, false);
                         }
 
                     }
diff --git a/software/applications/snake/snake.s b/software/applications/snake/snake.s
@@ -6,14 +6,15 @@
 
 .include "drivers/ra6963/ra6963.inc"
 .include "hardware/io.inc"
+.include "keyboard/keyboard_codes.inc"
 
 .section .text
 
 ; snake direction
 DIRECTION_UP = 0
-DIRECTION_DOWN = 1
-DIRECTION_LEFT = 2
-DIRECTION_RIGHT = 3
+DIRECTION_RIGHT = 1
+DIRECTION_DOWN = 2
+DIRECTION_LEFT = 3
 
 ; constants
 MAX_SNAKE_LEN = 253
@@ -26,21 +27,120 @@ snake_await_tick_process_keyboard:
     pop hl  ; return char code
     ld a, l  ; loading byte
     or a  ; if it zero?
-    jr z, snake_await_tick_process_keyboard_await_keyboard
+    jr z, timer_move_snake
     ; check 'q'
     cp 'q'  ; if q pressed
     jr z, snake_await_tick_process_keyboard_end
     cp 'Q'  ; if Q pressed
     jr z, snake_await_tick_process_keyboard_end
-    ;cp KBD_UP  ; if up pressed
-    ;jr z, less_process_file_keyboard_up
-    ;cp KBD_DOWN  ; if down pressed
-    ;jr z, less_process_file_keyboard_down
+    cp KBD_UP  ; if up pressed
+    jr z, snake_up
+    cp KBD_DOWN  ; if down pressed
+    jr z, snake_down
+    cp KBD_LEFT  ; if left pressed
+    jr z, snake_left
+    cp KBD_RIGHT  ; if right pressed
+    jr z, snake_right
+    jr timer_move_snake
+
+    snake_up:
+    ld a, DIRECTION_UP
+    ld (snake_direction), a
+    jr no_key
+    snake_down:
+    ld a, DIRECTION_DOWN
+    ld (snake_direction), a
+    jr no_key
+    snake_left:
+    ld a, DIRECTION_LEFT
+    ld (snake_direction), a
+    jr no_key
+    snake_right:
+    ld a, DIRECTION_RIGHT
+    ld (snake_direction), a
+    jr no_key
+
+    timer_move_snake:
+    call clear_display
+    call move_snake
+    call draw_snake
+
+    no_key:
     jr snake_await_tick_process_keyboard_await_keyboard  ; keyboard loop
     snake_await_tick_process_keyboard_end:
     ret
 
+move_snake:
+    call snake_set_next_step
+    call snake_step
+    ret
+
+snake_step:
+    push hl  ; storing hl
+    push de  ; storing de
+
+    ld hl, (snake_len)  ; loading snake len
+    add hl, hl  ; sizeof(snakePoint) = x and y = snake_len * 2
+    push hl  ; arg3 of memmove - size
+    ld hl, snake_dots
+    push hl  ; arg2 of memmove - src arr
+    ld hl, snake_dots + 2
+    push hl  ; arg1 of memmove - dst arr
+    call memmove
+
+    ld hl, snake_next_step  ; snake_next_step need to be set by snake_set_next_step function
+    ld e, (hl)  ; dereferencing next step
+    inc hl
+    ld d, (hl)  ; dereferencing next step
+    ld (snake_dots), de  ; setting moved snake_dots head with the new dot
+
+    pop de  ; restoring de
+    pop hl  ; restoring hl
+    ret
+
+snake_set_next_step:
+    push af  ; storing af
+    push hl  ; storing hl
+
+    ld hl, (snake_dots)  ; loading current last point, h - y, l - x
+
+    ld a, (snake_direction)  ; loading snake direction
+    cp DIRECTION_UP
+    jr z, snake_set_next_step_direction_up
+    cp DIRECTION_RIGHT
+    jr z, snake_set_next_step_direction_right
+    cp DIRECTION_DOWN
+    jr z, snake_set_next_step_direction_down
+    cp DIRECTION_LEFT
+    jr z, snake_set_next_step_direction_left
+    jr snake_set_next_step_end_do_nothing  ; if not any match
+
+    snake_set_next_step_direction_up:
+    dec h  ; y--
+    jr snake_set_next_step_end
+
+    snake_set_next_step_direction_down:
+    inc h  ; y++
+    jr snake_set_next_step_end
+
+    snake_set_next_step_direction_right:
+    inc l  ; x++
+    jr snake_set_next_step_end
+
+    snake_set_next_step_direction_left:
+    dec l  ; x--
+    jr snake_set_next_step_end
+
+    snake_set_next_step_end:
+    ld (snake_next_step), hl  ; storing next step
+    snake_set_next_step_end_do_nothing:
+
+    pop hl  ; restoring hl
+    pop af  ; restoring af
+    ret
+
 draw_snake:
+    push af
     push hl
     push de
     push bc
@@ -49,43 +149,69 @@ draw_snake:
     ld b, a
     ld hl, snake_dots
     draw_snake_loop:
+        ld de, 0x0404   ; arg2 of ra6963_draw_box - size_x, size_y
+        push de
+
         ld e, (hl)  ; x
         inc hl  ; going yo y
         ld d, (hl)  ; y
+
+        ; multiplying x by 4(snake size)
+        push bc  ; storing bc
+        ld b, 3  ; snake size
+        ld a, e  ; loading x
+        draw_snake_loop_multiply_by_4_loop_x:
+            add a, e
+            djnz draw_snake_loop_multiply_by_4_loop_x
+        ld e, a  ; multiplyed value
+
+        ; multiplying y by 4(snake size)
+        ld b, 3  ; snake size
+        ld a, d  ; loading y
+        draw_snake_loop_multiply_by_4_loop_y:
+            add a, d
+            djnz draw_snake_loop_multiply_by_4_loop_y
+        ld d, a  ; multiplyed value
+        pop bc  ; restoring bc
+
         push de  ; arg1 of ra6963_set_pixel
-        call ra6963_set_pixel
+
+        call ra6963_draw_box
+
         inc hl  ; next snake point
         djnz draw_snake_loop
     draw_snake_loop_end:
     pop bc
     pop de
     pop hl
+    pop af
     ret
 
 clear_display:
     push hl  ; storing hl
     ld hl, 0  ; arg3 for ra6963_memset - value
     push hl
-    ld hl, 1920  ; arg2 for ra6963_memset - size
+    ld hl, 2560  ; arg2 for ra6963_memset - size (240/6 * 64)
     push hl
     ld hl, 0  ; arg1 for ra6963_memset - address
     push hl
     call ra6963_memset
     pop hl  ; restoring hl
+    ret
 
 init_snake:
-    push hl
-    push de
-    push bc
+    push hl  ; storing hl
+    push de  ; storing de
+    push bc  ; storing bc
 
-    ld de, snake_dots
-    ld hl, snake_dots_init
-    ld bc, INITIAL_SNAKE_LEN * 2
+    ld de, snake_dots  ; dst arr
+    ld hl, snake_dots_init  ; src arr
+    ld bc, INITIAL_SNAKE_LEN * 2  ; arr size
     ldir  ; repeats 'ld (de), (hl)' then increments de, hl, and decrements bc until bc=0
 
-    pop bc
-    pop de
-    pop hl
+    pop bc  ; restoring bc
+    pop de  ; restoring de
+    pop hl  ; restoring hl
     ret
 
 write_byte:
@@ -100,34 +226,7 @@ snake_main:
     call ra6963_graphic_on
     call clear_display
 
-    ld hl, 0x0000
-    push hl
-    call ra6963_set_address_pointer
-
-    ld a, 0x3F
-    call write_byte
-    ld a, 0
-    call write_byte
-    ld a, 0xF0
-    call write_byte
-    ld a, 0x0F
-    call write_byte
-
-    ;ld hl, 0x00EF
-    ;push hl
-    ;call ra6963_set_pixel
-
-    ;ld hl, 0x3FEF
-    ;push hl
-    ;call ra6963_set_pixel
-
-    ;ld hl, 0x3F00
-    ;push hl
-    ;call ra6963_set_pixel
-
-    ;call init_snake
-
-    ;call draw_snake
+    call init_snake
 
     call snake_await_tick_process_keyboard
 
@@ -138,6 +237,9 @@ snake_main:
 snake_dots:
     .skip (2 * MAX_SNAKE_LEN)
 
+snake_next_step:
+    .skip 2
+
 .section .data
 snake_direction:
     .byte DIRECTION_RIGHT
@@ -158,4 +260,3 @@ snake_dots_init:
     .byte 3, 6
     .byte 2, 6
 
-
diff --git a/software/lib/stdlib/string/memmove.s b/software/lib/stdlib/string/memmove.s
@@ -0,0 +1,62 @@
+.include "string/string.inc"
+
+.section .text
+
+; About:
+;   The memmove() function copies byte array arr1 to byte array arr2.
+;   Both arrays are assumed to be n bytes long.
+; Args:
+;   uint8_t* arr1 - first array ptr
+;   uint8_t* arr2 - second array ptr
+;   uint16_t size - arrays size
+; Return:
+;   uint8_t res - 0 if both arrays are equal
+; C Prototype:
+;   uint8_t memmove(uint8_t* arr1, uint8_t* arr2, uint16_t size);
+memmove:
+    push af  ; storing af
+    push ix  ; storing ix
+    push hl  ; storing hl
+    push de  ; storing de
+    push bc  ; storing bc
+
+    ld ix, 12  ; there is no way to set load sp value to ix, skipping pushed 5 reg pairs and the return address
+    add ix, sp  ; loading sp value to ix
+
+    ld l, (ix + 2)  ; arr2 ptr low byte
+    ld h, (ix + 3)  ; arr3 ptr high byte
+    ld c, (ix + 4)  ; arrs size low byte
+    ld b, (ix + 5)  ; arrs size high byte
+    ld de, memmove_buffer
+
+    ldir  ; repeats 'ld (de), (hl)' then increments de, hl, and decrements bc until bc=0
+
+    ld e, (ix + 0)  ; arr1 ptr low byte
+    ld d, (ix + 1)  ; arr1 ptr high byte
+    ld c, (ix + 4)  ; arrs size low byte
+    ld b, (ix + 5)  ; arrs size high byte
+    ld hl, memmove_buffer
+
+    ldir  ; repeats 'ld (de), (hl)' then increments de, hl, and decrements bc until bc=0
+
+    pop bc  ; restoring bc
+    pop de  ; restoring de
+    pop hl  ; restoring hl
+    pop ix  ; restoring ix
+    pop af  ; restoring af
+
+    exx  ; exchanging register pairs with their shadow
+    pop hl  ; return address
+    pop bc  ; removing arg1
+    pop bc  ; removing arg2
+    pop bc  ; removing arg3
+    push hl  ; return address
+    exx  ; restoring registers
+
+    ret
+
+
+.section .bss
+; temp workaround before malloc function will exists..
+memmove_buffer:
+    .skip 256
diff --git a/software/lib/stdlib/string/string.inc b/software/lib/stdlib/string/string.inc
@@ -12,5 +12,6 @@
 .global memrchr
 .global memswap
 .global memcmp
+.global memmove
 
 ; vim: set ft=asm:
diff --git a/software/system/drivers/ra6963/ra6963.inc b/software/system/drivers/ra6963/ra6963.inc
@@ -76,6 +76,7 @@ RA6963_OFFSET_REGISTER_VALUE = RA6963_CUSTOM_FONT_START_ADDR / 2048
 .global ra6963_custom_font_init
 .global ra6963_memcpy
 .global ra6963_text_mode_cursor_off
+.global ra6963_draw_box
 .global ra6963_text_mode_cursor_on
 
 .global ra6963_graphic_on
diff --git a/software/system/drivers/ra6963/ra6963_graphic.s b/software/system/drivers/ra6963/ra6963_graphic.s
diff --git a/software/system/drivers/ra6963/ra6963_init.s b/software/system/drivers/ra6963/ra6963_init.s
diff --git a/software/system/drivers/ra6963/ra6963_set_pixel.s b/software/system/drivers/ra6963/ra6963_set_pixel.s

Original file line number	Diff line number	Diff line change
`@@ -244,13 +244,12 @@ function RA6963() {`
`244`	`244`	`}`
`245`	`245`	`if (graphicMode) {`
`246`	`246`	`for (let canvasY = 0; canvasY < canvas.height; canvasY++) {`
`247`		`- for (let canvasX = 0; canvasX < (canvas.width / 8); canvasX++) {`
`248`		`- const dataByte = vram[graphicHomeAddressPtr + (canvasY * DISPLAY_WIDTH / 8) + canvasX];`
`249`		`- for(let bit = 7; bit >= 0; bit--) {`
	`247`	`+ for (let canvasX = 0; canvasX < (canvas.width / 6); canvasX++) {`
	`248`	`+ const dataByte = vram[graphicHomeAddressPtr + (canvasY * DISPLAY_WIDTH / 6) + canvasX];`
	`249`	`+ for(let bit = 5; bit >= 0; bit--) {`
`250`	`250`	`if ((dataByte >> bit) & 0x01) {`
`251`		`- canvasSetPixelState((canvasX * 8) + (8 - bit), canvasY);`
	`251`	`+ canvasSetPixelState((canvasX * 6) + (6 - bit), canvasY);`
`252`	`252`	`} else {`
`253`		`- canvasSetPixelState(canvasX + (8 - bit), canvasY, false);`
`254`	`253`	`}`
`255`	`254`
`256`	`255`	`}`