Ping pong is ready

Author: scopeInfinity

Makefile

@@ -7,8 +7,8 @@ OUTPUT_DIR=output
 all: all_programs_binary all_programs_resolved
 
 clean:
-	rm -r $(BUILD_DIR)
-	rm -r $(OUTPUT_DIR)
+	rm -rf $(BUILD_DIR)
+	rm -rf $(OUTPUT_DIR)
 
 include emulator/Makefile.mk
 
@@ -30,4 +30,4 @@ $(OUTPUT_DIR)/programs/%_resolved.asm: programs/%.asm
 	python3 -m planner asm -r $^ > $@
 
 run_ping_pong:
-	python3 -m planner -v compile_and_execute ping_pong
+	python3 -m planner compile_and_execute ping_pong

README.md

@@ -5,28 +5,18 @@
 
 The eventual goal(?) is to build a general-purpose processor integrated with simple input (e.g. buttons) and output devices (8x8 LED display).
 
-## Verification
+## Sample Programs
 
-### Emulation
-
-```
-# Build ROM[boot]
-$ python3 -rb assembler/assembler.py programs/boot_sequence.asm | tee build/boot_rom.txt.
-
-# Write your program in custom assembly.
-$ cat programs/ping_pong.asm # we can proceeding with this
-
-# Use assembler to translate the instructions into machine code.
-$ mkdir -p build
-$ python3 assembler/assembler.py -r programs/ping_pong.asm | tee build/ping_pong_resolved.txt # optional
-$ python3 assembler/assembler.py -rb programs/ping_pong.asm | tee build/ping_pong_rom.txt
-
-# Use emulater the run the machine code.
-$ python3 emulator/emulate.py build/ping_pong_rom.txt
-```
+* Ping Pong
+  * Source: [ping_pong.asm](programs/ping_pong.asm)
+  * Generate resolved assembly: `python3 -m planner asm -r programs/ping_pong.asm`
+  * Generate binary: `python3 -m planner asm -b programs/ping_pong.asm`
+  * Run on emulator: `python3 -m planner compile_and_execute ping_pong`
 
 ## Design
 
+This section is not up-to date.
+
 ### Specs
 
 * Address Line: 16-bits

planner/asm/line_parser.py

