(ns com.aurellem.world.practice

   (:use (com.aurellem.gb saves util constants gb-driver vbm items

   assembly characters))

   (:use (com.aurellem.run title save-corruption))

   ;;(:use (com.aurellem.exp pokemon))

   (:use (com.aurellem.exp item-bridge))

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

   

   )

 

 (def hex-pc (comp hex PC))

 

 (defn nstep [state n]

   (if (zero? n) state

       (recur (step state) (dec n))))

 

 

 (defn view-memory* [state start length]

   ((comp vec map)

    #((comp  aget) (memory state) %)

    (range start (+ start length))))

 

 

 (defn state-surprise

   "This is one tick before the trainer goes [!]"

   []

   (->

    (pre-trainer-battle)

    (step [:r])

    (step)

    (ntick 88147)

    ;(step [:r])

 

    ;(step [:r])

    ;(step [:r])

    ;(step [:r])

    ;(step [:r])

    ))

 (defn state-inject

   "I have replaced the letter e with e-acute @ 0xC4E8."

   []

   (read-state "inject-surprise"))

 

 

 

 

 (defn pc-trail

   "Track the PC for a number of ticks."

   [state ticks]

   (tick state)

   (set-state! state)

   (loop [pcs [(PC)] ]

     (if (> (count pcs) ticks) pcs

         (do

           (com.aurellem.gb.Gb/tick)

           (recur (conj pcs (PC)))))))

 

 

 

 (defn differences [list-1 list-2]

   (remove

    (fn [[a b c]] (= b c))

    (map vector

         (range)

         list-1

         list-2)))

 

 (defn pc-diff [state-1 state-2]

   (differences (map hex (pc-trail state-1 10000))

                (map hex (pc-trail state-2 10000))))

 

 

 (defn memory-diff [state-1 state-2]

   (remove

   (fn[[a b c]] (= b c))

   (map (comp vec (partial map hex) list)

        (range)

        (vec (memory state-1))

        (vec (memory state-2)))

    )

   )

 

 

 

 (defn state-speak

   "This is when the trainer speaks."

   []

   (->

    (pre-trainer-battle)

    (set-memory 0xD354 0x0)

    (step [:r])

    (step)

    (ntick 88147)

    (tick)

    (nstep 102)

 

    ;(step [:r])

 

    ;(step [:r])

    ;(step [:r])

    ;(step [:r])

    ;(step [:r])

    ))

   

   

 

 (defn get-memory [state n]

   (aget (memory state) n))

 

 (defn first-change

   "Watch the current memory location as it ticks,

 return the first state that differs at location mem." 

   [state n]

   (tick state)

   (set-state! state)

   (let [init (aget (memory state) n)]

     (loop []

       (if (= (aget (memory) n) init)

         (do

           (com.aurellem.gb.Gb/tick)

           (recur))))

     (update-state)))

 

 

 

 (defn spell [state mem n]

   (print (character-codes->str

           (take n (drop mem

                         (vec(memory state)))))))

 

 

 (do

   (println)

   (print (character-codes->str (take 6000 (drop 0xA75F4

                                                (vec(com.aurellem.gb.gb-driver/rom))))))

   )

 

 ;(dorun (map println (view-memory* (state-surprise)  0x1AEF 1600)))

 

 

 

 (def surprise-words

   [0x80 0xAB 0xAB 0x7F 0xB1 0xA8 0xA6 0xA7 0xB3 0xE7 0x7F 0x8B 0xA4 0xB3 0xE0 0xB2 0x7F 0xB1 0xAE 0xAB 0xAB 0x7F 0xB3 0xA7 0xA4 0x7F 0xA3 0xA8 0xA2 0xA4 0xE7])

 

 (defn sublist

   "Unshifts the list until the sublist is at the start."

   [list sub]

   (cond

     (empty? sub) list

     (empty? list) nil

     (= (take (count sub) list) sub) list

     :else (recur (rest list) sub)))

 

 (defn subloc

   "Returns the position of the first occurence of sublist."

   [list sub]

   (loop [n 0 a list]

     (cond

       (empty? a) nil

       (= (take (count sub) a) sub) n

       :else (recur (inc n) (rest a)))))

 

 

 

 

 (defn change-speech

   ([state str k]

      (loop [ops str

             s state

             n k]

        (if (empty? ops) s

            (recur

             (rest ops)

             (set-memory (first-change s (+ 0xC4B9 n)) (+ 0xC4B9 n)

                         (first ops))

             (if (not= n 19) (inc n)

                 (+ n 21))))))

   ([str k]

      (change-speech (state-speak) str k))

   ([str]

      (change-speech str 0))

        

          

     

       

   )