(ns com.aurellem.gb.rlm-assembly

   "Version of main bootstrap program that is valid output for the

    item-writer program."

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

   (:use (com.aurellem.run bootstrap-1))

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

 

 ;; Specs for Main Bootstrap Program

 

 ;; Number-Input

 ;; Number input works using all eight buttons to

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

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

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

 

 ;;; MODE-SELECT

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

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

 ;;   on which buttons are pressed:

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

 ;;       8   [:start]      :  WRITE-BYTES

 ;;    0xFF   (all-buttons) :  JUMP

 

 ;;; WRITE-BYTES

 

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

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

 ;;   header of three bytes describing what to write:

 

 ;;    Byte 0  : Number of Bytes to Write

 ;;    Byte 1  : Start Address High Byte

 ;;    Byte 1  : Start Address Low  Byte

 

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

 ;;   they are written to the start address in

 ;;   sequence. After the last byte is written control

 ;;   returns to MODE-SELECT mode.

 

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

 ;;   address 0xC01F enter

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

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

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

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

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

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

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

 

 ;;; JUMP 

 ;;   JUMP mode jumps program control to any arbitray

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

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

 ;;   address to which you want to jump.

 ;;    Byte 0  : Jump Address High Byte

 ;;    Byte 1  : Jump Address Low  Byte

 

 ;;   Example: to jump to address 0x1234 enter

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

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

 

 

 (defn ->signed-8-bit [n]

   (if (< n 0)

     (+ 256 n) n))

 

 (defn frame-metronome []

   (let [timing-loop

         [0x01 ; \

          0x43 ; |

          0xFE ; |  load 0xFF44 into BC without repeats

          0x0C ; |

          0x04 ; /

          0x0A]   ;; (BC) -> A, now A = LY (vertical line coord)

         continue-if-144

         [0xFE

          144     ;; compare LY (in A) with 144

          0x20    ;; jump back to beginning if LY != 144 (not-v-blank)

          (->signed-8-bit

           (+ -4 (- (count timing-loop))))]

         spin-loop

         [0x05 ;; dec B, which is 0xFF

          0x20 ;; spin until B==0

          0xFD]]

     (concat timing-loop continue-if-144 spin-loop)))

 

 (defn test-frame-metronome

   "Ensure that frame-metronome ticks exactly once every frame."

   ([] (test-frame-metronome 151))

   ([steps]

      (let [inc-D [0x14 0x18

                   (->signed-8-bit

                    (+ -3 (- (count (frame-metronome)))))]

            program (concat (frame-metronome) inc-D)

            count-frames

            (-> (tick (mid-game))

                (IE! 0)

                (DE! 0)

                (set-memory-range pokemon-list-start program)

                (PC! pokemon-list-start))

            D-after-moves (D (run-moves count-frames (repeat steps [])))]

        (println "D:" D-after-moves) 

        (assert (= steps D-after-moves))

 

        (println "D =" D-after-moves "after" steps "steps")

        count-frames)))

 

 (defn read-user-input []

   [0x01 ;\

    0x01 ;|

    0xFE ;|  load 0xFF00 into BC without repeats

    0x04 ;|

    0x0D ;/

 

    0x3E

    (Integer/parseInt "00100000" 2) ; prepare to measure d-pad

 

    0x02 

    0x0A ;; get D-pad info

 

    0xE6 ;; select bottom bits of A

    0x0F

 

    0xCB

    0x37 ;; swap A nybbles

    

    0x57 ;; A->D

 

    0x3E

    (Integer/parseInt "00010000" 2) ; prepare to measure buttons

 

    0x02

    0x0A ;; get button info

    

    0xE6

    0x0F ;; select bottom bits of A

 

    0xB2 ;; combine together into A

    0x2F ;; (NOT A) -> A

    ])

 

 (defn test-read-user-input []

   (let [program

         (concat

          (frame-metronome) (read-user-input)

          [0x5F ;; A-> E

           0x18

           (->signed-8-bit

            (+ (- (count (frame-metronome)))

               (- (count (read-user-input)))

               (- 3)))])

         read-input

         (-> (tick (mid-game))

             (IE! 0)

             (set-memory-range pokemon-list-start program)

             (PC! pokemon-list-start))]

     (dorun

      (for [i (range 0x100)]

        (assert (= (E (step read-input (buttons i))) i))))

     (println "Tested all inputs.")

     read-input))

 

         

 

 (defn main-bootstrap-program [start-address]

   (let [[start-high start-low] (disect-bytes-2 start-address)

         ]

     ))

 

         

      

       

   

 

         

     

 

 

 ;;;;;; TESTS ;;;;;;

 

 (defn bootstrap-base []

   (let [program (main-bootstrap-program pokemon-list-start)]

     ;; make sure program is valid output for item-writer

     (bootstrap-pattern program)

     (-> (tick (mid-game))

         (set-memory-range pokemon-list-start program)

         (PC! pokemon-list-start))))

 

 (defn test-write-bytes-mode []

   (let [target-address 0xC00F

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

         assembly [0xF3 0x18 0xFE 0x12]

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

                                  target-address (+ target-address 20))

         before (bootstrap-base)

         after

         (-> before

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

             (step [])                       ; at the beginning.

             (step [])                      

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

             (step (buttons 4))              ; write 4 bytes

             (step (buttons target-high))

             (step (buttons target-low))

             (step (buttons (nth assembly 0)))

             (step (buttons (nth assembly 1)))

             (step (buttons (nth assembly 2)))

             (step (buttons (nth assembly 3)))

             (step [])

             (step [])

             (step []))]

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

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

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

     after))

 

 (defn test-jump-mode []

   (let [target-address 0xC00F

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

         post-jump

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

             (step [])

             (step [])

             (step [])

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

             (step (buttons target-high))

             (step (buttons target-low)))

         program-counters

         (capture-program-counter 

          post-jump

          10000)]

     (println program-counters)

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

     post-jump))