@@ -47,6 +47,9 @@ def parse_line(line: str) -> Tuple[Optional[str], Optional[List[Tuple[unit.Opera
         if op.upper() == memory.TOKEN_ESP:
             optype = address_of(optype)
             op = str(memory.ESP)
+        if op.upper() == memory.TOKEN_ESB:
+            optype = address_of(optype)
+            op = str(memory.ESB)
         elif op in memory.TOKEN_GENERAL_REGISTERS:
             optype = address_of(optype)
             try:

planner/asm/program_parser.py

@@ -157,7 +157,7 @@ def parse_data(self, tokens: List[str]):
             raise ValueError("unsupported data size provided")
 
         # unsigned integer only for now
-        val = int(tokens[2])
+        val = int(tokens[2], 0)
         assert val >= 0 and val < (2**(8*sz))
 
         for _ in range(times):

planner/memory.py

@@ -9,8 +9,10 @@ def get_register_address(index):
 
 # Stack Registers
 TOKEN_ESP = "ESP"
+TOKEN_ESB = "ESB"
 ESP = 0x20
-MSI = 0x24  # multi-step instruction state
+ESB = 0x24
+MSI = 0x28  # multi-step instruction state
 
 # free
 

programs/ping_pong.asm

@@ -33,6 +33,25 @@ OUTPUT_WIDTH equ 6
 OUTPUT_HEGHT equ 7
 INPUT_DEVICE equ 1
 
+BALL_STEP_SIZE equ 2
+GAME_OVER_BLINK_STEP equ 5
+
+BALL_DIR_RIGHT    equ 1
+BALL_DIR_LEFT     equ 2
+# BALL_DIR_RIGHT|BALL_DIR_LEFT
+BALL_DIR_FLIP_HOR equ 3
+# if not up or down, ball goes horizontally
+BALL_DIR_UP       equ 4
+BALL_DIR_DOWN     equ 8
+# BALL_DIR_UP|BALL_DIR_DOWN
+BALL_DIR_FLIP_VER equ 12
+
+BALL_MAXX equ 14
+BALL_MINX equ 1
+BALL_MAXY equ 7
+BALL_MINY equ 0
+
+
 section .text
   main:
     movc ESP, 0xFF
@@ -45,69 +64,110 @@ section .data
     bat2_y    dd 2
     ball_x    dd 7
     ball_y    dd 2
+    mask16f   dd 0xFFFF
+    ball_step_counter dd 0
+    ball_dir  dd 6
+
+    game_over_blink_counter dd 0
+    game_over_blink dd 1
 
 section .text
   game:
     call print
     call read_input_p1_up
-    call sleep
+    call step
     jmp game
 
+  game_over:
+    call game_over_step
+    call print
+    jmp game_over
+
+  game_over_step:
+    cmpc [game_over_blink_counter], 0
+    jnz _game_over_step_end
+    xorc [game_over_blink], 1
+    movc [game_over_blink_counter], GAME_OVER_BLINK_STEP
+  _game_over_step_end:
+    subc [game_over_blink_counter], 1
+    ret
 
-    # call step
-    # jmp step
-    game_after_step:
-    # jmp game
-    # hlt_marker:
-    # jmp hlt_marker
 
   read_input_p1_up:
     IN R0, INPUT_DEVICE
     movc R1, 0x1
     and R1, R0
     jz read_input_p1_down
+    cmpc [bat1_y], 0
+    jz read_input_p1_down
     subc [bat1_y], 1
   read_input_p1_down:
     movc R1, 0x02
     and R1, R0
     jz read_input_p2_up
+    cmpc [bat1_y], BAT_MAXY
+    jz read_input_p2_up
     addc [bat1_y], 1
   read_input_p2_up:
     movc R1, 0x04
     and R1, R0
     jz read_input_p2_down
+    cmpc [bat2_y], 0
+    jz read_input_p2_down
     subc [bat2_y], 1
   read_input_p2_down:
     movc R1, 0x08
     and R1, R0
     jz read_input_end
+    cmpc [bat2_y], BAT_MAXY
+    jz read_input_end
     addc [bat2_y], 1
   read_input_end:
     ret
 
   print:
+    # if game over draw blink bat animation
+    cmpc [game_over_blink], 0
+    jz _draw_ball
+
     ## Player 1
     # anode col
     movc R0, 0x7F
     shlc R0, 8
     xorc R0, 0xFF
     # cathode row
-    movc R1, 0x3
+    movc R1, 0x7
     shl R1, [bat1_y]
     OUT OUTPUT_WIDTH, R0
     OUT OUTPUT_HEGHT, R1
-
     call sleep
+
     ## Player 2
     # anode col
     movc R0, 0xFF
     shlc R0, 8
     xorc R0, 0xFE
     # cathode row
-    movc R1, 0x3
+    movc R1, 0x7
     shl R1, [bat2_y]
     OUT OUTPUT_WIDTH, R0
     OUT OUTPUT_HEGHT, R1
+    call sleep
+
+  _draw_ball:
+    ## Ball
+    mov R0, [ball_x]
+    movc R1, 0x80
+    shlc R1, 8
+    shr R1, R0
+    xor R1, [mask16f]
+    mov R0, [ball_y]
+    movc R2, 1
+    shl R2, R0
+    OUT OUTPUT_WIDTH, R1
+    OUT OUTPUT_HEGHT, R2
+    call sleep
+
     ret
 
   sleep:
@@ -118,9 +178,95 @@ section .text
     jnz _sleep
     ret
 
-  #step:
-  #  addc [ball_x], 1
-  #  andc [ball_x], 0x07
-  #  jmp game_after_step
+  step:
+    cmpc [ball_step_counter], 0
+    jnz step_over
+    movc [ball_step_counter], BALL_STEP_SIZE
+    call step_ball_move
+  step_over:
+    subc [ball_step_counter], 1
+    ret
+
+  step_ball_move:
+    cmpc [ball_x], BALL_MAXX
+    jz _step_ball_collision_hor_right
+    cmpc [ball_x], BALL_MINX
+    jz _step_ball_collision_hor_left
+  _step_ball_collision_hor_over:
+    cmpc [ball_y], BALL_MAXY
+    jz _step_ball_collision_ver
+    cmpc [ball_y], BALL_MINY
+    jz _step_ball_collision_ver
+  _step_ball_collision_ver_over:
+
+    mov R0, [ball_dir]
+    andc R0, BALL_DIR_RIGHT
+    jz _step_ball_left
+    # move_right
+    addc [ball_x], 1
+    jmp _step_ball_up
+  _step_ball_left:
+    # move left
+    subc [ball_x], 1
+  _step_ball_up:
+    mov R0, [ball_dir]
+    andc R0, BALL_DIR_UP
+    jz _step_ball_down
+    # move up
+    subc [ball_y], 1
+  _step_ball_down:
+    mov R0, [ball_dir]
+    andc R0, BALL_DIR_DOWN
+    jz _step_ball_move_over
+    # move down
+    addc [ball_y], 1
+  _step_ball_move_over:
+    ret
 
+  _step_ball_collision_hor_right:
+    push [bat2_y]
+    call _step_ball_collision_hor
+    pop R7
+    jmp _step_ball_collision_hor_over
+
+  _step_ball_collision_hor_left:
+    push [bat1_y]
+    call _step_ball_collision_hor
+    pop R7
+    jmp _step_ball_collision_hor_over
+
+  _step_ball_collision_hor:
+    # Argument
+    # bat_y
+    mov esb, esp
+    addc esb, 4
+    load R1, [esb] # bat_y
+
+    xorc [ball_dir], BALL_DIR_FLIP_HOR
+    movc R0, BALL_DIR_FLIP_VER
+    xorc R0, 0xFF
+    and [ball_dir], R0
+    cmp [ball_y], R1
+    jz _step_ball_collision_hor_right_go_up
+    addc R1, 1
+    cmp [ball_y], R1
+    jz _step_ball_collision_hor_right_go_hor
+    addc R1, 1
+    cmp [ball_y], R1
+    jz _step_ball_collision_hor_right_go_down
+    jmp game_over
+  _step_ball_collision_hor_right_go_up:
+    orc [ball_dir], BALL_DIR_UP
+    ret
+  _step_ball_collision_hor_right_go_down:
+    orc [ball_dir], BALL_DIR_DOWN
+    ret
+  _step_ball_collision_hor_right_go_hor:
+    ret
 
+  _step_ball_collision_ver:
+    mov R0, [ball_dir]
+    andc R0, BALL_DIR_FLIP_VER
+    jz _step_ball_collision_ver_over
+    xorc [ball_dir], BALL_DIR_FLIP_VER
+    jmp _step_ball_collision_ver_over