(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 [init [0x06 155] ;; init B to out of LY range

         timing-loop

         [0x47    ;; A->B

          

          0x26 

          0xFE    ;; load FF into H without repeats

          0x24

          

          0x2E

          0x43    ;; load 44 into L without repeats

          0x2C

 

          0x7E]   ;; (HL) -> A, now A = LY (vertical line coord)

         continue-if-different

         [0xB8    ;; compare A with B

          0x28

          (->signed-8-bit

           (+ -3 (- (count timing-loop))))

          ]

         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))

              (- (count continue-if-different))))]]

 

     (concat init timing-loop continue-if-different continue-if-144)))

 

 

 (defn test-frame-metronome

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

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

   ([steps]

      (let [inc-C [0x0C 0x18

                   (->signed-8-bit

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

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

            count-frames

            (-> (tick (mid-game))

                (IE! 0)

                (BC! 0)

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

                (PC! pokemon-list-start))

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

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

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

 

        (println "C =" steps "after" steps "steps")

        count-frames)))

 

 (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))