(ns com.aurellem.run.util

   (:use (com.aurellem.gb util gb-driver vbm characters saves))

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

 

 (def ↑ [:u])

 (def ↓ [:d])

 (def ← [:l])

 (def → [:r])

 

 [↑ ↓ ← →]

 

 (defn do-nothing [n script]

   (->> script

        (play-moves

         (repeat n []))))

 

 (defn first-difference

   [base alt difference-metric [moves root :as script]]

   (loop [branch-point root

          actions (vec moves)]

     (let [base-branch (step branch-point base)

           base-val (difference-metric base-branch)

           alt-branch (step branch-point alt)

           alt-val (difference-metric alt-branch)]

       (if (not= base-val alt-val)

         [(conj actions alt) alt-branch]

         (recur base-branch (conj actions base))))))

 

 (defn repeat-until-different

   [buttons metric [moves root :as script]]

   (let [baseline (metric root)]

     (loop [actions (vec moves)

            state root]

       (let [new-state (step state buttons)

             new-actions (conj actions buttons)]

         (if (not= (metric new-state) baseline)

           [new-actions new-state]

           (recur new-actions new-state))))))

 

 (defn binary-search [metric]

   (loop [low 0

          high 1]

     (let [low-val (metric low)

           high-val (metric high)]

       (println "(" low high ")")

       (cond

        ;; base case

        (and (= low (dec high))

             (not= low-val high-val))

        high

        ;; exponential growth

        (= high-val low-val)

        (recur high (* high 2))

        

        ;; binary search

        (not= low-val high-val)

        (let [test (int (/ (+ low high) 2))

              test-val (metric test)]

          (if (= test-val low-val)

            (recur test high)

            (recur low test)))))))

 

 

 (defn delayed-difference

   "determine the shortest sequence of the form:

 

    sequence = (concat (repeat n base) alt)

     which will cause difference-metric

    to yield a different value between.

 

    (concat sequence (repeat delay base))

    and

    (repeat (+ n 1 delay base))

 

    This search function is good for finding the optimum keypresses

    whose effect on the game is not revealed until several frames after

    those keys have been pressed (such as scrolling text)."

   [base alt delay difference-metric [moves root :as script]]

   (let [states-cache (atom {})

         generator 

         ;; (memoize  ;; 32947 msecs

         ;;  (fn gen [n] 

         ;;    (run-moves

         ;;     root

         ;;     (repeat n base))))

 

         (fn gen [n]  ;; 21150 msecs

           (if (= 0 n)

             root

             (if-let [cached (@states-cache n)]

               cached

               (do (swap!

                    states-cache

                    #(assoc % n

                            (run-moves

                             (gen (dec n))

                             [base])))

                   (gen n)))))

             

         len

         (binary-search

          (memoize

           (fn [n]

             (if (= n 0) true

                 (=(difference-metric

                    (run-moves

                     (generator n)

                     (concat [alt] (repeat delay base))))

                   (difference-metric

                     (generator (+ n 1 delay))))))))

         new-moves (concat moves (repeat len base) [alt])

         new-state (run-moves (generator len) [alt])]

     [new-moves new-state]))

 

 (def x-position-address 0xD361)

 (def y-position-address 0xD362)

 

 (defn x-position

   ([^SaveState state]

      (aget (memory state) x-position-address))

   ([] (x-position @current-state)))

 

 (defn y-position

   ([^SaveState state]

      (aget (memory state) y-position-address))

   ([] (y-position @current-state)))

 

 (defn move

   [dir script]

   (let [current-position-fn

         (cond (#{← →} dir) x-position

               (#{↑ ↓} dir) y-position)]

     (repeat-until-different dir current-position-fn script)))

   

 (defn walk 

   "Move the character along the given directions."

   [directions script]

   (reduce (fn [script dir]

             (move dir script)) script directions))

 

 (defn search-string

   ([^SaveState state string]

      (let [codes

            (str->character-codes string)

            codes-length (count codes)

            mem (vec (memory state))

            mem-length (count mem)]

        (loop [idx 0]

          (if (< (- mem-length idx) codes-length)

            nil

            (if (= (subvec mem idx (+ idx codes-length))

                   codes)

              idx

              (recur (inc idx)))))))

   ([string]

      (search-string @current-state string)))

 

 (def text-address 0x9DC1)

 

 (defn displayed-text

   ([^SaveState state]

      (character-codes->str

       (subvec (vec (memory state))

               (+ text-address 0)

               (+ text-address  90))))

   ([] (displayed-text @current-state)))

 

 (defn scroll-text

   ([script]

      (delayed-difference

       [:b] [:a :b] 25 displayed-text script))

   ([n script]

      (reduce (fn [script _]

                (scroll-text script))

              script

              (range n))))

 

 (defn end-text

   ([script]

      (->>

       script

       (do-nothing 150)

       (play-moves [[:b]]))))

 

 (defn delayed-improbability-search

   "insert blank frames before calling script-fn until

    metric returns true."

   [delay metric script-fn script]

   (loop [blanks 0]

     (let [new-script

           (->> script

                (play-moves

                 (concat (repeat blanks [])))

                script-fn)

           future-state

           (run-moves (second new-script)

                      (repeat delay []))

           result (metric future-state)]

       (if result

         (do

           (println "improbability factor:" blanks)

           new-script)

         (recur (inc blanks))))))

 

 (defn critical-hit

   "Put the cursor over the desired attack. This program will

    determine the appropriate amount of blank frames to

    insert before pressing [:a] to ensure that the attack is

    a critical hit."

   [script]

   (delayed-improbability-search

    400

    #(search-string  % "Critical")

    (partial play-moves [[:a][]])

    script))

 

 (defn move-thru-grass

   [direction script]

   (delayed-improbability-search

    600

    #(nil? (search-string % "Wild"))

    (partial move direction)

    script))

 

 (defn walk-thru-grass

   [directions script]

   (reduce (fn [script direction]

             (move-thru-grass direction script))

           script directions))

 

 (defn slowly

   [delay moves script]

   (reduce

    (fn [script move]

      (->> script

           (do-nothing delay)

           (play-moves (vector move))))

    script moves))

 

 (defn multiple-times

   ([n command args script]

      (reduce (fn [script _]

                (apply command (concat args [script])))

              script

              (range n)))

   ([n command script]

      (multiple-times n command [] script)))

 

 (defn write-script!

   [[moves state :as script] name]

   [(write-moves! moves name)

    (write-state! state name)])

 

 (defn read-script

   [name]

   [(read-moves name)

    (read-state name)])