(ns com.aurellem.gb.dylan-assembly

   "A much more compact version of write-memory-assembly"

   {:author "Dylan Holmes"}

   (:use (com.aurellem.gb gb-driver assembly util vbm))

   (:import [com.aurellem.gb.gb_driver SaveState]))

 

 ;; Specs for main bootstrap program

 

 ;; Number-Input

 ;; Number input works using all eight buttons to

 ;;   spell out an 8 bit number.  The order of buttons is

 ;;   [:d :u :l :r :start :select :b :a]  -->  11111111

 ;;   [      :l    :start            :a]  -->  00101001

 

 ;;; MODE-SELECT

 ;;   The bootstrap program starts in MODE-SELECT mode.

 ;;   MODE-SELECT transitions to one of three modes depending

 ;;   on which buttons are pressed:

 ;;       0   (no-buttons)  :  MODE-SELECT

 ;;       8   [:start]      :  WRITE-BYTES

 ;;    0xFF   (all-buttons) :  JUMP

 

 

 ;;; WRITE-BYTES

 

 ;;   WRITE-BYTES mode writes sequences of arbitray values to

 ;;   arbitray memory locations. It expects you to enter a

 ;;   header of three bytes describing what to write:

 

 ;;    Byte 0  : Number of Bytes to Write

 ;;    Byte 1  : Start Address High Byte

 ;;    Byte 1  : Start Address Low  Byte

 

 ;;   Then, you enter the number of bytes specified in Byte 0

 ;;   they are written to the start address in

 ;;   sequence. After the last byte is written control

 ;;   returns to MODE-SELECT mode.

 

 ;;   Example: to write the sequence [1 2 3 4] starting at

 ;;   address 0xC01F enter

 ;;    Byte 0  : 4 (will write four bytes)

 ;;    Byte 1  : 0xC0  (high byte of 0xC01F)

 ;;    Byte 2  : 0x1F  (low  byte of 0xC01F)

 ;;    Byte 3  : 1 (write 1 to 0xC01F)

 ;;    Byte 4  : 2 (write 2 to 0xC020)

 ;;    Byte 5  : 3 (write 3 to 0xC021)

 ;;    Byte 6  : 4 (write 4 to 0xC022)

 

 ;;; JUMP 

 ;;   JUMP mode jumps program control to any arbitray

 ;;   location. It expects you to enter two bytes which

 ;;   correspond to the high and low bytes of the memory

 ;;   address to which you want to jump.

 ;;    Byte 0  : Jump Address High Byte

 ;;    Byte 1  : Jump Address Low  Byte

 

 ;;   Example: to jump to address 0x1234 enter

 ;;    Byte 0  : 0x12 (high byte of 0x1234)

 ;;    Byte 1  : 0x34 (low  byte of 0x1234)

 

 

 (defn write-memory-assembly-compact

   "Currently, grabs input from the user each frame."

   []

   [

    ;; --------- FRAME METRONOME

    0x18 ;; jump ahead to cleanup. first time only.

    0x40 ;; v-blank-prev [D31E]

 

    0xFA ;; load modes into A [D31F]

    0x41

    0xFF

 

    0x47 ;; A -> B

    0xCB ;; rotate A

    0x2F

    0x2F ;; invert A

 

    0xA0

    0x47 ;; now B_0 contains (VB==1)

 

    0xFA ;; load v-blank-prev

    0x1E

    0xD3

 

    0x2F ;; complement v-blank-prev

    

    0xA0 ;; A & B --> A

    0x4F ;; now C_0 contains increment?

 

 

    0x78 ;; B->A

    0xEA ;; spit A --> vbprev

    0x1E

    0xD3

 

    0xCB   ;test C_0

    0x41

    0x20   ; JUMP ahead to button input if nonzero

    0x02

    0x18   ; JUMP  back to frame metronome (D31F)

    0xE7

    

    ;; -------- GET BUTTON INPUT

 

         ;; btw, C_0 is now 1

         ;; prepare to select bits

 

    0x06 ;; load 0x00 into B

    0x00 ;; to initialize for "OR" loop

  

    0x3E ;; load 0x20 into A, to measure dpad

    0x20

 

    

    0xE0 ;; load A into [FF00] ;; start of OR loop [D33C]

    0x00

    

    0xF0 ;; load A from [FF00]

    0x00

 

    0xE6 ;; bitmask 00001111

    0x0F

    

    0xB0 ;; A or B --> A

    0xCB

    0x41 ;; test bit 0 of C

    0x28 ;; JUMP forward if 0

    0x08

 

    0x47 ;; A -> B

    0xCB ;; swap B nybbles

    0x30 

    0x0C ;; increment C

    0x3E ;; load 0x10 into A, to measure btns

    0x10

    0x18 ;; JUMP back to "load A into [FF00]" [20 steps?]

    0xED

 

 

    ;; ------ TAKE ACTION BASED ON USER INPUT

 

    ;; "input mode"

    ;; mode 0x00 : select mode

    ;; mode 0x08 : select bytes-to-write

    ;; mode 0x10 : select hi-bit

    ;; mode 0x18 : select lo-bit

 

    ;; "output mode"

    ;; mode 0x20 : write bytes

    ;; mode 0xFF : jump PC

 

 

    ;; registers

    ;; D : mode select

    ;; E : count of bytes to write

    ;; H : address-high

    ;; L : address-low

    

    ;; now A contains the pressed keys

    0x2F ; complement A, by request. [D34F]

    

    0x47 ; A->B ;; now B contains the pressed keys

    0x7B ; E->A ;; now A contains the count.

 

    0xCB ; test bit 5 of D (are we in o/p mode?)

    0x6A

    0x28 ; if test == 0, skip this o/p section

    0x13 ; JUMP

    

    0xCB ; else, test bit 0 of D (fragile; are we in pc mode?)

    0x42

    0x28 ; if test == 0, skip the following command

    0x01

 

    ;; output mode I: moving the program counter

    0xE9 ; ** move PC to (HL)

 

    ;; output mode II: writing bytes

    0xFE ; A compare 0. finished writing?

    0x00

    0x20 ; if we are not finished, skip cleanup

    0x04 ; JUMP

 

    ;; CLEANUP

    ;; btw, A is already zero.

    0xAF ; zero A  [D35F]

    0x57 ; A->D; makes D=0.

    0x18 ; end of frame

    0xBC

    

    ;; ---- end of cleanup

 

    

    ;; continue writing bytes

    0x1D ;; decrement E, the number of bytes to write [D363]

    0x78 ;; B->A; now A contains the pressed keys

    0x77 ;; copy A to (HL)

    0x23 ;; increment HL

    0x18 ;; end frame. [goto D31F]

    0xB6 ;; TODO: set skip length backwards

 

 

    ;; ---- end of o/p section

    

    ;; i/p mode

    ;; adhere to the mode discipline:

    ;; D must be one of 0x00 0x08 0x10 0x18.

 

    0x3E ;; load the constant 57 into A. [D369]

    0x57

    0x82 ;; add the mode to A

    0xEA ;; store A into "thing to execute"

    0x74

    0xD3

 

    0x3E ;; load the constant 8 into A

    0x08

    0x82 ;; add the mode to A

    

    0x57 ;; store the incremented mode into D

    0x78 ;; B->A; now A contains the pressed keys

    

    0x00 ;; var: thing to execute [D374]

 

    0x18 ;; end frame

    0xA8])

 

 (defn write-mem-compact []

   (-> (tick (mid-game))

       (IE! 0)

       (inject-item-assembly (write-memory-assembly-compact))))

 

 (defn test-write-bytes-mode []

   (let [target-address 0xD135

         [target-high target-low] (disect-bytes-2 target-address)

         assembly [0xF3 0x18 0xFE 0x12]

         get-mem-region  #(subvec (vec (memory %))

                                  target-address (+ target-address 20))

         before (write-mem-compact)

         after

         (-> before

             (step [])                       ; make sure it can handle blanks

             (step [])                       ; at the beginning.

             (step [])                      

             (step [:start])                 ; select WRITE-BYTES mode

             (step (buttons 4))              ; write 4 bytes

             (step (buttons target-high))

             (step (buttons target-low))

             (step (buttons (nth assembly 0)))

             (step (buttons (nth assembly 1)))

             (step (buttons (nth assembly 2)))

             (step (buttons (nth assembly 3)))

             (step [])

             (step [])

             (step []))]

             (println "before :" (get-mem-region before))

             (println "after  :" (get-mem-region after))

             (assert (= assembly (take 4 (get-mem-region after))))

     after))

 

 (defn test-jump-mode []

   (let [target-address 0xC01F

         [target-high target-low] (disect-bytes-2 target-address)

         post-jump

         (-> (test-write-bytes-mode)

             (step [])

             (step [])

             (step [])

             (step (buttons 0xFF))           ; Select JUMP mode.

             (step (buttons target-high))

             (step (buttons target-low)))

         program-counters

         (capture-program-counter 

          post-jump

          10000)]

     (println program-counters)

     (assert (contains? (set program-counters) target-address))

     post-jump))

 

 

 (defn test-loop []

   (contains?

    (set

     (capture-program-counter

      (-> (mid-game)

          ;;      (IE! 0)

          (set-memory-range 0xD135 [0xF3 0x18 0xFE])

          (PC! 0xD135)) 10000))

     0xD136))