Mercurial > vba-clojure

     1 (ns com.aurellem.assembly

     2   (:use (com.aurellem gb-driver vbm title items))

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

     4 

     5 (defn mid-game []

     6   (read-state "mid-game"))

     7 

     8 (defn inject-assembly

     9   ([^SaveState state

    10    program-counter registers

    11    assembly-code]

    12   (let [scratch-memory (memory state)]

    13     ;; inject assembly code

    14     (dorun (map (fn [index val]

    15                   (aset scratch-memory index val))

    16                 (range program-counter

    17                        (+ program-counter (count assembly-code)))

    18                 assembly-code))

    19     (-> state

    20         (write-memory! scratch-memory)

    21         (write-registers! registers)

    22         (PC! program-counter)))))

    23 

    24 (defn inject-item-assembly

    25   ([^SaveState state assembly-code]

    26      (inject-assembly state (inc item-list-start)

    27                       (registers state)

    28                       assembly-code))

    29   ([assembly-code]

    30      (inject-item-assembly @current-state assembly-code)))

    31 

    32 (defn info

    33   ([^SaveState state]

    34      (println (format "PC: 0x%04X" (PC state)))

    35      (println "Instruction:"

    36               (format "0x%02X" (aget (memory state) (PC state))))

    37      state))    

    38 

    39 (defn print-interrupt

    40   [^SaveState state]

    41   (println (format "IE: %d" (IE state)))

    42   state)

    43 

    44 (defn print-listing [state begin end]

    45   (dorun (map 

    46           (fn [opcode line]

    47             (println (format "0x%04X:  0x%02X" line opcode)))

    48           (subvec  (vec (memory state)) begin end)

    49           (range begin end)))

    50   state)

    51 

    52 (defn run-assembly

    53   ([info-fn assembly n]

    54      (let [final-state

    55            (reduce (fn [state _]

    56                      (tick (info-fn state)))

    57                    (inject-item-assembly

    58                      (mid-game) assembly)

    59                    (range n))]

    60        final-state))

    61   ([assembly n]

    62      (run-assembly info assembly n)))

    63 

    64 (def buttons-port 0xFF00)

    65 

    66 (defn A [state]

    67   (bit-shift-right (bit-and 0x0000FF00 (AF state)) 8))

    68 

    69 (defn B [state]

    70   (bit-shift-right (bit-and 0x0000FF00 (BC state)) 8))

    71 

    72 (defn C [state]

    73   (bit-and 0xFF (BC state)))

    74 

    75 (defn binary-str [num]

    76   (format "%08d"

    77           (Integer/parseInt

    78            (Integer/toBinaryString num) 10)))

    79 

    80 (defn view-register [state name reg-fn]

    81   (println (format "%s: %s" name

    82                    (binary-str (reg-fn state))))

    83   state)

    84 

    85 (defn view-memory [state mem]

    86   (println (format "mem 0x%04X = %s" mem

    87                    (binary-str (aget (memory state) mem))))

    88   state)

    89 

    90 (defn trace [state]

    91   (loop [program-counters [(first (registers @current-state)) ]

    92          opcodes [(aget (memory @current-state) (PC @current-state))]]

    93     (let [frame-boundary?

    94           (com.aurellem.gb.Gb/tick)]

    95       (if frame-boundary?

    96         [program-counters opcodes]

    97         (recur

    98          (conj program-counters

    99                (first (registers @current-state)))

   100          (conj opcodes

   101                (aget (memory @current-state)

   102                      (PC @current-state))))))))

   103 

   104 (defn print-trace [state n]

   105   (let [[program-counters opcodes] (trace state)]

   106     (dorun (map (fn [pc op] (println (format "%04X: 0x%02X" pc op)))

   107                 (take n program-counters)

   108                 (take n opcodes)))))

   109 

   110 (defn good-trace []

   111   (-> (mid-game) (tick) (IE! 0)

   112       (set-inv-mem [0x00 0x00 0X00 0x00])

   113       (PC! item-list-start)(print-interrupt)

   114       (info) (tick) (info) (tick) (info)))

   115 

   116 (defn read-down-button []

   117   (-> (tick (mid-game))

   118       (IE! 0) ; disable interrupts

   119       (inject-item-assembly

   120        ;; write 00010000 to 0xFF00 to select joypad

   121        [0x18   ;D31D                    ; jump over          

   122         0x01   ;D31E                    ; the next 8 bits

   123                                         ;D31F

   124         (Integer/parseInt "00100000" 2) ; data section 

   125         

   126         0xFA   ;D320                    ; load (D31F) into A

   127         0x1F   ;D321      -->       

   128         0xD3   ;D322      -->  D31F     

   129 

   130         0xEA   ;D323                    ; load (A), which is 

   131         0x00   ;D324      -->           ; 00010000, into FF00

   132         0xFF   ;D325      -->  FF00     

   133         

   134         0x18   ;D326                    ; this is the place where

   135         0x01   ;D327                    ; we will store whether

   136         0x00   ;D328                    ; "down" is pressed.

   137 

   138         0xFA   ;D329                    ; (FF00) -> A

   139         0x00   ;D32A                   

   140         0xFF   ;D32B

   141 

   142         0xCB   ;D32C                    ; Test whether "down"

   143         0x5F   ;D32D                    ; is pressed.

   144 

   145         0x28   ;D32E                    ; if down is pressed,

   146         0x03   ;D32F                    ; skip the next section 

   147                                         ; of code.

   148         ;; down-is-not-pressed

   149         0xC3   ;D330

   150         0x1D   ;D331                    ; return to beginning

   151         0xD3   ;D332

   152         

   153         ;; down-is-pressed 

   154         0xEA   ;D334                    ; write A to D328 if 

   155         0x28   ;D335                    ; "down" was pressed

   156         0xD3   ;D336

   157 

   158         0xC3   ;D330

   159         0x1D   ;D331                    ; return to beginning

   160         0xD3   ;D332

   161         ])))

   162 

   163 (defn test-read-down []

   164  (= (view-memory (step (step (read-down-button) [:d])) 0xD328)

   165     (view-memory (step (step (read-down-button))) 0xD328)))

   166 

   167 (defn count-frames []

   168   (-> (tick (mid-game))

   169       (IE! 0) ; disable interrupts

   170       (inject-item-assembly

   171        [0x18   ;D31D                    ; jump over          

   172         0x02   ;D31E                    ; the next 2 bytes

   173         0x00   ;D31F                    ; frame-count

   174         0x00   ;D320                    ; v-blank-prev

   175         

   176         0xFA   ;D321

   177         0x41   ;D322                    ; load (FF41) into A

   178         0xFF   ;D323                    ; this contains mode flags

   179         

   180         ;; if we're in v-blank, the bit-1 is 0

   181         ;; and bit-2 is 1  Otherwise, it is not v-blank.

   182         0xCB   ;D324                     ; test bit-1 of A

   183         0x4F   ;D325                         

   184 

   185         0xC2   ;D326                     ; if bit-1 is not 0

   186         0x44   ;D327                     ; GOTO not-v-blank

   187         0xD3   ;D328

   188         

   189         0xCB   ;D329                     ; test bit-0 of A 

   190         0x47   ;D32A

   191 

   192         0xCA   ;D32B                     ; if bit-0 is not 1

   193         0x44   ;D32C                     ; GOTO not-v-blank

   194         0xD3   ;D32D

   195         ;;; in v-blank mode

   196            ;; if v-blank-prev was 0,

   197            ;; increment frame-count

   198 

   199         0xFA   ;D32E                    ; load v-blank-prev to A

   200         0x20   ;D32F

   201         0xD3   ;D330

   202         

   203         0xCB   ;D331

   204         0x47   ;D332                    ; test bit-0 of A 

   205 

   206         0x20   ;D333                    ; skip next section

   207         0x07   ;D334                    ; if v-blank-prev was not zero 

   208         

   209            ;; v-blank was 0, increment frame-count

   210         0xFA   ;D335                    ; load frame-count into A

   211         0x1F   ;D336

   212         0xD3   ;D337                   

   213 

   214         0x3C   ;D338                    ; inc A

   215 

   216         0xEA   ;D339                    ; load A into frame-count

   217         0x1F   ;D33A

   218         0xD3   ;D33B

   219 

   220            ;; set v-blank-prev to 1

   221         0x3E   ;D33C                    ; load 1 into A

   222         0x01   ;D33D                    

   223 

   224         0xEA   ;D33E                    ; load A into v-blank-prev

   225         0x20   ;D33F

   226         0xD3   ;D340

   227 

   228         0xC3   ;D341                   ; return to beginning

   229         0x1D   ;D342

   230         0xD3   ;D343

   231 

   232         ;;; not in v-blank mode

   233            ;; set v-blank-prev to 0

   234         0x3E   ;D344                    ; load 0 into A        

   235         0x00   ;D345

   236 

   237         0xEA   ;D346                    ; load A into v-blank-prev

   238         0x20   ;D347

   239         0xD3   ;D348

   240 

   241         0xC3   ;D349                   ; return to beginning

   242         0x1D   ;D34A

   243         0xD3   ;D34B

   244         ])))

   245 

   246 (defn step-count-frames []

   247   (-> (read-down-button)

   248       (info)

   249       (tick)  ;; skip over data section

   250       (info)  

   251       (view-register "Register A" A)

   252       (tick)  ;; load-data into A

   253       (view-register "Register A" A)

   254       (info)

   255       (view-memory 0xFF00)

   256       (tick) ;; load A into 0xFF00

   257       (view-memory 0xFF00)

   258       (info)

   259       (tick)

   260       (info)

   261       (tick)

   262       (info)

   263       (tick)

   264       (info)

   265       (tick)

   266       (info)

   267       (tick)

   268       (info)

   269       (tick)

   270       (print-inventory)))

   271 

   272 (defn test-count-frames []

   273   (= 255 (aget (memory ((apply comp (repeat 255 step))

   274                         (count-frames)))

   275                0xD31F)))

   276 

   277 ;; specs for main bootstrap program

   278 ;; starts in "mode-select" mode

   279 ;;   Each button press takes place in a single frame.

   280 ;;   mode-select-mode takes one of the main buttons

   281 ;;   which selects one of up to eight modes

   282 ;;   mode 1 activated by the "A" button

   283 ;;   the next two button presses indicates the start

   284 ;;   memory location which to which the bootstrap

   285 ;;   program will write.

   286 ;;   This is done by using each of the eight buttons to

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

   288 ;;   [:d :u :l :r :start :select :b :a]

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

   290 

   291 ;;   the next button press determines how many bytes are to be

   292 ;;   written, starting at the start position.

   293 

   294 ;;   then, the actual bytes are entered and are written to the

   295 ;;   start address in sequence.

   296 

   297 (defn input-number-assembly []

   298   [0x18   ;D31D                    ; jump over          

   299    0x02   ;D31E                    ; the next 2 bytes

   300    0x00   ;D31F                    ; frame-count

   301    0x00   ;D320                    ; v-blank-prev

   302    

   303    0xFA   ;D321

   304    0x41   ;D322                    ; load (FF41) into A

   305    0xFF   ;D323                    ; this contains mode flags

   306    

   307    ;; if we're in v-blank, the bit-1 is 0

   308    ;; and bit-2 is 1  Otherwise, it is not v-blank.

   309    0xCB   ;D324                     ; test bit-1 of A

   310    0x4F   ;D325                         

   311 

   312    0xC2   ;D326                     ; if bit-1 is not 0

   313    0x44   ;D327                     ; GOTO not-v-blank

   314    0xD3   ;D328

   315    

   316    0xCB   ;D329                     ; test bit-0 of A 

   317    0x47   ;D32A

   318 

   319    0xCA   ;D32B                     ; if bit-0 is not 1

   320    0x44   ;D32C                     ; GOTO not-v-blank

   321    0xD3   ;D32D

   322    

   323         ;;; in v-blank mode

   324 

   325    ;; if v-blank-prev was 0,

   326    ;; increment frame-count

   327 

   328    0xFA   ;D32E                    ; load v-blank-prev to A

   329    0x20   ;D32F

   330    0xD3   ;D330

   331    

   332    0xCB   ;D331

   333    0x47   ;D332                    ; test bit-0 of A 

   334 

   335    0x20   ;D333                    ; skip next section

   336    0x07   ;D334                    ; if v-blank-prev was not zero 

   337    

   338    ;; v-blank was 0, increment frame-count

   339    0xFA   ;D335                    ; load frame-count into A

   340    0x1F   ;D336

   341    0xD3   ;D337                   

   342 

   343    0x3C   ;D338                    ; inc A

   344 

   345    0xEA   ;D339                    ; load A into frame-count

   346    0x1F   ;D33A

   347    0xD3   ;D33B

   348 

   349    ;; set v-blank-prev to 1

   350    0x3E   ;D33C                    ; load 1 into A

   351    0x01   ;D33D                    

   352 

   353    0xEA   ;D33E                    ; load A into v-blank-prev

   354    0x20   ;D33F

   355    0xD3   ;D340

   356 

   357    0xC3   ;D341                   ; GOTO input handling code

   358    0x4E   ;D342

   359    0xD3   ;D343

   360 

   361         ;;; not in v-blank mode

   362    ;; set v-blank-prev to 0

   363    0x3E   ;D344                    ; load 0 into A        

   364    0x00   ;D345

   365 

   366    0xEA   ;D346                    ; load A into v-blank-prev

   367    0x20   ;D347

   368    0xD3   ;D348

   369 

   370    0xC3   ;D349                   ; return to beginning

   371    0x1D   ;D34A

   372    0xD3   ;D34B

   373 

   374    0x00   ;D34C                   ; these are here 

   375    0x00   ;D34D                   ; for glue

   376    

   377    

   378         ;;; calculate input number based on button presses

   379    0x18   ;D34E                    ;  skip next 3 bytes

   380    0x03   ;D34F

   381                                         ;D350

   382    (Integer/parseInt "00100000" 2) ;  select directional pad

   383                                         ;D351

   384    (Integer/parseInt "00010000" 2) ;  select buttons

   385    0x00   ;D352                    ;  input-number

   386 

   387    ;; select directional pad, store low bits in B

   388    

   389    0xFA   ;D353                    ; load (D350) into A

   390    0x50   ;D354      -->       

   391    0xD3   ;D355      -->  D31F     

   392    

   393    0xEA   ;D356                    ; load A, which is 

   394    0x00   ;D357      -->           ; 00010000, into FF00

   395    0xFF   ;D358      -->  FF00     

   396 

   397    0x06   ;D359

   398                                         ;D35A

   399    (Integer/parseInt "11110000" 2) ; "11110000" -> B 

   400    0xFA   ;D35B                    ; (FF00) -> A

   401    0x00   ;D35C                   

   402    0xFF   ;D35D

   403 

   404    0xCB   ;D35E                    ; swap nybbles on A

   405    0x37   ;D35F

   406    0xA0   ;D360                    ; (AND A B) -> A

   407    0x47   ;D361                    ; A -> B

   408 

   409    ;; select buttons store bottom bits in C

   410    

   411    0xFA   ;                        ; load (D351) into A

   412    0x51   ;          -->       

   413    0xD3   ;          -->  D31F     

   414    

   415    0xEA   ;                        ; load (A), which is 

   416    0x00   ;          -->           ; 00001000, into FF00

   417    0xFF   ;          -->  FF00     

   418 

   419    0x0E   ;    

   420    (Integer/parseInt "00001111" 2) ; "00001111" -> C 

   421 

   422    0xFA   ;                        ; (FF00) -> A

   423    0x00   ;                       

   424    0xFF   ;    

   425    

   426    0xA1   ;                        ; (AND A C) -> A

   427    0x4F   ;                        ; A -> C

   428 

   429    ;; combine the B and C registers into the input number

   430    0x79   ;                        ; C -> A

   431    0xB0   ;                        ; (OR A B) -> A

   432    0x2F   ;                        ; negate A

   433 

   434    0xEA   ;                        ; store A into input-number

   435    0x52   ;

   436    0xD3   ;

   437 

   438    0xC3   ;                        ; return to beginning

   439    0x1D   ;    

   440    0xD3   ;    

   441    ])

   442 

   443 

   444 (defn print-pc [state]

   445   (println (format "PC: 0x%04X" (PC state)))

   446   state)

   447 

   448 (defn print-op [state]

   449   (println (format "OP: 0x%02X" (aget (memory state) (PC state))))

   450   state)

   451 

   452 (defn d-tick

   453   ([state]

   454   (-> state print-pc print-op tick)))

   455 

   456 (defn input-number []

   457   (-> (tick (mid-game))

   458       (IE! 0) ; disable interrupts

   459       (inject-item-assembly (input-number-assembly))))

   460   

   461 (defn test-input-number

   462   "Input freestyle buttons and observe the effects at the repl."

   463   []

   464   (set-state! (input-number)) 

   465   (dotimes [_ 90000] (step (view-memory @current-state 0xD352))))

   466 

   467 

   468     

   469 

   470 

   471 

   472 

   473 

   474 

   475 

   476 

   477 

   478 

   479 

   480 

   481 

   482 

   483 

   484 

   485 

   486 

   487 

   488 

   489 

   490 

   491 

   492 

   493 

   494 

   495 (defn write-memory-assembly*

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

   497   []

   498   [

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

   500    0x00 ;; v-blank-prev D31D

   501 

   502    0xFA ;; load modes into A

   503    0x41

   504    0xFF

   505 

   506    0x47 ;; A -> B

   507    0xCB ;; rotate A

   508    0x2F

   509    0x2F ;; invert A

   510 

   511    0xA0

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

   513 

   514    0xFA ;; load v-blank-prev

   515    0x1D

   516    0xD3

   517 

   518    0x2F ;; complement v-blank-prev

   519    

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

   521    0x4F ;; now C_0 contains increment?

   522 

   523 

   524    0x78 ;; B->A

   525    

   526    0xEA ;; spit A --> vbprev

   527    0x1D

   528    0xD3

   529 

   530    0xCB   ;test C_0

   531    0x41

   532    0x20   ; JUMP ahead to button input if nonzero

   533    0x03

   534    0x18   ; JUMP  back to frame metronome (D31E)

   535    0xE7  

   536    

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

   538 

   539         ;; btw, C_0 is now 1

   540    0x00 ;; var: which-input D337

   541         ;; prepare to select bits

   542 

   543    0x06 ;; load 0x00 into B

   544    0x00

   545  

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

   547    0x20

   548 

   549    

   550    0xE0 ;; load A into [FF00] ;; D33C

   551    0x00

   552    

   553    0xF0 ;; load A from [FF00]

   554    0x00

   555 

   556    0xE6 ;; bitmask 00001111

   557    0x0F

   558    

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

   560    0xCB

   561    0x41 ;; test bit 0 of C

   562    0x28 ;; JUMP forward if 0

   563    0x08

   564 

   565    0x47 ;; A -> B

   566    0xCB ;; swap B nybbles

   567    0x30 

   568    0x0C ;; increment C

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

   570    0x10

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

   572    0xED

   573 

   574    ;; now A contains the pressed keys

   575    

   576    

   577 

   578 

   579 

   580 

   581 

   582 

   583    0xC3 ;; todo replace with relative jump

   584    0x1E

   585    0xD3

   586    ;;0x18 ;;JUMP back to "metronome" in one hop [D31E]

   587    ;;0xCA ;; E1

   588    

   589    ]

   590   )

   591 

   592 (defn write-mem-dyl []

   593   (-> (tick (mid-game))

   594       (IE! 0)

   595       (inject-item-assembly (write-memory-assembly*))))

   596 

   597 

   598 (defn dylan []

   599   (->

   600    (write-mem-dyl)

   601    (tick)

   602    (tick)

   603    (tick)

   604    (tick)

   605    (tick)

   606    (tick)

   607    (tick)

   608    (tick)

   609    (tick)

   610    (tick)

   611    (tick)

   612    (tick)

   613    (tick)

   614    (tick)

   615    (tick) ;; first loop

   616 

   617 

   618    (tick)

   619    (tick)

   620    (tick)

   621    (tick)

   622    (tick)

   623    (tick)

   624    (tick)

   625    (tick)

   626    (tick)

   627    (tick)

   628    (tick)

   629    (tick)

   630    (tick) ;; dpad bits

   631 

   632    (tick)

   633    (tick)

   634    (tick)

   635    (tick)

   636    (tick)

   637    (tick)

   638    (tick)

   639    (tick)

   640    (d-tick)

   641    

   642 

   643    

   644    (view-register "A" A)

   645    (view-register "B" B)

   646    (view-register "C" C)

   647    

   648    ))

   649 

   650 

   651 

   652 

   653 (defn d2 []

   654   (->

   655    (write-mem-dyl)

   656    (view-memory 0xD31F)

   657    step step step step step

   658    (view-memory 0xD31F)))

   659 

   660 

   661 

   662 

   663 

   664 

   665 

   666 

   667 

   668 

   669 

   670 

   671 

   672 

   673 

   674 

   675 

   676 

   677 

   678 

   679 (defn write-memory-assembly []

   680   [

   681    ;; Main Timing Loop

   682    ;;   Constantly check for v-blank and Trigger main state machine on

   683    ;;   every transtion from v-blank to non-v-blank.

   684     

   685    0x18   ; D31D                  ; Variable declaration

   686    0x02   ; D31E                   

   687    0x00   ; D31F                  ; frame-count

   688    0x00   ; D320                  ; v-blank-prev 

   689    

   690    0xF0   ; D321                  ; load v-blank mode flags into A

   691    0x41

   692    0x00

   693 

   694 

   695    ;; Branch dependent on v-blank.  v-blank happens when the last two

   696    ;; bits in A are "01"

   697    0xCB   ; D324                  

   698    0x4F   ; D325                  

   699 

   700    0xC2   ; D326                  ; if bit-1 is not 0, then

   701    0x3E   ; D327                  ; GOTO non-v-blank.

   702    0xD3   ; D328                  

   703 

   704    0xCB   ; D329                  

   705    0x47   ; D32A                  

   706 

   707    0xCA   ; D32B                  ; if bit-0 is not 1, then

   708    0x3E   ; D32C                  ; GOTO non-v-blank.

   709    0xD3   ; D32D                  

   710 

   711    ;; V-Blank

   712    ;;   Activate state-machine if this is a transition event.

   713 

   714    0xFA   ; D32E                  ; load v-bank-prev into A

   715    0x20   ; D32F                  

   716    0xD3   ; D330                  

   717 

   718    0xFE   ; D331                  ; compare A to 0. >--------\ 

   719    0x00   ; D332                                              \

   720                                   ;                           |

   721    ;;   set v-blank-prev to 1.                                |

   722    0x3E   ; D333                  ; load 1 into A.            |

   723    0x01   ; D334                                              | 

   724                                   ;                           |

   725    0xEA   ; D335                  ; load A into v-blank-prev  |

   726    0x20   ; D336                                              |

   727    0xD3   ; D337                                              |

   728                                   ;                           /

   729    ;;   if v-blank-prev was 0, activate state-machine <------/

   730    0xCA   ; D338                  ; if v-blank-prev 

   731    0x46   ; D339                  ;   was 0, 

   732    0xD3   ; D33A                  ; GOTO state-machine

   733 

   734    0xC3   ; D33B                  

   735    0x1D   ; D33C                  

   736    0xD3   ; D33D                  ; GOTO beginning

   737    ;; END V-blank

   738 

   739    ;; Non-V-Blank

   740    ;;   Set v-blank-prev to 0

   741    0x3E   ; D33E                  ; load 0 into A

   742    0x00   ; D33F                  

   743 

   744    0xEA   ; D340                  ; load A into v-blank-prev

   745    0x20   ; D341                  

   746    0xD3   ; D342

   747    

   748    0xC3   ; D343                  

   749    0x1D   ; D344                  

   750    0xD3   ; D345                  ; GOTO beginning

   751    ;; END Not-V-Blank

   752 

   753    

   754    ;; Main State Machine -- Input Section

   755    ;;   This is called once every frame.

   756    ;;   It collects input and uses it to drive the

   757    ;;   state transitions.

   758 

   759    ;; Increment frame-count

   760    0xFA   ; D346                  ; load frame-count into A

   761    0x1F   ; D347                  

   762    0xD3   ; D348

   763    

   764    0x3C   ; D349                  ; inc A

   765 

   766    0xEA   ; D34A                  

   767    0x1F   ; D34B                  ; load A into frame-count

   768    0xD3   ; D34C

   769 

   770    0x00   ; D34D                  ; glue :)

   771    

   772    0x18   ;D34E                    ;  skip next 3 bytes

   773    0x03   ;D34F

   774           ;D350

   775    (Integer/parseInt "00100000" 2) ;  select directional pad

   776           ;D351

   777    (Integer/parseInt "00010000" 2) ;  select buttons

   778    0x00   ;D352                    ;  input-number

   779 

   780    ;; select directional pad; store low bits in B

   781    

   782    0xFA   ;D353                    ; load (D350) into A

   783    0x50   ;D354      -->       

   784    0xD3   ;D355      -->  D350     

   785    

   786    0xE0   ;D356                    ; load (A), which is 

   787    0x00   ;D357      -->           ; 00010000, into FF00

   788    0x00   ;D358      -->  FF00     ;; NO-OP

   789 

   790    0x06   ;D359

   791           ;D35A

   792    (Integer/parseInt "11110000" 2) ; "11110000" -> B 

   793    0xF0   ;D35B                    ; (FF00) -> A

   794    0x00   ;D35C                   

   795    0x00   ;D35D                    ;; NO-OP

   796 

   797    0xCB   ;D35E                    ; swap nybbles on A

   798    0x37   ;D35F

   799    0xA0   ;D360                    ; (AND A B) -> A

   800    0x47   ;D361                    ; A -> B

   801 

   802    ;; select buttons; store bottom bits in C

   803    

   804    0xFA   ;D362                    ; load (D351) into A

   805    0x51   ;D363      -->       

   806    0xD3   ;D364      -->  D351     

   807    

   808    0xE0   ;D365                    ; load (A), which is 

   809    0x00   ;D366      -->           ; 00001000, into FF00

   810    0x00   ;D367      -->  FF00     ;; NO-OP

   811 

   812    0x0E   ;D368

   813           ;D369

   814    (Integer/parseInt "00001111" 2) ; "00001111" -> C 

   815 

   816    0xF0   ;D36A                    ; (FF00) -> A

   817    0x00   ;D36B                   

   818    0x00   ;D36C

   819    

   820    0xA1   ;D36D                    ; (AND A C) -> A

   821    0x4F   ;D36E                    ; A -> C

   822 

   823    ;; combine the B and C registers into the input number

   824    0x79   ;D36F                    ; C -> A

   825    0xB0   ;D370                    ; (OR A B) -> A

   826    0x2F   ;D371                    ; negate A

   827 

   828    0xEA   ;D372                    ; store A into input-number

   829    0x52   ;D373

   830    0xD3   ;D374

   831 

   832    0x00   ;D375                  

   833    0x00   ;D376

   834    0x00   ;D377

   835    0x00   ;D378

   836    0x00   ;D379

   837    0x00   ;D37A

   838    0x00   ;D37B                   ; these are here because 

   839    0x00   ;D37C                   ; I messed up :(

   840    0x00   ;D37D

   841    0x00   ;D37E

   842    0x00   ;D37F

   843    

   844    ;; beginning of main state machine   

   845    0x18   ;D380                    ; Declaration of variables

   846    0x05   ;D381                    ;  5 variables:

   847    0x00   ;D382                    ;    current-mode

   848    0x00   ;D383                    ;    bytes-to-write

   849    0x00   ;D384                    ;    bytes-written

   850    0x00   ;D385                    ;    start-point-high

   851    0x00   ;D386                    ;    start-point-low

   852 

   853 

   854    ;; banch on current mode

   855    0xFA   ;D387                    ; load current-mode (0xD382)

   856    0x82   ;D388                    ; into A

   857    0xD3   ;D389

   858    0x00   ;D38A

   859 

   860 

   861    ;;  GOTO Mode 0 (input-mode) if current-mode is 0

   862    0xFE   ;D38B

   863    0x00   ;D38C                    ; compare A with 0x00

   864 

   865    0xCA   ;D38D                    ; goto Mode 0 if A == 0

   866    0xA8   ;D38E

   867    0xD3   ;D38F

   868 

   869    ;; GOTO Mode 1 (set-length) if current-mode is 1

   870    0xFE   ;D390

   871    0x01   ;D391                    ; compare A with 0x01

   872 

   873    0xCA   ;D392                  

   874    0xB1   ;D393 

   875    0xD3   ;D394                    ; goto Mode 1 if A == 1

   876 

   877    ;; GOTO Mode 2 (set-start-point-high) if current mode is 2

   878    0xFE   ;D395                    

   879    0x02   ;D396                    ; compare A with 0x02

   880 

   881    0xCA   ;D397

   882    0xBF   ;D398

   883    0xD3   ;D399                    ; goto Mode 2 if A == 2

   884 

   885    ;; GOTO Mode 3 (set-start-point-low) if current mode is 3

   886    0xFE   ;D39A

   887    0x03   ;D39B

   888 

   889    0xCA   ;D39C

   890    0xCD   ;D39D

   891    0xD3   ;D39E                    ; goto Mode 3 if A == 3

   892 

   893    ;; GOTO Mode 4 (write-memory) if current mode is 4

   894    0xFE   ;D39F

   895    0x04   ;D3A0

   896 

   897    0xCA   ;D3A1

   898    0xDB   ;D3A2

   899    0xD3   ;D3A3

   900 

   901    0x00   ;D3A4

   902    ;; End of Mode checking, goto beginning

   903    0xC3   ;D3A5

   904    0x1D   ;D3A6

   905    0xD3   ;D3A7

   906 

   907 

   908    ;; Mode 0 -- input-mode mode

   909    ;;     means that we are waiting for a mode, so set the mode to

   910    ;;     whatever is currently in input-number.  If nothing is

   911    ;;     entered, then the program stays in input-mode mode

   912 

   913    ;;   set current-mode to input-number

   914    0xFA   ;D3A8                    ; load input-number (0xD352) 

   915    0x52   ;D3A9                    ; into A

   916    0xD3   ;D3AA

   917 

   918    0xEA   ;D3AB                    ; load A into current-mode

   919    0x82   ;D3AC                    ; (0xD382)

   920    0xD3   ;D3AD

   921 

   922    0xC3   ;D3AE                    ; go back to beginning

   923    0x1D   ;D3AF

   924    0xD3   ;D3B0

   925    ;; End Mode 0

   926 

   927 

   928    ;; Mode 1 -- set-length mode

   929    ;;      This is the header for writing things to memory.

   930    ;;      User specifies the number of bytes to write.

   931    ;;      Mode is auto advanced to Mode 2 after this mode

   932    ;;      completes.

   933 

   934    ;;      Set bytes left to write to input-number;

   935    ;;      set current-mode to 0x02.

   936    0xFA   ;D3B1                   ; load input-number (0xD352)

   937    0x52   ;D3B2                   ; into A

   938    0xD3   ;D3B3

   939    

   940    0xEA   ;D3B4                   ; load A into bytes-left-to-write

   941    0x83   ;D3B5                   ; (0xD383)

   942    0xD3   ;D3B6

   943 

   944    0x3E   ;D3B7                   ; load 0x02 into A.

   945    0x02   ;D3B8

   946    

   947    0xEA   ;D3B9                   ; load A to current-mode

   948    0x82   ;D3BA                   ; advancing from Mode 1 to 

   949    0xD3   ;D3BB                   ; Mode 2

   950    

   951    0xC3   ;D3BC                   ; go back to beginning

   952    0x1D   ;D3BD

   953    0xD3   ;D3BE

   954    ;; End Mode 1

   955 

   956 

   957    ;; Mode 2 -- set start-point-high mode

   958    ;;      Middle part of the header for writing things to memory.

   959    ;;      User specifies the start location in RAM to which 

   960    ;;      data will be written.

   961    ;;      Mode is auto advanced to Mode 3 after this mode completes.

   962 

   963    ;;      Set start-point-high to input-number;

   964    ;;      set current mode to 0x03.

   965    0xFA   ;D3BF                   ; load input-number (0xD352)

   966    0x52   ;D3C0                   ; into A

   967    0xD3   ;D3C1

   968 

   969    0xEA   ;D3C2                   ; load A into start-point-high

   970    0x85   ;D3C3                   ; (0xD385)

   971    0xD3   ;D3C4

   972 

   973    0x3E   ;D3C5                   ; load 0x03 into A.

   974    0x03   ;D3C6

   975 

   976    0xEA   ;D3C7                   ; load A to current-mode,

   977    0x82   ;D3C8                   ; advancing from Mode 2 to 

   978    0xD3   ;D3C9                   ; Mode 3.

   979    

   980    0xC3   ;D3CA                   ; go back to beginning

   981    0x1D   ;D3CB

   982    0xD3   ;D3CC

   983    ;;End Mode 2

   984 

   985 

   986    ;; Mode 3 -- set-start-point-low mode

   987    ;;      Final part of header for writing things to memory.

   988    ;;      User specifies the low bytes of 16 bit start-point.

   989 

   990    ;;      Set start-point-low to input-number;

   991    ;;      set current mode to 0x04

   992    0xFA   ;D3CD                   ; load input-number into A

   993    0x52   ;D3CE                   

   994    0xD3   ;D3CF                   

   995 

   996    0xEA   ;D3D0                   ; load A into start-point-low

   997    0x86   ;D3D1                   

   998    0xD3   ;D3D2                   

   999 

  1000    0x3E   ;D3D3                   ; load 0x04 into A.

  1001    0x04   ;D3D4                   

  1002 

  1003    0xEA   ;D3D5                   ; load A to current-mode,

  1004    0x82   ;D3D6                   ; advancing from Mode 3 to 

  1005    0xD3   ;D3D7                   ; Mode 4.

  1006 

  1007    0xC3   ;D3D8                   ; go back to beginning

  1008    0x1D   ;D3D9                   

  1009    0xD3   ;D3DA                   

  1010    

  1011    ;; Mode 4 -- write bytes mode

  1012 

  1013    ;;      This is where RAM manipulation happens.  User supplies

  1014    ;;      bytes every frame, which are written sequentially to

  1015    ;;      start-point until bytes-to-write have been written. Once

  1016    ;;      bytes-to-write have been written, the mode is reset to 0.

  1017 

  1018    ;;   compare bytes-written with bytes-to-write.

  1019    ;;   if they are the same, then reset mode to 0

  1020   

  1021    0xFA   ;D3DB                   ; load bytes-to-write into A

  1022    0x83   ;D3DC

  1023    0xD3   ;D3DD

  1024 

  1025    0x47   ;D3DE                   ; load A into B

  1026 

  1027    0xFA   ;D3DF                   ; load bytes-written into A

  1028    0x84   ;D3E0

  1029    0xD3   ;D3E1

  1030 

  1031    0xB8   ;D3E2                   ; compare A with B

  1032 

  1033    0xCA   ;D3E3                   ; if they are equal, go to cleanup

  1034    0x07   ;D3E4                   

  1035    0xD4   ;D3E5                   

  1036 

  1037    ;;  Write Memory Section

  1038    ;;    Write the input-number, interpreted as an 8-bit number,

  1039    ;;    into the current target register, determined by

  1040    ;;    (+ start-point bytes-written).

  1041    ;;    Then, increment bytes-written by 1.

  1042    

  1043    0xFA   ;D3E6                   ; load start-point-high into A

  1044    0x85   ;D3E7                   

  1045    0xD3   ;D3E8                   

  1046 

  1047    0x67   ;D3E9                   ; load A into H

  1048 

  1049    0xFA   ;D3EA                   ; load start-point-low into A

  1050    0x86   ;D3EB                   

  1051    0xD3   ;D3EC

  1052    

  1053    0x6F   ;D3ED                   ; load A into L

  1054    

  1055    0xFA   ;D3EE                   ; load bytes-written into A

  1056    0x84   ;D3EF                   

  1057    0xD3   ;D3F0                   

  1058    

  1059    0x00   ;D3F1                   ; These are here because

  1060    0x00   ;D3F2                   ; I screwed up again.

  1061    0x00   ;D3F3                   

  1062 

  1063    0x85   ;D3F4                   ; add L to A; store A in L.

  1064    0x6F   ;D3F5                   

  1065 

  1066    0x30   ;D3F6                   ; If the addition overflowed,

  1067    0x01   ;D3F7                   

  1068    0x24   ;D3F8                   ; increment H.

  1069 

  1070    ;;   Now, HL points to the correct place in memory

  1071    

  1072    0xFA   ;D3F9                   ; load input-number into A

  1073    0x52   ;D3FA                   

  1074    0xD3   ;D3FB                   

  1075 

  1076    0x77   ;D3FC                   ; load A into (HL)

  1077 

  1078    0xFA   ;D3FD                   ; load bytes-written into A

  1079    0x84   ;D3FE                   

  1080    0xD3   ;D3FF                   

  1081 

  1082    0x3C   ;D400                   ; increment A

  1083 

  1084    0xEA   ;D401                   ; load A into bytes-written

  1085    0x84   ;D402                   

  1086    0xD3   ;D403

  1087 

  1088    0xC3   ;D404                   ; go back to beginning.

  1089    0x1D   ;D405

  1090    0xD3   ;D406

  1091    ;;  End Write Memory Section

  1092 

  1093    ;;  Mode 4 Cleanup Section

  1094    ;;    reset bytes-written to 0

  1095    ;;    set mode to 0

  1096    0x3E   ;D407                   ; load 0 into A

  1097    0x00   ;D408                  

  1098 

  1099    0xEA   ;D409                   ; load A into bytes-written

  1100    0x84   ;D40A                   

  1101    0xD3   ;D40B                   

  1102 

  1103    0xEA   ;D40C                   ; load A into current-mode

  1104    0x82   ;D40D                   

  1105    0xD3   ;D40E                   

  1106 

  1107    0xC3   ;D40F                    ; go back to beginning

  1108    0x1D   ;D410

  1109    0xD3   ;D411

  1110 

  1111    ;; End Mode 4

  1112    

  1113    ])

  1114 

  1115 

  1116 

  1117 (def frame-count 0xD31F)

  1118 (def input 0xD352)

  1119 (def current-mode      0xD382)

  1120 (def bytes-to-write    0xD383)

  1121 (def bytes-written     0xD384)

  1122 (def start-point-high  0xD385)

  1123 (def start-point-low   0xD386)

  1124 

  1125 

  1126 

  1127 (defn write-memory []

  1128   (-> (tick (mid-game))

  1129       (IE! 0) ; disable interrupts

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

  1131 

  1132 (defn test-write-memory []

  1133   (set-state! (write-memory))

  1134   (dorun

  1135    (dotimes [_ 5000]

  1136      (view-memory (step @current-state) current-mode))))

  1137 

  1138 (def bytes-to-write 0xD383)

  1139 (def start-point 0xD384)

  1140 

  1141 (defn print-blank-assembly

  1142   [start end]

  1143   (dorun

  1144    (map

  1145     #(println (format "0x00   ;%04X                   " %))

  1146     (range start end))))

  1147 

  1148 (defn test-mode-2 []

  1149   (->

  1150    (write-memory)

  1151    (view-memory frame-count)

  1152    (step)

  1153    (step [:a])

  1154    (step [:b])

  1155    (step [:start])

  1156    (step [])

  1157    (view-memory frame-count)))

  1158 

  1159 (defn test-mode-4

  1160   ([] (test-mode-4 (write-memory)))

  1161   ([target-state]

  1162      (->

  1163       target-state

  1164       (#(do (println "memory from 0xC00F to 0xC01F:"

  1165                      (subvec (vec (memory %)) 0xC00F 0xC01F)) %))

  1166       (view-memory current-mode)

  1167       (step [])

  1168       (step [])

  1169       (step [])

  1170       (#(do (println "after three steps") %))

  1171       (view-memory current-mode)

  1172 

  1173       ;; Activate memory writing mode

  1174       

  1175       (#(do (println "step with [:a]") %))

  1176       (step [:a])

  1177       (view-memory current-mode)

  1178       (view-memory bytes-to-write)

  1179       (view-memory start-point-high)

  1180       (view-memory start-point-low)

  1181 

  1182       ;; Specify four bytes to be written

  1183       

  1184       (#(do (println "step with [:select]")%))

  1185       (step [:select])

  1186       (view-memory current-mode)

  1187       (view-memory bytes-to-write)

  1188       (view-memory start-point-high)

  1189       (view-memory start-point-low)

  1190 

  1191       ;; Specify target memory address as 0xC00F

  1192       

  1193       (#(do (println "step with [:u :d]")%))

  1194       (step [:u :d])

  1195       (view-memory current-mode)

  1196       (view-memory bytes-to-write)

  1197       (view-memory start-point-high)

  1198       (view-memory start-point-low)

  1199 

  1200       (#(do (println "step with [:a :b :start :select]")%))

  1201       (step [:a :b :start :select])

  1202       (view-memory current-mode)

  1203       (view-memory bytes-to-write)

  1204       (view-memory start-point-high)

  1205       (view-memory start-point-low)

  1206 

  1207       ;; Start reprogramming memory

  1208 

  1209       (#(do (println "step with [:a]")%))

  1210       (step [:a])

  1211       (view-memory current-mode)

  1212       (view-memory bytes-written)

  1213 

  1214       (#(do (println "step with [:b]")%))

  1215       (step [:b])

  1216       (view-memory current-mode)

  1217       (view-memory bytes-written)

  1218 

  1219       (#(do (println "step with [:a :b]")%))

  1220       (step [:a :b])

  1221       (view-memory current-mode)

  1222       (view-memory bytes-written)

  1223 

  1224       (#(do (println "step with [:select]")%))

  1225       (step [:select])

  1226       (view-memory current-mode)

  1227       (view-memory bytes-written)

  1228 

  1229       ;; Reprogramming done, program ready for more commands.

  1230 

  1231       (#(do (println "step with []")%))

  1232       (step [])

  1233       (view-memory current-mode)

  1234       (view-memory bytes-written)

  1235       

  1236       (#(do (println "memory from 0xC00F to 0xC01F:"

  1237                      (subvec (vec (memory %)) 0xC00F 0xC01F)) %)))))

  1238
author	Dylan Holmes <ocsenave@gmail.com>
date	Sun, 18 Mar 2012 20:49:40 -0500
parents	ffeeabae7dcd
children	2b69cbe8a5b9