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 binary-str [num]

    70   (format "%08d"

    71           (Integer/parseInt

    72            (Integer/toBinaryString num) 10)))

    73 

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

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

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

    77   state)

    78 

    79 (defn view-memory [state mem]

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

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

    82   state)

    83 

    84 (defn trace [state]

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

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

    87     (let [frame-boundary?

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

    89       (if frame-boundary?

    90         [program-counters opcodes]

    91         (recur

    92          (conj program-counters

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

    94          (conj opcodes

    95                (aget (memory @current-state)

    96                      (PC @current-state))))))))

    97 

    98 (defn print-trace [state n]

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

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

   101                 (take n program-counters)

   102                 (take n opcodes)))))

   103 

   104 (defn good-trace []

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

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

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

   108       (info) (tick) (info) (tick) (info)))

   109 

   110 (defn read-down-button []

   111   (-> (tick (mid-game))

   112       (IE! 0) ; disable interrupts

   113       (inject-item-assembly

   114        ;; write 00010000 to 0xFF00 to select joypad

   115        [0x18   ;D31D                    ; jump over          

   116         0x01   ;D31E                    ; the next 8 bits

   117                                         ;D31F

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

   119         

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

   121         0x1F   ;D321      -->       

   122         0xD3   ;D322      -->  D31F     

   123 

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

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

   126         0xFF   ;D325      -->  FF00     

   127         

   128         0x18   ;D326                    ; this is the place where

   129         0x01   ;D327                    ; we will store whether

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

   131 

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

   133         0x00   ;D32A                   

   134         0xFF   ;D32B

   135 

   136         0xCB   ;D32C                    ; Test whether "down"

   137         0x5F   ;D32D                    ; is pressed.

   138 

   139         0x28   ;D32E                    ; if down is pressed,

   140         0x03   ;D32F                    ; skip the next section 

   141                                         ; of code.

   142         ;; down-is-not-pressed

   143         0xC3   ;D330

   144         0x1D   ;D331                    ; return to beginning

   145         0xD3   ;D332

   146         

   147         ;; down-is-pressed 

   148         0xEA   ;D334                    ; write A to D328 if 

   149         0x28   ;D335                    ; "down" was pressed

   150         0xD3   ;D336

   151 

   152         0xC3   ;D330

   153         0x1D   ;D331                    ; return to beginning

   154         0xD3   ;D332

   155         ])))

   156 

   157 (defn test-read-down []

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

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

   160 

   161 (defn count-frames []

   162   (-> (tick (mid-game))

   163       (IE! 0) ; disable interrupts

   164       (inject-item-assembly

   165        [0x18   ;D31D                    ; jump over          

   166         0x02   ;D31E                    ; the next 2 bytes

   167         0x00   ;D31F                    ; frame-count

   168         0x00   ;D320                    ; v-blank-prev

   169         

   170         0xFA   ;D321

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

   172         0xFF   ;D323                    ; this contains mode flags

   173         

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

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

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

   177         0x4F   ;D325                         

   178 

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

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

   181         0xD3   ;D328

   182         

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

   184         0x47   ;D32A

   185 

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

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

   188         0xD3   ;D32D

   189         ;;; in v-blank mode

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

   191            ;; increment frame-count

   192 

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

   194         0x20   ;D32F

   195         0xD3   ;D330

   196         

   197         0xCB   ;D331

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

   199 

   200         0x20   ;D333                    ; skip next section

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

   202         

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

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

   205         0x1F   ;D336

   206         0xD3   ;D337                   

   207 

   208         0x3C   ;D338                    ; inc A

   209 

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

   211         0x1F   ;D33A

   212         0xD3   ;D33B

   213 

   214            ;; set v-blank-prev to 1

   215         0x3E   ;D33C                    ; load 1 into A

   216         0x01   ;D33D                    

   217 

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

   219         0x20   ;D33F

   220         0xD3   ;D340

   221 

   222         0xC3   ;D341                   ; return to beginning

   223         0x1D   ;D342

   224         0xD3   ;D343

   225 

   226         ;;; not in v-blank mode

   227            ;; set v-blank-prev to 0

   228         0x3E   ;D344                    ; load 0 into A        

   229         0x00   ;D345

   230 

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

   232         0x20   ;D347

   233         0xD3   ;D348

   234 

   235         0xC3   ;D349                   ; return to beginning

   236         0x1D   ;D34A

   237         0xD3   ;D34B

   238         ])))

   239 

   240 (defn step-count-frames []

   241   (-> (read-down-button)

   242       (info)

   243       (tick)  ;; skip over data section

   244       (info)  

   245       (view-register "Register A" A)

   246       (tick)  ;; load-data into A

   247       (view-register "Register A" A)

   248       (info)

   249       (view-memory 0xFF00)

   250       (tick) ;; load A into 0xFF00

   251       (view-memory 0xFF00)

   252       (info)

   253       (tick)

   254       (info)

   255       (tick)

   256       (info)

   257       (tick)

   258       (info)

   259       (tick)

   260       (info)

   261       (tick)

   262       (info)

   263       (tick)

   264       (print-inventory)))

   265 

   266 (defn test-count-frames []

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

   268                         (count-frames)))

   269                0xD31F)))

   270 

   271 ;; specs for main bootstrap program

   272 ;; starts in "mode-select" mode

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

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

   275 ;;   which selects one of up to eight modes

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

   277 ;;   the next two button presses indicates the start

   278 ;;   memory location which to which the bootstrap

   279 ;;   program will write.

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

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

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

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

   284 

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

   286 ;;   written, starting at the start position.

   287 

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

   289 ;;   start address in sequence.

   290 

   291 (defn input-number-assembly []

   292   [0x18   ;D31D                    ; jump over          

   293    0x02   ;D31E                    ; the next 2 bytes

   294    0x00   ;D31F                    ; frame-count

   295    0x00   ;D320                    ; v-blank-prev

   296    

   297    0xFA   ;D321

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

   299    0xFF   ;D323                    ; this contains mode flags

   300    

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

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

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

   304    0x4F   ;D325                         

   305 

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

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

   308    0xD3   ;D328

   309    

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

   311    0x47   ;D32A

   312 

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

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

   315    0xD3   ;D32D

   316    

   317         ;;; in v-blank mode

   318 

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

   320    ;; increment frame-count

   321 

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

   323    0x20   ;D32F

   324    0xD3   ;D330

   325    

   326    0xCB   ;D331

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

   328 

   329    0x20   ;D333                    ; skip next section

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

   331    

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

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

   334    0x1F   ;D336

   335    0xD3   ;D337                   

   336 

   337    0x3C   ;D338                    ; inc A

   338 

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

   340    0x1F   ;D33A

   341    0xD3   ;D33B

   342 

   343    ;; set v-blank-prev to 1

   344    0x3E   ;D33C                    ; load 1 into A

   345    0x01   ;D33D                    

   346 

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

   348    0x20   ;D33F

   349    0xD3   ;D340

   350 

   351    0xC3   ;D341                   ; GOTO input handling code

   352    0x4E   ;D342

   353    0xD3   ;D343

   354 

   355         ;;; not in v-blank mode

   356    ;; set v-blank-prev to 0

   357    0x3E   ;D344                    ; load 0 into A        

   358    0x00   ;D345

   359 

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

   361    0x20   ;D347

   362    0xD3   ;D348

   363 

   364    0xC3   ;D349                   ; return to beginning

   365    0x1D   ;D34A

   366    0xD3   ;D34B

   367 

   368    0x00   ;D34C                   ; these are here 

   369    0x00   ;D34D                   ; for glue

   370    

   371    

   372         ;;; calculate input number based on button presses

   373    0x18   ;D34E                    ;  skip next 3 bytes

   374    0x03   ;D34F

   375                                         ;D350

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

   377                                         ;D351

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

   379    0x00   ;D352                    ;  input-number

   380 

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

   382    

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

   384    0x50   ;D354      -->       

   385    0xD3   ;D355      -->  D31F     

   386    

   387    0xEA   ;D356                    ; load (A), which is 

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

   389    0xFF   ;D358      -->  FF00     

   390 

   391    0x06   ;D359

   392                                         ;D35A

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

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

   395    0x00   ;D35C                   

   396    0xFF   ;D35D

   397 

   398    0xCB   ;D35E                    ; swap nybbles on A

   399    0x37   ;D35F

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

   401    0x47   ;D361                    ; A -> B

   402 

   403    ;; select buttons store bottom bits in C

   404    

   405    0xFA   ;                        ; load (D351) into A

   406    0x51   ;          -->       

   407    0xD3   ;          -->  D31F     

   408    

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

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

   411    0xFF   ;          -->  FF00     

   412 

   413    0x0E   ;    

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

   415 

   416    0xFA   ;                        ; (FF00) -> A

   417    0x00   ;                       

   418    0xFF   ;    

   419    

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

   421    0x4F   ;                        ; A -> C

   422 

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

   424    0x79   ;                        ; C -> A

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

   426    0x2F   ;                        ; negate A

   427 

   428    0xEA   ;                        ; store A into input-number

   429    0x52   ;

   430    0xD3   ;

   431 

   432    0xC3   ;                        ; return to beginning

   433    0x1D   ;    

   434    0xD3   ;    

   435    ])

   436 

   437 (defn input-number []

   438   (-> (tick (mid-game))

   439       (IE! 0) ; disable interrupts

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

   441   

   442 (defn test-input-number

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

   444   []

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

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

   447 

   448 (defn write-memory-assembly []

   449  

   450   [

   451    ;; Main Timing Loop

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

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

   454    

   455    0x18   ; D31D                  ; Variable declaration

   456    0x02   ; D31E                   

   457    0x00   ; D31F                  ; frame-count

   458    0x00   ; D320                  ; v-blank-prev 

   459 

   460    0xFA   ; D321                  ; load v-blank mode flags into A

   461    0x41   ; D322                  

   462    0xFF   ; D323                  

   463 

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

   465    ;; bits in A are "01"

   466    0xCB   ; D324                  

   467    0x4F   ; D325                  

   468 

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

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

   471    0xD3   ; D328                  

   472 

   473    0xCB   ; D329                  

   474    0x47   ; D32A                  

   475 

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

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

   478    0xD3   ; D32D                  

   479 

   480    ;; V-Blank

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

   482 

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

   484    0x20   ; D32F                  

   485    0xD3   ; D330                  

   486 

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

   488    0x00   ; D332                                              \

   489                                   ;                           |

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

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

   492    0x01   ; D334                                              | 

   493                                   ;                           |

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

   495    0x20   ; D336                                              |

   496    0xD3   ; D337                                              |

   497                                   ;                           /

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

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

   500    0x46   ; D339                  ;   was 0, 

   501    0xD3   ; D33A                  ; GOTO state-machine

   502 

   503    0xC3   ; D33B                  

   504    0x1D   ; D33C                  

   505    0xD3   ; D33D                  ; GOTO beginning

   506    ;; END V-blank

   507 

   508    ;; Non-V-Blank

   509    ;;   Set v-blank-prev to 0

   510    0x3E   ; D33E                  ; load 0 into A

   511    0x00   ; D33F                  

   512 

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

   514    0x20   ; D341                  

   515    0xD3   ; D342

   516    

   517    0xC3   ; D343                  

   518    0x1D   ; D344                  

   519    0xD3   ; D345                  ; GOTO beginning

   520    ;; END Not-V-Blank

   521 

   522    

   523    ;; Main State Machine -- Input Section

   524    ;;   This is called once every frame.

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

   526    ;;   state transitions.

   527 

   528    ;; Increment frame-count

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

   530    0x1F   ; D347                  

   531    0xD3   ; D348

   532    

   533    0x3C   ; D349                  ; inc A

   534 

   535    0xEA   ; D34A                  

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

   537    0xD3   ; D34C

   538 

   539    0x00   ; D34D                  ; glue :)

   540 

   541 

   542    ;;;;;;;;;  BEGIN RLM DEBUG

   543    ;;0xC3 ;; jump to beginning

   544    ;;0x1D

   545    ;;0xD3

   546    ;;;;;;;;;  END RLM DEBUG

   547 

   548    

   549    0x18   ;D34E                    ;  skip next 3 bytes

   550    0x03   ;D34F

   551           ;D350

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

   553           ;D351

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

   555    0x00   ;D352                    ;  input-number

   556 

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

   558    

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

   560    0x50   ;D354      -->       

   561    0xD3   ;D355      -->  D350     

   562    

   563    0xEA   ;D356                    ; load (A), which is 

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

   565    0xFF   ;D358      -->  FF00     

   566 

   567    0x06   ;D359

   568           ;D35A

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

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

   571    0x00   ;D35C                   

   572    0xFF   ;D35D

   573 

   574    0xCB   ;D35E                    ; swap nybbles on A

   575    0x37   ;D35F

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

   577    0x47   ;D361                    ; A -> B

   578 

   579    ;; select buttons; store bottom bits in C

   580    

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

   582    0x51   ;D363      -->       

   583    0xD3   ;D364      -->  D351     

   584    

   585    0xEA   ;D365                    ; load (A), which is 

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

   587    0xFF   ;D367      -->  FF00     

   588 

   589    0x0E   ;D368

   590           ;D369

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

   592 

   593    0xFA   ;D36A                    ; (FF00) -> A

   594    0x00   ;D36B                   

   595    0xFF   ;D36C

   596    

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

   598    0x4F   ;D36E                    ; A -> C

   599 

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

   601    0x79   ;D36F                    ; C -> A

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

   603    0x2F   ;D371                    ; negate A

   604 

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

   606    0x52   ;D373

   607    0xD3   ;D374

   608 

   609    0x00   ;D375                  

   610    0x00   ;D376

   611    0x00   ;D377

   612    0x00   ;D378

   613    0x00   ;D379

   614    0x00   ;D37A

   615    0x00   ;D37B                   ; these are here because 

   616    0x00   ;D37C                   ; I messed up :(

   617    0x00   ;D37D

   618    0x00   ;D37E

   619    0x00   ;D37F

   620    

   621    ;; beginning of main state machine   

   622    0x18   ;D380                    ; Declaration of variables

   623    0x05   ;D381                    ;  5 variables:

   624    0x00   ;D382                    ;    current-mode

   625    0x00   ;D383                    ;    bytes-to-write

   626    0x00   ;D384                    ;    start-point

   627    0x00   ;D385                    ;    unused

   628    0x00   ;D386                    ;    unused

   629 

   630 

   631    ;; banch on current mode

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

   633    0x82   ;D388                    ; into A

   634    0xD3   ;D389

   635    0x00   ;D38A

   636 

   637 

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

   639    0xFE   ;D38B

   640    0x00   ;D38C                    ; compare A with 0x00

   641 

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

   643    0xA8   ;D38E

   644    0xD3   ;D38F

   645 

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

   647    0xFE   ;D390

   648    0x01   ;D391                    ; compare A with 0x01

   649 

   650    0xCA   ;D392                  

   651    0xB1   ;D393 

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

   653 

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

   655    0xFE   ;D395                    

   656    0x02   ;D396                    ; compare A with 0x02

   657 

   658    0xCA   ;D397

   659    0xBF   ;D398

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

   661 

   662    0x00   ;D39A

   663    0x00   ;D39B

   664    0x00   ;D39C

   665    0x00   ;D39D

   666    0x00   ;D39E

   667    0x00   ;D39F

   668    0x00   ;D3A0

   669    0x00   ;D3A1

   670    0x00   ;D3A2

   671    0x00   ;D3A3

   672    0x00   ;D3A4

   673    ;; End of Mode checking, goto beginning

   674    0xC3   ;D3A5

   675    0x1D   ;D3A6

   676    0xD3   ;D3A7

   677 

   678 

   679    ;; Mode 0 -- input-mode mode

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

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

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

   683 

   684    ;;   set current-mode to input-number

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

   686    0x52   ;D3A9                    ; into A

   687    0xD3   ;D3AA

   688 

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

   690    0x82   ;D3AC                    ; (0xD382)

   691    0xD3   ;D3AD

   692 

   693    0xC3   ;D3AE                    ; go back to beginning

   694    0x1D   ;D3AF

   695    0xD3   ;D3B0

   696    ;; End Mode 0

   697 

   698 

   699    ;; Mode 1 -- set-length mode

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

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

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

   703    ;;      completes.

   704 

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

   706    ;;      set current-mode to 0x02.

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

   708    0x52   ;D3B2                   ; into A

   709    0xD3   ;D3B3

   710    

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

   712    0x83   ;D3B5                   ; (0xD383)

   713    0xD3   ;D3B6

   714 

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

   716    0x02   ;D3B8

   717    

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

   719    0x82   ;D3BA                   ; advancing from Mode 1 to 

   720    0xD3   ;D3BB                   ; Mode 2

   721    

   722    0xC3   ;D3BC                   ; go back to beginning

   723    0x1D   ;D3BD

   724    0xD3   ;D3BE

   725    ;; End Mode 1

   726 

   727 

   728    ;; Mode 2 -- set start-point mode

   729    ;;      Final part of the header for writing things to memory.

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

   731    ;;      data will be written.

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

   733 

   734    ;;      Set start-point to input-number;

   735    ;;      set current mode to 0x03.

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

   737    0x52   ;D3C0                   ; into A

   738    0xD3   ;D3C1

   739 

   740    0xEA   ;D3C2                   ; load A into start-point

   741    0x84   ;D3C3                   ; (0xD384)

   742    0xD3   ;D3C4

   743 

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

   745    0x03   ;D3C6

   746 

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

   748    0x82   ;D3C8                   ; advancing from Mode 2 to 

   749    0xD3   ;D3C9                   ; Mode 3.

   750    

   751    0xC3   ;D3CA                   ; go back to beginning

   752    0x1D   ;D3CB

   753    0xD3   ;D3CC

   754    ;;End Mode 2

   755    

   756    0x00   ;D3CD

   757    0x00   ;D3CE

   758    0x00   ;D3CF

   759    0x00   ;D3D0

   760    0x00   ;D3D1

   761    0x00   ;D3D2

   762    0x00   ;D3D3

   763    0x00   ;D3D4

   764    0x00   ;D3D5

   765    0x00   ;D3D6

   766 

   767    ;; Mode 3 -- write bytes mode

   768    ;;      This is where RAM manipulation happens.

   769    ;;      User supplies bytes every frame, which are written

   770    ;;      sequentially to 

   771 

   772 

   773 

   774 

   775    0xC3   ;                        ; Complete Loop

   776    0x1D   ;    

   777    0xD3   ;    

   778 

   779    

   780    

   781    ])

   782 

   783 

   784 

   785 (def frame-count 0xD31F)

   786 (def input 0xD352)

   787 (def current-mode 0xD382)

   788 (def bytes-to-write 0xD383)

   789 (def start-point 0xD384)

   790 

   791 

   792 (defn write-memory []

   793   (-> (tick (mid-game))

   794       (IE! 0) ; disable interrupts

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

   796 

   797 (defn test-write-memory []

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

   799   (dorun

   800    (dotimes [_ 5000]

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

   802 

   803 (def bytes-to-write 0xD383)

   804 (def start-point 0xD384)

   805 

   806 (defn test-mode-2 []

   807   (->

   808    (write-memory)

   809    (view-memory frame-count)

   810    (step)

   811    (step [:a])

   812    (step [:b])

   813    (step [:start])

   814    (step [])

   815    (view-memory frame-count)))

   816 

   817 (defn test-mode-2 []

   818   (->

   819    (write-memory)

   820    (view-memory current-mode)

   821    (step [])

   822    (step [])

   823    (step [])

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

   825    (view-memory current-mode)

   826    (step [:a])

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

   828    (view-memory current-mode)

   829    (view-memory bytes-to-write)

   830    (view-memory start-point)

   831    (#(do (println "step with [:u :d :l :r]")%))

   832    (step [:u :d])

   833    (view-memory current-mode)

   834    (view-memory bytes-to-write)

   835    (view-memory start-point)

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

   837    (step [:u :d])

   838    (view-memory current-mode)

   839    (view-memory bytes-to-write)

   840    (view-memory start-point)

   841 

   842    ))

   843 

   844
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 17 Mar 2012 01:23:47 -0500
parents	c9a280b8bd1c
children	d2e00c923bad