Mercurial > vba-clojure

     1 (ns com.aurellem.gb.assembly

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

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

     4 

     5 (defn inject-assembly

     6   ([^SaveState state

     7    program-counter registers

     8    assembly-code]

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

    10     ;; inject assembly code

    11     (dorun (map (fn [index val]

    12                   (aset scratch-memory index val))

    13                 (range program-counter

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

    15                 assembly-code))

    16     (-> state

    17         (write-memory! scratch-memory)

    18         (write-registers! registers)

    19         (PC! program-counter)))))

    20 

    21 (defn inject-item-assembly

    22   ([^SaveState state assembly-code]

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

    24                       (registers state)

    25                       assembly-code))

    26   ([assembly-code]

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

    28 

    29 (defn run-assembly

    30   ([info-fn assembly n]

    31      (let [final-state

    32            (reduce (fn [state _]

    33                      (tick (info-fn state)))

    34                    (inject-item-assembly

    35                      (mid-game) assembly)

    36                    (range n))]

    37        final-state))

    38   ([assembly n]

    39      (run-assembly d-tick assembly n)))

    40 

    41 (def buttons-port 0xFF00)

    42 

    43 (defn trace [state]

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

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

    46     (let [frame-boundary?

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

    48       (if frame-boundary?

    49         [program-counters opcodes]

    50         (recur

    51          (conj program-counters

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

    53          (conj opcodes

    54                (aget (memory @current-state)

    55                      (PC @current-state))))))))

    56 

    57 (defn print-trace [state n]

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

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

    60                 (take n program-counters)

    61                 (take n opcodes)))))

    62 

    63 (defn good-trace []

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

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

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

    67       (d-tick) (tick) (d-tick) (tick) (d-tick)))

    68 

    69 (defn read-down-button []

    70   (-> (tick (mid-game))

    71       (IE! 0) ; disable interrupts

    72       (inject-item-assembly

    73        ;; write 00010000 to 0xFF00 to select joypad

    74        [0x18   ;D31D                    ; jump over          

    75         0x01   ;D31E                    ; the next 8 bits

    76                                         ;D31F

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

    78         

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

    80         0x1F   ;D321      -->       

    81         0xD3   ;D322      -->  D31F     

    82 

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

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

    85         0xFF   ;D325      -->  FF00     

    86         

    87         0x18   ;D326                    ; this is the place where

    88         0x01   ;D327                    ; we will store whether

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

    90 

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

    92         0x00   ;D32A                   

    93         0xFF   ;D32B

    94 

    95         0xCB   ;D32C                    ; Test whether "down"

    96         0x5F   ;D32D                    ; is pressed.

    97 

    98         0x28   ;D32E                    ; if down is pressed,

    99         0x03   ;D32F                    ; skip the next section 

   100                                         ; of code.

   101         ;; down-is-not-pressed

   102         0xC3   ;D330

   103         0x1D   ;D331                    ; return to beginning

   104         0xD3   ;D332

   105         

   106         ;; down-is-pressed 

   107         0xEA   ;D334                    ; write A to D328 if 

   108         0x28   ;D335                    ; "down" was pressed

   109         0xD3   ;D336

   110 

   111         0xC3   ;D330

   112         0x1D   ;D331                    ; return to beginning

   113         0xD3   ;D332

   114         ])))

   115 

   116 (defn test-read-down []

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

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

   119 

   120 (defn count-frames []

   121   (-> (tick (mid-game))

   122       (IE! 0) ; disable interrupts

   123       (inject-item-assembly

   124        [0x18   ;D31D                    ; jump over          

   125         0x02   ;D31E                    ; the next 2 bytes

   126         0x00   ;D31F                    ; frame-count

   127         0x00   ;D320                    ; v-blank-prev

   128         

   129         0xFA   ;D321

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

   131         0xFF   ;D323                    ; this contains mode flags

   132         

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

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

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

   136         0x4F   ;D325                         

   137 

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

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

   140         0xD3   ;D328

   141         

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

   143         0x47   ;D32A

   144 

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

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

   147         0xD3   ;D32D

   148         ;;; in v-blank mode

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

   150            ;; increment frame-count

   151 

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

   153         0x20   ;D32F

   154         0xD3   ;D330

   155         

   156         0xCB   ;D331

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

   158 

   159         0x20   ;D333                    ; skip next section

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

   161         

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

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

   164         0x1F   ;D336

   165         0xD3   ;D337                   

   166 

   167         0x3C   ;D338                    ; inc A

   168 

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

   170         0x1F   ;D33A

   171         0xD3   ;D33B

   172 

   173            ;; set v-blank-prev to 1

   174         0x3E   ;D33C                    ; load 1 into A

   175         0x01   ;D33D                    

   176 

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

   178         0x20   ;D33F

   179         0xD3   ;D340

   180 

   181         0xC3   ;D341                   ; return to beginning

   182         0x1D   ;D342

   183         0xD3   ;D343

   184 

   185         ;;; not in v-blank mode

   186            ;; set v-blank-prev to 0

   187         0x3E   ;D344                    ; load 0 into A        

   188         0x00   ;D345

   189 

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

   191         0x20   ;D347

   192         0xD3   ;D348

   193 

   194         0xC3   ;D349                   ; return to beginning

   195         0x1D   ;D34A

   196         0xD3   ;D34B

   197         ])))

   198 

   199 (defn step-count-frames []

   200   (-> (read-down-button)

   201       (d-tick)

   202       (tick)  ;; skip over data section

   203       (d-tick)  

   204       (view-register "Register A" A)

   205       (tick)  ;; load-data into A

   206       (view-register "Register A" A)

   207       (d-tick)

   208       (view-memory 0xFF00)

   209       (tick) ;; load A into 0xFF00

   210       (view-memory 0xFF00)

   211       (d-tick)

   212       (tick)

   213       (d-tick)

   214       (tick)

   215       (d-tick)

   216       (tick)

   217       (d-tick)

   218       (tick)

   219       (d-tick)

   220       (tick)

   221       (d-tick)

   222       (tick)

   223       (print-inventory)))

   224 

   225 (defn test-count-frames []

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

   227                         (count-frames)))

   228                0xD31F)))

   229 

   230 ;; specs for main bootstrap program

   231 ;; starts in "mode-select" mode

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

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

   234 ;;   which selects one of up to eight modes

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

   236 ;;   the next two button presses indicates the start

   237 ;;   memory location which to which the bootstrap

   238 ;;   program will write.

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

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

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

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

   243 

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

   245 ;;   written, starting at the start position.

   246 

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

   248 ;;   start address in sequence.

   249 

   250 (defn input-number-assembly []

   251   [0x18   ;D31D                    ; jump over          

   252    0x02   ;D31E                    ; the next 2 bytes

   253    0x00   ;D31F                    ; frame-count

   254    0x00   ;D320                    ; v-blank-prev

   255    

   256    0xFA   ;D321

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

   258    0xFF   ;D323                    ; this contains mode flags

   259    

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

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

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

   263    0x4F   ;D325                         

   264 

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

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

   267    0xD3   ;D328

   268    

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

   270    0x47   ;D32A

   271 

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

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

   274    0xD3   ;D32D

   275    

   276         ;;; in v-blank mode

   277 

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

   279    ;; increment frame-count

   280 

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

   282    0x20   ;D32F

   283    0xD3   ;D330

   284    

   285    0xCB   ;D331

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

   287 

   288    0x20   ;D333                    ; skip next section

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

   290    

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

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

   293    0x1F   ;D336

   294    0xD3   ;D337                   

   295 

   296    0x3C   ;D338                    ; inc A

   297 

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

   299    0x1F   ;D33A

   300    0xD3   ;D33B

   301 

   302    ;; set v-blank-prev to 1

   303    0x3E   ;D33C                    ; load 1 into A

   304    0x01   ;D33D                    

   305 

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

   307    0x20   ;D33F

   308    0xD3   ;D340

   309 

   310    0xC3   ;D341                   ; GOTO input handling code

   311    0x4E   ;D342

   312    0xD3   ;D343

   313 

   314         ;;; not in v-blank mode

   315    ;; set v-blank-prev to 0

   316    0x3E   ;D344                    ; load 0 into A        

   317    0x00   ;D345

   318 

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

   320    0x20   ;D347

   321    0xD3   ;D348

   322 

   323    0xC3   ;D349                   ; return to beginning

   324    0x1D   ;D34A

   325    0xD3   ;D34B

   326 

   327    0x00   ;D34C                   ; these are here 

   328    0x00   ;D34D                   ; for glue

   329    

   330    

   331         ;;; calculate input number based on button presses

   332    0x18   ;D34E                    ;  skip next 3 bytes

   333    0x03   ;D34F

   334                                         ;D350

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

   336                                         ;D351

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

   338    0x00   ;D352                    ;  input-number

   339 

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

   341    

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

   343    0x50   ;D354      -->       

   344    0xD3   ;D355      -->  D31F     

   345    

   346    0xEA   ;D356                    ; load A, which is 

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

   348    0xFF   ;D358      -->  FF00     

   349 

   350    0x06   ;D359

   351                                         ;D35A

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

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

   354    0x00   ;D35C                   

   355    0xFF   ;D35D

   356 

   357    0xCB   ;D35E                    ; swap nybbles on A

   358    0x37   ;D35F

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

   360    0x47   ;D361                    ; A -> B

   361 

   362    ;; select buttons store bottom bits in C

   363    

   364    0xFA   ;                        ; load (D351) into A

   365    0x51   ;          -->       

   366    0xD3   ;          -->  D31F     

   367    

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

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

   370    0xFF   ;          -->  FF00     

   371 

   372    0x0E   ;    

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

   374 

   375    0xFA   ;                        ; (FF00) -> A

   376    0x00   ;                       

   377    0xFF   ;    

   378    

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

   380    0x4F   ;                        ; A -> C

   381 

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

   383    0x79   ;                        ; C -> A

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

   385    0x2F   ;                        ; negate A

   386 

   387    0xEA   ;                        ; store A into input-number

   388    0x52   ;

   389    0xD3   ;

   390 

   391    0xC3   ;                        ; return to beginning

   392    0x1D   ;    

   393    0xD3   ;    

   394    ])

   395 

   396 

   397 

   398 (defn input-number []

   399   (-> (tick (mid-game))

   400       (IE! 0) ; disable interrupts

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

   402   

   403 (defn test-input-number

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

   405   []

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

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

   408 

   409 

   410 

   411 

   412 

   413 

   414 (defn write-memory-assembly*

   415   "A program for altering in-game memory by pressing buttons."

   416   []

   417   [

   418    0xF3 ; stop interrupts

   419    ;; --------- CLEANUP

   420    0xAF ; zero A  [D31E]

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

   422    

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

   424    0xF1 ;; pop AF (vblank prev) [D320]

   425 

   426    0x2F ;; invert A

   427    0x4F ;; A -> C

   428    

   429    0xF0 ;; copy STAT into A

   430    0x41

   431 

   432    0x47 ;; A->B

   433    0x1F ;; rotate A right

   434    0x2F ;; complement A

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

   436    

   437    0xF5 ;; push AF (vbprev)

   438    

   439    0xA1 ;; A & C --> A. Now A_0 contains "increment?"

   440    

   441    0xCB ;; test A_0. this result will be used twice.

   442    0x47

   443    

   444    0x28 ;; end frame (JUMP) if A_0 = 0.  

   445    0xF3 ;; TODO: set jump length

   446    

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

   448    

   449         ;; btw, Z bit is now 1

   450         ;; prepare to select bits

   451  

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

   453    0x20

   454    

   455    0x06 ;; load 0x00 into B

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

   457 

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

   459    0x00

   460    

   461    0xF0 ;; load A from [FF00]

   462    0x00

   463 

   464    0xE6 ;; bitmask 00001111

   465    0x0F

   466    

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

   468 

   469    0x28 ;; JUMP forward if Z=0

   470    0x08

   471 

   472    0x47 ;; A -> B

   473    0xCB ;; swap B nybbles

   474    0x30 

   475    

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

   477    0x10

   478 

   479    0xBF ;; compare(A,A) sets Z=0

   480    

   481    0x18 ;; JUMP back to "load A into [FF00]"

   482    0xEF

   483 

   484 

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

   486 

   487    ;; "input mode"

   488    ;; mode 0x00 : select mode

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

   490    ;; mode 0x10 : select hi-bit

   491    ;; mode 0x18 : select lo-bit

   492 

   493    ;; "output mode"

   494    ;; mode 0x20 : write bytes

   495    ;; mode 0xFF : jump PC

   496 

   497 

   498    ;; registers

   499    ;; D : mode select

   500    ;; E : count of bytes to write

   501    ;; H : address-high

   502    ;; L : address-low

   503    

   504    ;; now A contains the pressed keys

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

   506    

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

   508 

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

   510    0x6A

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

   512    0x13 ; JUMP

   513    

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

   515    0x42

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

   517    0x01

   518 

   519    ;; output mode I: moving the program counter

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

   521 

   522    ;; output mode II: writing bytes

   523    0xAF ; zero A

   524    0xBB ; compare count to zero. finished writing?

   525    0x28 ; if we are finished, jump back to cleanup

   526    0x00 ; TODO: set jump length backwards.

   527    

   528    ;; continue writing bytes

   529    0x78 ;; B->A

   530    0x22 ;; copy A to (HL) and increment HL. 

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

   532    0xB6 ;; JUMP

   533 

   534 

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

   536    

   537    ;; i/p mode

   538    ;; adhere to the mode discipline:

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

   540 

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

   542    0x57

   543    0x82 ;; add the mode to A

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

   545    0x74

   546    0xD3

   547 

   548    0x3E ;; load the constant 8 into A

   549    0x08

   550    0x82 ;; add the mode to A

   551    

   552    0x57 ;; store the incremented mode into D

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

   554    

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

   556 

   557    0x18 ;; end frame

   558    0xA8 ;; JUMP

   559    ]

   560   )

   561 

   562 (defn write-mem-dyl []

   563   (-> (tick (mid-game))

   564       (IE! 0)

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

   566 

   567 (defn ntick [s n]

   568   (if (zero? n) s

   569       (do

   570         (set-state! s)

   571         (dorun (dotimes [_ n] 

   572                  (com.aurellem.gb.Gb/tick)))

   573         (update-state))))

   574 

   575 

   576 (defn find-frame-shift [state]

   577   ;;(restart!)

   578   (set-state! state)

   579   (loop [n 0]

   580     (if (>= (first (registers)) 0xD32D)

   581       (do (println n)

   582       (update-state))

   583       (do

   584         (com.aurellem.gb.Gb/tick)

   585         (recur (inc n) )))))

   586   

   587 (defn demo-assembly [n]

   588   (repeat n 0x00))

   589 

   590 

   591 (defn find-frame-shift* [state]

   592   (set-state! state)

   593   (loop []

   594     (com.aurellem.gb.Gb/tick)

   595     ;;(println (first (registers)))

   596     (if (>= (first (registers)) 0xD32D)

   597       (update-state)

   598       (recur))))

   599 

   600 

   601 (defn dylan**

   602   ([k]

   603   (->

   604    (tick (mid-game))

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

   606    ;;(find-frame-shift)

   607    (ntick k)

   608    (d-tick)

   609    (view-register "A" A)

   610    (view-register "B" B)

   611    (view-register "D" D)

   612    (view-register "E" E)

   613    (view-register "F" F)

   614    (#(do (println) %))

   615    ))

   616   ([] (dylan** 0)))

   617    

   618    

   619 

   620 

   621 (defn dylan* []

   622   (->

   623    (write-mem-dyl)

   624 

   625    (tick)

   626    (tick)

   627    (tick)

   628    (tick)

   629    (tick)

   630    (tick)

   631    (tick)

   632    (tick)

   633    (tick)

   634    (tick)

   635    (tick)

   636    (tick)

   637    (tick)

   638    (tick)

   639    (tick)

   640    (tick)

   641    (tick)

   642    (tick)

   643    (tick)

   644    (tick)

   645    (tick)

   646    (tick)

   647    (tick)

   648    (tick)

   649    (tick)

   650    (tick)

   651    (tick)

   652    (tick)

   653    (tick)

   654    (tick)

   655    (tick)

   656    (tick)

   657    (tick)

   658    (tick)

   659    (tick)

   660    (tick)

   661 

   662    ;;(view-memory 0xD374)

   663    (tick)

   664    (tick)

   665    (tick)

   666    (tick)

   667    (tick)

   668    (tick)

   669    (tick)

   670    (tick)

   671    (tick)

   672    (tick)

   673    (tick)

   674    (tick)

   675    (tick)

   676    (tick)

   677    (tick)

   678    ;;(view-memory 0xD374)

   679    (d-tick)

   680 

   681    (view-register "A" A)

   682    (view-register "B" B)

   683    (view-register "C" C))

   684 

   685 )

   686 

   687 

   688 (defn dylan []

   689   (->

   690    (write-mem-dyl)

   691    (tick)

   692    (tick)

   693    (tick)

   694    (tick)

   695    (tick)

   696    (tick)

   697    (tick)

   698    (tick)

   699    (tick)

   700    (tick)

   701    (tick)

   702    (tick)

   703    (tick)

   704    (tick)

   705    (tick) ;; first loop

   706 

   707 

   708    (tick)

   709    (tick)

   710    (tick)

   711    (tick)

   712    (tick)

   713    (tick)

   714    (tick)

   715    (tick)

   716    (tick)

   717    (tick)

   718    (tick)

   719    (tick)

   720    (tick) ;; dpad bits

   721 

   722    (tick)

   723    (tick)

   724    (tick)

   725    (tick)

   726    (tick)

   727    (tick)

   728    (tick)

   729    (tick)

   730    (d-tick)

   731    

   732 

   733    

   734    (view-register "A" A)

   735    (view-register "B" B)

   736    (view-register "C" C)

   737    

   738    ))

   739 

   740 

   741 

   742 

   743 (defn d2 []

   744   (->

   745    (write-mem-dyl)

   746    (view-memory 0xD31F)

   747    step step step step step

   748    (view-memory 0xD31F)))

   749 

   750 

   751 

   752 

   753 

   754 

   755 

   756 

   757 

   758 

   759 

   760 

   761 

   762 

   763 

   764 

   765 

   766 

   767 

   768 

   769 (defn write-memory-assembly []

   770   [

   771    ;; Main Timing Loop

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

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

   774     

   775    0x18   ; D31D                  ; Variable declaration

   776    0x02   ; D31E                   

   777    0x00   ; D31F                  ; frame-count

   778    0x00   ; D320                  ; v-blank-prev 

   779    

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

   781    0x41

   782    0x00

   783 

   784 

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

   786    ;; bits in A are "01"

   787    0xCB   ; D324                  

   788    0x4F   ; D325                  

   789 

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

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

   792    0xD3   ; D328                  

   793 

   794    0xCB   ; D329                  

   795    0x47   ; D32A                  

   796 

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

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

   799    0xD3   ; D32D                  

   800 

   801    ;; V-Blank

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

   803 

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

   805    0x20   ; D32F                  

   806    0xD3   ; D330                  

   807 

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

   809    0x00   ; D332                                              \

   810                                   ;                           |

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

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

   813    0x01   ; D334                                              | 

   814                                   ;                           |

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

   816    0x20   ; D336                                              |

   817    0xD3   ; D337                                              |

   818                                   ;                           /

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

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

   821    0x46   ; D339                  ;   was 0, 

   822    0xD3   ; D33A                  ; GOTO state-machine

   823 

   824    0xC3   ; D33B                  

   825    0x1D   ; D33C                  

   826    0xD3   ; D33D                  ; GOTO beginning

   827    ;; END V-blank

   828 

   829    ;; Non-V-Blank

   830    ;;   Set v-blank-prev to 0

   831    0x3E   ; D33E                  ; load 0 into A

   832    0x00   ; D33F                  

   833 

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

   835    0x20   ; D341                  

   836    0xD3   ; D342

   837    

   838    0xC3   ; D343                  

   839    0x1D   ; D344                  

   840    0xD3   ; D345                  ; GOTO beginning

   841    ;; END Not-V-Blank

   842 

   843    

   844    ;; Main State Machine -- Input Section

   845    ;;   This is called once every frame.

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

   847    ;;   state transitions.

   848 

   849    ;; Increment frame-count

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

   851    0x1F   ; D347                  

   852    0xD3   ; D348

   853    

   854    0x3C   ; D349                  ; inc A

   855 

   856    0xEA   ; D34A                  

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

   858    0xD3   ; D34C

   859 

   860    0x00   ; D34D                  ; glue :)

   861    

   862    0x18   ;D34E                    ;  skip next 3 bytes

   863    0x03   ;D34F

   864           ;D350

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

   866           ;D351

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

   868    0x00   ;D352                    ;  input-number

   869 

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

   871    

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

   873    0x50   ;D354      -->       

   874    0xD3   ;D355      -->  D350     

   875    

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

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

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

   879 

   880    0x06   ;D359

   881           ;D35A

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

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

   884    0x00   ;D35C                   

   885    0x00   ;D35D                    ;; NO-OP

   886 

   887    0xCB   ;D35E                    ; swap nybbles on A

   888    0x37   ;D35F

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

   890    0x47   ;D361                    ; A -> B

   891 

   892    ;; select buttons; store bottom bits in C

   893    

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

   895    0x51   ;D363      -->       

   896    0xD3   ;D364      -->  D351     

   897    

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

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

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

   901 

   902    0x0E   ;D368

   903           ;D369

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

   905 

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

   907    0x00   ;D36B                   

   908    0x00   ;D36C

   909    

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

   911    0x4F   ;D36E                    ; A -> C

   912 

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

   914    0x79   ;D36F                    ; C -> A

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

   916    0x2F   ;D371                    ; negate A

   917 

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

   919    0x52   ;D373

   920    0xD3   ;D374

   921 

   922    0x00   ;D375                  

   923    0x00   ;D376

   924    0x00   ;D377

   925    0x00   ;D378

   926    0x00   ;D379

   927    0x00   ;D37A

   928    0x00   ;D37B                   ; these are here because 

   929    0x00   ;D37C                   ; I messed up :(

   930    0x00   ;D37D

   931    0x00   ;D37E

   932    0x00   ;D37F

   933    

   934    ;; beginning of main state machine   

   935    0x18   ;D380                    ; Declaration of variables

   936    0x05   ;D381                    ;  5 variables:

   937    0x00   ;D382                    ;    current-mode

   938    0x00   ;D383                    ;    bytes-to-write

   939    0x00   ;D384                    ;    bytes-written

   940    0x00   ;D385                    ;    start-point-high

   941    0x00   ;D386                    ;    start-point-low

   942 

   943 

   944    ;; banch on current mode

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

   946    0x82   ;D388                    ; into A

   947    0xD3   ;D389

   948    0x00   ;D38A

   949 

   950 

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

   952    0xFE   ;D38B

   953    0x00   ;D38C                    ; compare A with 0x00

   954 

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

   956    0xA8   ;D38E

   957    0xD3   ;D38F

   958 

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

   960    0xFE   ;D390

   961    0x01   ;D391                    ; compare A with 0x01

   962 

   963    0xCA   ;D392                  

   964    0xB1   ;D393 

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

   966 

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

   968    0xFE   ;D395                    

   969    0x02   ;D396                    ; compare A with 0x02

   970 

   971    0xCA   ;D397

   972    0xBF   ;D398

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

   974 

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

   976    0xFE   ;D39A

   977    0x03   ;D39B

   978 

   979    0xCA   ;D39C

   980    0xCD   ;D39D

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

   982 

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

   984    0xFE   ;D39F

   985    0x04   ;D3A0

   986 

   987    0xCA   ;D3A1

   988    0xDB   ;D3A2

   989    0xD3   ;D3A3

   990 

   991    0x00   ;D3A4

   992    ;; End of Mode checking, goto beginning

   993    0xC3   ;D3A5

   994    0x1D   ;D3A6

   995    0xD3   ;D3A7

   996 

   997 

   998    ;; Mode 0 -- input-mode mode

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

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

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

  1002 

  1003    ;;   set current-mode to input-number

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

  1005    0x52   ;D3A9                    ; into A

  1006    0xD3   ;D3AA

  1007 

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

  1009    0x82   ;D3AC                    ; (0xD382)

  1010    0xD3   ;D3AD

  1011 

  1012    0xC3   ;D3AE                    ; go back to beginning

  1013    0x1D   ;D3AF

  1014    0xD3   ;D3B0

  1015    ;; End Mode 0

  1016 

  1017 

  1018    ;; Mode 1 -- set-length mode

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

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

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

  1022    ;;      completes.

  1023 

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

  1025    ;;      set current-mode to 0x02.

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

  1027    0x52   ;D3B2                   ; into A

  1028    0xD3   ;D3B3

  1029    

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

  1031    0x83   ;D3B5                   ; (0xD383)

  1032    0xD3   ;D3B6

  1033 

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

  1035    0x02   ;D3B8

  1036    

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

  1038    0x82   ;D3BA                   ; advancing from Mode 1 to 

  1039    0xD3   ;D3BB                   ; Mode 2

  1040    

  1041    0xC3   ;D3BC                   ; go back to beginning

  1042    0x1D   ;D3BD

  1043    0xD3   ;D3BE

  1044    ;; End Mode 1

  1045 

  1046 

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

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

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

  1050    ;;      data will be written.

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

  1052 

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

  1054    ;;      set current mode to 0x03.

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

  1056    0x52   ;D3C0                   ; into A

  1057    0xD3   ;D3C1

  1058 

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

  1060    0x85   ;D3C3                   ; (0xD385)

  1061    0xD3   ;D3C4

  1062 

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

  1064    0x03   ;D3C6

  1065 

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

  1067    0x82   ;D3C8                   ; advancing from Mode 2 to 

  1068    0xD3   ;D3C9                   ; Mode 3.

  1069    

  1070    0xC3   ;D3CA                   ; go back to beginning

  1071    0x1D   ;D3CB

  1072    0xD3   ;D3CC

  1073    ;;End Mode 2

  1074 

  1075 

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

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

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

  1079 

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

  1081    ;;      set current mode to 0x04

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

  1083    0x52   ;D3CE                   

  1084    0xD3   ;D3CF                   

  1085 

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

  1087    0x86   ;D3D1                   

  1088    0xD3   ;D3D2                   

  1089 

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

  1091    0x04   ;D3D4                   

  1092 

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

  1094    0x82   ;D3D6                   ; advancing from Mode 3 to 

  1095    0xD3   ;D3D7                   ; Mode 4.

  1096 

  1097    0xC3   ;D3D8                   ; go back to beginning

  1098    0x1D   ;D3D9                   

  1099    0xD3   ;D3DA                   

  1100    

  1101    ;; Mode 4 -- write bytes mode

  1102 

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

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

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

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

  1107 

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

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

  1110   

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

  1112    0x83   ;D3DC

  1113    0xD3   ;D3DD

  1114 

  1115    0x47   ;D3DE                   ; load A into B

  1116 

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

  1118    0x84   ;D3E0

  1119    0xD3   ;D3E1

  1120 

  1121    0xB8   ;D3E2                   ; compare A with B

  1122 

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

  1124    0x07   ;D3E4                   

  1125    0xD4   ;D3E5                   

  1126 

  1127    ;;  Write Memory Section

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

  1129    ;;    into the current target register, determined by

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

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

  1132    

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

  1134    0x85   ;D3E7                   

  1135    0xD3   ;D3E8                   

  1136 

  1137    0x67   ;D3E9                   ; load A into H

  1138 

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

  1140    0x86   ;D3EB                   

  1141    0xD3   ;D3EC

  1142    

  1143    0x6F   ;D3ED                   ; load A into L

  1144    

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

  1146    0x84   ;D3EF                   

  1147    0xD3   ;D3F0                   

  1148    

  1149    0x00   ;D3F1                   ; These are here because

  1150    0x00   ;D3F2                   ; I screwed up again.

  1151    0x00   ;D3F3                   

  1152 

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

  1154    0x6F   ;D3F5                   

  1155 

  1156    0x30   ;D3F6                   ; If the addition overflowed,

  1157    0x01   ;D3F7                   

  1158    0x24   ;D3F8                   ; increment H.

  1159 

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

  1161    

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

  1163    0x52   ;D3FA                   

  1164    0xD3   ;D3FB                   

  1165 

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

  1167 

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

  1169    0x84   ;D3FE                   

  1170    0xD3   ;D3FF                   

  1171 

  1172    0x3C   ;D400                   ; increment A

  1173 

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

  1175    0x84   ;D402                   

  1176    0xD3   ;D403

  1177 

  1178    0xC3   ;D404                   ; go back to beginning.

  1179    0x1D   ;D405

  1180    0xD3   ;D406

  1181    ;;  End Write Memory Section

  1182 

  1183    ;;  Mode 4 Cleanup Section

  1184    ;;    reset bytes-written to 0

  1185    ;;    set mode to 0

  1186    0x3E   ;D407                   ; load 0 into A

  1187    0x00   ;D408                  

  1188 

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

  1190    0x84   ;D40A                   

  1191    0xD3   ;D40B                   

  1192 

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

  1194    0x82   ;D40D                   

  1195    0xD3   ;D40E                   

  1196 

  1197    0xC3   ;D40F                    ; go back to beginning

  1198    0x1D   ;D410

  1199    0xD3   ;D411

  1200 

  1201    ;; End Mode 4

  1202    

  1203    ])

  1204 

  1205 

  1206 

  1207 (def frame-count 0xD31F)

  1208 (def input 0xD352)

  1209 (def current-mode      0xD382)

  1210 (def bytes-to-write    0xD383)

  1211 (def bytes-written     0xD384)

  1212 (def start-point-high  0xD385)

  1213 (def start-point-low   0xD386)

  1214 

  1215 

  1216 

  1217 (defn write-memory []

  1218   (-> (tick (mid-game))

  1219       (IE! 0) ; disable interrupts

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

  1221 

  1222 (defn test-write-memory []

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

  1224   (dorun

  1225    (dotimes [_ 5000]

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

  1227 

  1228 (def bytes-to-write 0xD383)

  1229 (def start-point 0xD384)

  1230 

  1231 (defn print-blank-assembly

  1232   [start end]

  1233   (dorun

  1234    (map

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

  1236     (range start end))))

  1237 

  1238 (defn test-mode-2 []

  1239   (->

  1240    (write-memory)

  1241    (view-memory frame-count)

  1242    (step)

  1243    (step [:a])

  1244    (step [:b])

  1245    (step [:start])

  1246    (step [])

  1247    (view-memory frame-count)))

  1248 

  1249 

  1250 

  1251 (defn dylan-test-mode

  1252   ([] (dylan-test-mode (write-mem-dyl)))

  1253   ([target-state]

  1254      (let [

  1255            v-blank-prev 54046

  1256            btn-register 65280

  1257            eggs 0xD374

  1258            ]

  1259        

  1260        (->

  1261         target-state

  1262         

  1263         (tick)

  1264         (tick)

  1265         (tick)

  1266         (tick);; jumps back to beginning

  1267         

  1268         (tick)

  1269         (tick)

  1270         (tick)

  1271         (tick)

  1272         (tick)

  1273         (tick)

  1274         (tick)

  1275         (tick)

  1276         (tick)

  1277         (tick)

  1278         (tick)

  1279         (tick)

  1280 

  1281                

  1282         (tick)

  1283         (tick)

  1284         (tick)

  1285         (tick)

  1286         (tick)

  1287         (tick)

  1288         (tick)

  1289         (tick)

  1290         (tick)

  1291         (tick)

  1292         (tick)

  1293         (tick)

  1294         (tick)

  1295         (tick)

  1296         (tick)

  1297         (tick)

  1298         (tick)

  1299         (tick)

  1300         (tick)

  1301         (tick)

  1302         (tick) ;; just complemented A

  1303 

  1304         (tick)

  1305         (DE! 0x1800)

  1306         (AF! 0x7700) ;; change inputs @ A

  1307         (tick)

  1308         (tick)

  1309         (tick)

  1310         (tick)

  1311         (tick)

  1312 

  1313         ;;(view-memory eggs)

  1314         (tick)

  1315         (tick)

  1316         ;;(view-memory eggs)

  1317         (tick)

  1318         (tick)

  1319         (tick)

  1320         (tick)

  1321         (tick)

  1322         (tick)

  1323         (d-tick)

  1324 

  1325         

  1326         ;;(view-memory btn-register) 

  1327         (view-register "A" A)

  1328         (view-register "B" B)

  1329         

  1330         ;;(view-register "C" C)

  1331         (view-register "D" D)

  1332         (view-register "E" E)

  1333         (view-register "H" H)

  1334         (view-register "L" L)

  1335         ))))

  1336   

  1337 

  1338 

  1339 (defn drive-dylan []

  1340   (-> (write-mem-dyl)

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

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

  1343       (step [])

  1344       (step [])

  1345       (step [])

  1346       (step [:start])

  1347       (step [:select])

  1348       (step [:u :d])

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

  1350       (step [:a])

  1351       (step [:b])

  1352       (step [:a :b])

  1353       (step [:select])

  1354       (step [])

  1355       (step [])

  1356       (step [])

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

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

  1359       ))

  1360 

  1361 (defn test-mode-4

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

  1363   ([target-state]

  1364      (->

  1365       target-state

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

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

  1368       (view-memory current-mode)

  1369       (step [])

  1370       (step [])

  1371       (step [])

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

  1373       (view-memory current-mode)

  1374 

  1375       ;; Activate memory writing mode

  1376       

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

  1378       (step [:a])

  1379       (view-memory current-mode)

  1380       (view-memory bytes-to-write)

  1381       (view-memory start-point-high)

  1382       (view-memory start-point-low)

  1383 

  1384       ;; Specify four bytes to be written

  1385       

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

  1387       (step [:select])

  1388       (view-memory current-mode)

  1389       (view-memory bytes-to-write)

  1390       (view-memory start-point-high)

  1391       (view-memory start-point-low)

  1392 

  1393       ;; Specify target memory address as 0xC00F

  1394       

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

  1396       (step [:u :d])

  1397       (view-memory current-mode)

  1398       (view-memory bytes-to-write)

  1399       (view-memory start-point-high)

  1400       (view-memory start-point-low)

  1401 

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

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

  1404       (view-memory current-mode)

  1405       (view-memory bytes-to-write)

  1406       (view-memory start-point-high)

  1407       (view-memory start-point-low)

  1408 

  1409       ;; Start reprogramming memory

  1410 

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

  1412       (step [:a])

  1413       (view-memory current-mode)

  1414       (view-memory bytes-written)

  1415 

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

  1417       (step [:b])

  1418       (view-memory current-mode)

  1419       (view-memory bytes-written)

  1420 

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

  1422       (step [:a :b])

  1423       (view-memory current-mode)

  1424       (view-memory bytes-written)

  1425 

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

  1427       (step [:select])

  1428       (view-memory current-mode)

  1429       (view-memory bytes-written)

  1430 

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

  1432 

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

  1434       (step [])

  1435       (view-memory current-mode)

  1436       (view-memory bytes-written)

  1437       

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

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

  1440 

  1441 

  1442 

  1443 

  1444 

  1445 

  1446 ;;; ASSEMBLY-READING UTILITIES

  1447 

  1448 (def opcodes

  1449   [

  1450    "NOP"

  1451    "LD BC,nn"

  1452    "LD (BC),A"

  1453    "INC BC"

  1454    "INC B"

  1455    "DEC B"

  1456    "LD B,n"

  1457    "RLC A"

  1458    "LD (nn),SP"

  1459    "ADD HL,BC"

  1460    "LD A,(BC)"

  1461    "DEC BC"

  1462    "INC C"

  1463    "DEC C"

  1464    "LD C,n"

  1465    "RRC A"

  1466 

  1467    "STOP"

  1468    "LD DE,nn"

  1469    "LD (DE),A"

  1470    "INC DE"

  1471    "INC D"

  1472    "DEC D"

  1473    "LD D,n"

  1474    "RL A"

  1475    "JR n"

  1476    "ADD HL,DE"

  1477    "LD A,(DE)"

  1478    "DEC DE"

  1479    "INC E"

  1480    "DEC E"

  1481    "LD E,n"

  1482    "RR A"

  1483 

  1484    "JR NZ,n"

  1485    "LD HL,nn"

  1486    "LDI (HL),A"

  1487    "INC HL"

  1488    "INC H"

  1489    "DEC H"

  1490    "LD H,n"

  1491    "DAA"

  1492    "JR Z,n"

  1493    "ADD HL,HL"

  1494    "LDI A,(HL)"

  1495    "DEC HL"

  1496    "INC L"

  1497    "DEC L"

  1498    "LD L,n"

  1499    "CPL"

  1500 

  1501    "JR NC,n"

  1502    "LD SP,nn"

  1503    "LDD (HL),A"

  1504    "INC SP"

  1505    "INC (HL)"

  1506    "DEC (HL)"

  1507    "LD (HL),n"

  1508    "SCF"

  1509    "JR C,n"

  1510    "ADD HL,SP"

  1511    "LDD A,(HL)"

  1512    "DEC SP"

  1513    "INC A"

  1514    "DEC A"

  1515    "LD A,n"

  1516    "CCF"

  1517 

  1518    "LD B,B"

  1519    "LD B,C"

  1520    "LD B,D"

  1521    "LD B,E"

  1522    "LD B,H"

  1523    "LD B,L"

  1524    "LD B,(HL)"

  1525    "LD B,A"

  1526    "LD C,B"

  1527    "LD C,C"

  1528    "LD C,D"

  1529    "LD C,E"

  1530    "LD C,H"

  1531    "LD C,L"

  1532    "LD C,(HL)"

  1533    "LD C,A"

  1534 

  1535    "LD D,B"

  1536    "LD D,C"

  1537    "LD D,D"

  1538    "LD D,E"

  1539    "LD D,H"

  1540    "LD D,L"

  1541    "LD D,(HL)"

  1542    "LD D,A"

  1543    "LD E,B"

  1544    "LD E,C"

  1545    "LD E,D"

  1546    "LD E,E"

  1547    "LD E,H"

  1548    "LD E,L"

  1549    "LD E,(HL)"

  1550    "LD E,A"

  1551 

  1552    "LD H,B"

  1553    "LD H,C"

  1554    "LD H,D"

  1555    "LD H,E"

  1556    "LD H,H"

  1557    "LD H,L"

  1558    "LD H,(HL)"

  1559    "LD H,A"

  1560    "LD L,B"

  1561    "LD L,C"

  1562    "LD L,D"

  1563    "LD L,E"

  1564    "LD L,H"

  1565    "LD L,L"

  1566    "LD L,(HL)"

  1567    "LD L,A"

  1568 

  1569    "LD (HL),B"

  1570    "LD (HL),C"

  1571    "LD (HL),D"

  1572    "LD (HL),E"

  1573    "LD (HL),H"

  1574    "LD (HL),L"

  1575    "HALT"

  1576    "LD (HL),A"

  1577    "LD A,B"

  1578    "LD A,C"

  1579    "LD A,D"

  1580    "LD A,E"

  1581    "LD A,H"

  1582    "LD A,L"

  1583    "LD A,(HL)"

  1584    "LD A,A"

  1585 

  1586    "ADD A,B"

  1587    "ADD A,C"

  1588    "ADD A,D"

  1589    "ADD A,E"

  1590    "ADD A,H"

  1591    "ADD A,L"

  1592    "ADD A,(HL)"

  1593    "ADD A,A"

  1594    "ADC A,B"

  1595    "ADC A,C"

  1596    "ADC A,D"

  1597    "ADC A,E"

  1598    "ADC A,H"

  1599    "ADC A,L"

  1600    "ADC A,(HL)"

  1601    "ADC A,A"

  1602 

  1603    "SUB A,B"

  1604    "SUB A,C"

  1605    "SUB A,D"

  1606    "SUB A,E"

  1607    "SUB A,H"

  1608    "SUB A,L"

  1609    "SUB A,(HL)"

  1610    "SUB A,A"

  1611    "SBC A,B"

  1612    "SBC A,C"

  1613    "SBC A,D"

  1614    "SBC A,E"

  1615    "SBC A,H"

  1616    "SBC A,L"

  1617    "SBC A,(HL)"

  1618    "SBC A,A"

  1619 

  1620    "AND B"

  1621    "AND C"

  1622    "AND D"

  1623    "AND E"

  1624    "AND H"

  1625    "AND L"

  1626    "AND (HL)"

  1627    "AND A"

  1628    "XOR B"

  1629    "XOR C"

  1630    "XOR D"

  1631    "XOR E"

  1632    "XOR H"

  1633    "XOR L"

  1634    "XOR (HL)"

  1635    "XOR A"

  1636 

  1637    "OR B"

  1638    "OR C"

  1639    "OR D"

  1640    "OR E"

  1641    "OR H"

  1642    "OR L"

  1643    "OR (HL)"

  1644    "OR A"

  1645    "CP B"

  1646    "CP C"

  1647    "CP D"

  1648    "CP E"

  1649    "CP H"

  1650    "CP L"

  1651    "CP (HL)"

  1652    "CP A"

  1653 

  1654    "RET NZ"

  1655    "POP BC"

  1656    "JP NZ,nn"

  1657    "JP nn"

  1658    "CALL NZ,nn"

  1659    "PUSH BC"

  1660    "ADD A,n"

  1661    "RST 0"

  1662    "RET Z"

  1663    "RET"

  1664    "JP Z,nn"

  1665    "Ext ops"

  1666    "CALL Z,nn"

  1667    "CALL nn"

  1668    "ADC A,n"

  1669    "RST 8"

  1670 

  1671    "RET NC"

  1672    "POP DE"

  1673    "JP NC,nn"

  1674    "XX"

  1675    "CALL NC,nn"

  1676    "PUSH DE"

  1677    "SUB A,n"

  1678    "RST 10"

  1679    "RET C"

  1680    "RETI"

  1681    "JP C,nn"

  1682    "XX"

  1683    "CALL C,nn"

  1684    "XX"

  1685    "SBC A,n"

  1686    "RST 18"

  1687 

  1688    "LDH (n),A"

  1689    "POP HL"

  1690    "LDH (C),A"

  1691    "XX"

  1692    "XX"

  1693    "PUSH HL"

  1694    "AND n"

  1695    "RST 20"

  1696    "ADD SP,d"

  1697    "JP (HL)"

  1698    "LD (nn),A"

  1699    "XX"

  1700    "XX"

  1701    "XX"

  1702    "XOR n"

  1703    "RST 28"

  1704 

  1705    "LDH A,(n)"

  1706    "POP AF"

  1707    "XX"

  1708    "DI"

  1709    "XX"

  1710    "PUSH AF"

  1711    "OR n"

  1712    "RST 30"

  1713    "LDHL SP,d"

  1714    "LD SP,HL"

  1715    "LD A,(nn)"

  1716    "EI"

  1717    "XX"

  1718    "XX"

  1719    "CP n"

  1720    "RST 38"])

  1721 

  1722 

  1723 (defn hex

  1724   "Converts the number into a hexadecimal-formatted symbol."

  1725   [n]

  1726   (symbol (str "0x" (.toUpperCase (Integer/toHexString n)))))

  1727 

  1728 

  1729 

  1730 (defn arity

  1731   "Returns the arity of the given opcode (hex numeral)."

  1732   [op]

  1733   (cond

  1734     (#{0x06 0x0E 0x16 0x1E

  1735        0x20 0x26 0x28 0x2E

  1736        0x30 0x36 0x38 0x3E

  1737        0xC6 0xD6 0xCE 0xDE

  1738        0xE0 0xF0 0xE6 0xF6

  1739        0xEE 0xFE} op)

  1740     1

  1741     (#{0x01 0x08 0x11 0x21

  1742        0x31 0xC2 0xC3 0xC4

  1743        0xCA 0xDA 0xCC 0xDC

  1744        0xCD 0xEA 0xFA} op)

  1745     2

  1746     :else

  1747     0))
author	Robert McIntyre <rlm@mit.edu>
date	Fri, 23 Mar 2012 02:41:22 -0500
parents	d585b91de06c
children	19fd38fe376e