Mercurial > vba-clojure

     1 (ns com.aurellem.gb.dylan-assembly

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

     3   {:author "Dylan Holmes"}

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

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

     6 

     7 ;; Specs for main bootstrap program

     8 

     9 ;; Number-Input

    10 ;; Number input works using all eight buttons to

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

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

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

    14 

    15 ;;; MODE-SELECT

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

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

    18 ;;   on which buttons are pressed:

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

    20 ;;       8   [:start]      :  WRITE-BYTES

    21 ;;    0xFF   (all-buttons) :  JUMP

    22 

    23 

    24 ;;; WRITE-BYTES

    25 

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

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

    28 ;;   header of three bytes describing what to write:

    29 

    30 ;;    Byte 0  : Number of Bytes to Write

    31 ;;    Byte 1  : Start Address High Byte

    32 ;;    Byte 1  : Start Address Low  Byte

    33 

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

    35 ;;   they are written to the start address in

    36 ;;   sequence. After the last byte is written control

    37 ;;   returns to MODE-SELECT mode.

    38 

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

    40 ;;   address 0xC01F enter

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

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

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

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

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

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

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

    48 

    49 ;;; JUMP 

    50 ;;   JUMP mode jumps program control to any arbitray

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

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

    53 ;;   address to which you want to jump.

    54 ;;    Byte 0  : Jump Address High Byte

    55 ;;    Byte 1  : Jump Address Low  Byte

    56 

    57 ;;   Example: to jump to address 0x1234 enter

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

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

    60 

    61 

    62 (defn write-memory-assembly-compact

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

    64   []

    65   [

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

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

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

    69 

    70    0xFA ;; load modes into A [D31F]

    71    0x41

    72    0xFF

    73 

    74    0x47 ;; A -> B

    75    0xCB ;; rotate A

    76    0x2F

    77    0x2F ;; invert A

    78 

    79    0xA0

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

    81 

    82    0xFA ;; load v-blank-prev

    83    0x1E

    84    0xD3

    85 

    86    0x2F ;; complement v-blank-prev

    87    

    88    0xA0 ;; A & B --> A

    89    0x4F ;; now C_0 contains increment?

    90 

    91 

    92    0x78 ;; B->A

    93    0xEA ;; spit A --> vbprev

    94    0x1E

    95    0xD3

    96 

    97    0xCB   ;test C_0

    98    0x41

    99    0x20   ; JUMP ahead to button input if nonzero

   100    0x02

   101    0x18   ; JUMP  back to frame metronome (D31F)

   102    0xE7

   103    

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

   105 

   106         ;; btw, C_0 is now 1

   107         ;; prepare to select bits

   108 

   109    0x06 ;; load 0x00 into B

   110    0x00 ;; to initialize for "OR" loop

   111  

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

   113    0x20

   114 

   115    

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

   117    0x00

   118    

   119    0xF0 ;; load A from [FF00]

   120    0x00

   121 

   122    0xE6 ;; bitmask 00001111

   123    0x0F

   124    

   125    0xB0 ;; A or B --> A

   126    0xCB

   127    0x41 ;; test bit 0 of C

   128    0x28 ;; JUMP forward if 0

   129    0x08

   130 

   131    0x47 ;; A -> B

   132    0xCB ;; swap B nybbles

   133    0x30 

   134    0x0C ;; increment C

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

   136    0x10

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

   138    0xED

   139 

   140 

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

   142 

   143    ;; "input mode"

   144    ;; mode 0x00 : select mode

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

   146    ;; mode 0x10 : select hi-bit

   147    ;; mode 0x18 : select lo-bit

   148 

   149    ;; "output mode"

   150    ;; mode 0x20 : write bytes

   151    ;; mode 0xFF : jump PC

   152 

   153 

   154    ;; registers

   155    ;; D : mode select

   156    ;; E : count of bytes to write

   157    ;; H : address-high

   158    ;; L : address-low

   159    

   160    ;; now A contains the pressed keys

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

   162    

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

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

   165 

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

   167    0x6A

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

   169    0x13 ; JUMP

   170    

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

   172    0x42

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

   174    0x01

   175 

   176    ;; output mode I: moving the program counter

   177    0xE9 ; ** move PC to (HL)

   178 

   179    ;; output mode II: writing bytes

   180    0xFE ; A compare 0. finished writing?

   181    0x00

   182    0x20 ; if we are not finished, skip cleanup

   183    0x04 ; JUMP

   184 

   185    ;; CLEANUP

   186    ;; btw, A is already zero.

   187    0xAF ; zero A  [D35F]

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

   189    0x18 ; end of frame

   190    0xBC

   191    

   192    ;; ---- end of cleanup

   193 

   194    

   195    ;; continue writing bytes

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

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

   198    0x77 ;; copy A to (HL)

   199    0x23 ;; increment HL

   200    0x18 ;; end frame. [goto D31F]

   201    0xB6 ;; TODO: set skip length backwards

   202 

   203 

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

   205    

   206    ;; i/p mode

   207    ;; adhere to the mode discipline:

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

   209 

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

   211    0x57

   212    0x82 ;; add the mode to A

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

   214    0x74

   215    0xD3

   216 

   217    0x3E ;; load the constant 8 into A

   218    0x08

   219    0x82 ;; add the mode to A

   220    

   221    0x57 ;; store the incremented mode into D

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

   223    

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

   225 

   226    0x18 ;; end frame

   227    0xA8])

   228 

   229 (defn write-mem-compact []

   230   (-> (tick (mid-game))

   231       (IE! 0)

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

   233 

   234 (defn test-write-bytes-mode []

   235   (let [target-address 0xD135

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

   237         assembly [0xF3 0x18 0xFE 0x12]

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

   239                                  target-address (+ target-address 20))

   240         before (write-mem-compact)

   241         after

   242         (-> before

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

   244             (step [])                       ; at the beginning.

   245             (step [])                      

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

   247             (step (buttons 4))              ; write 4 bytes

   248             (step (buttons target-high))

   249             (step (buttons target-low))

   250             (step (buttons (nth assembly 0)))

   251             (step (buttons (nth assembly 1)))

   252             (step (buttons (nth assembly 2)))

   253             (step (buttons (nth assembly 3)))

   254             (step [])

   255             (step [])

   256             (step []))]

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

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

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

   260     after))

   261 

   262 (defn test-jump-mode []

   263   (let [target-address 0xC01F

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

   265         post-jump

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

   267             (step [])

   268             (step [])

   269             (step [])

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

   271             (step (buttons target-high))

   272             (step (buttons target-low)))

   273         program-counters

   274         (capture-program-counter 

   275          post-jump

   276          10000)]

   277     (println program-counters)

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

   279     post-jump))

   280 

   281 

   282 (defn test-loop []

   283   (contains?

   284    (set

   285     (capture-program-counter

   286      (-> (mid-game)

   287          ;;      (IE! 0)

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

   289          (PC! 0xD135)) 10000))

   290     0xD136))

   291      

   292       

   293 

   294                 

   295
author	Robert McIntyre <rlm@mit.edu>
date	Thu, 30 Aug 2012 14:11:11 -0500
parents	1f14c1b8af7e
children