(ns com.aurellem.gb-driver

   (:import com.aurellem.gb.Gb)

   (:import java.io.File)

   (:import org.apache.commons.io.FileUtils)

   (:import (java.nio IntBuffer ByteOrder)))

 

 (Gb/loadVBA)

 

 (def ^:dynamic *max-history* 2e4)

 

 (def ^:dynamic *backup-saves-to-disk* true)

 

 (def ^:dynamic *save-history* true)

 

 (def ^:dynamic *save-state-cache*

   (File. "/home/r/proj/pokemon-escape/save-states/"))

 

 (def yellow-rom-image

   (File. "/home/r/proj/pokemon-escape/roms/yellow.gbc"))

 

 (def yellow-save-file

   (File. "/home/r/proj/pokemon-escape/roms/yellow.sav"))

 

 (def current-frame (atom 0))

 

 (defn vba-init []

   (reset! current-frame 0)

   (.delete yellow-save-file)

   (Gb/startEmulator (.getCanonicalPath yellow-rom-image)))

 

 (defn shutdown [] (Gb/shutdown))

 

 (defn reset [] (shutdown) (vba-init))

 

 (defn cpu-data [size arr-fn]

   (let [store (int-array size)]

     (fn [] (arr-fn store) store)))

 

 (def ram

   (cpu-data (Gb/getRAMSize) #(Gb/getRAM %)))

 

 (def rom 

   (cpu-data (Gb/getROMSize) #(Gb/getROM %)))

 

 (def working-ram 

   (cpu-data Gb/WRAM_SIZE #(Gb/getWRAM %)))

 

 (def video-ram 

   (cpu-data Gb/VRAM_SIZE #(Gb/getVRAM %)))

 

 (def registers

   (cpu-data Gb/NUM_REGISTERS #(Gb/getRegisters %)))

 

 (def button-code

   {;; main buttons

    :a         0x0001

    :b         0x0002

 

    ;; directional pad

    :r         0x0010

    :l         0x0020

    :u         0x0040

    :d         0x0080

 

    ;; meta buttons

    :select    0x0004

    :start     0x0008

 

    ;; hard reset -- not really a button

    :reset   0x0800})

 

 (defn button-mask [buttons]

   (reduce bit-or 0x0000 (map button-code buttons)))

 

 (defn buttons [mask]

   (loop [buttons []

          masks (seq button-code)]

     (if (empty? masks) buttons

         (let [[button value] (first masks)]

           (if (not= 0x0000 (bit-and value mask))

             (recur (conj buttons button) (rest masks))

             (recur buttons (rest masks)))))))

 

 (defrecord SaveState [frame save-data])

 

 (defn frame [] @current-frame)

 

 (defn save-state []

   (SaveState. (frame) (Gb/saveState)))

 

 (defn load-state [#^SaveState save]

   (reset! current-frame (:frame save))

   (Gb/loadState (:save-data save)))

 

 (def empty-history (sorted-map))

 

 (def history (atom empty-history))

 

 (defn frame->disk-save [frame]

   (File. *save-state-cache*

          (format "%07d.sav" frame)))

 

 (defn get-save-from-disk [frame]

   (let [save (frame->disk-save frame)]

     (if (.exists save)

       (let [buf (Gb/saveBuffer)

             bytes (FileUtils/readFileToByteArray save)]

         (.put buf bytes)

         (.flip buf)

         (SaveState. frame buf)))))

 

 (defn store-save-to-disk [^SaveState save]

   (let [buf (:save-data save)

         bytes (byte-array (.limit buf))

         dest (frame->disk-save (:frame save))]

     (.get buf bytes)

     (FileUtils/writeByteArrayToFile dest bytes)

     (.rewind buf) dest))

 

 (defn find-save-state [frame]

   (let [save (@history frame)]

     (if (not (nil? save)) save

         (get-save-from-disk frame))))

 

 (defn goto [frame]

   (let [save (find-save-state frame)]

     (if (nil? save)

       (println frame "is not in history")

       (do

         (reset! current-frame frame)

         (load-state save)))))

 

 (defn clear-history [] (reset! history empty-history))

 

 (defn rewind

   ([] (rewind 1))

   ([n] (goto (- @current-frame n))))

 

 (defn backup-state

   ([] (backup-state (frame)))

   ([frame]

   (let [save (save-state)]

     (swap! history #(assoc % frame save))

     ;;(store-save-to-disk save)

     (if (> (count @history) *max-history*)

       (swap! history #(dissoc % (first (first %))))))))

 

 (defn advance []

   (if *save-history*

     (backup-state @current-frame))

   (swap! current-frame inc))

 

 (defn step

   ([] (advance) (Gb/step))

   ([mask-or-buttons]

      (advance)

      (if (number? mask-or-buttons)

        (Gb/step mask-or-buttons)

        (Gb/step (button-mask mask-or-buttons)))))

 

 (defn play-moves

   ([start moves]

      (goto start)

      (dorun (map step moves))

      (backup-state)

      (frame))

   ([moves]

      (dorun (map step moves))

      (backup-state)

      (frame)))

 

 (defn play

   ([] (play Integer/MAX_VALUE))

   ([n] (dorun (dotimes [_ n] (step)))))

 

 (defmacro without-saves [& forms]

   `(binding [*save-history* false]

      ~@forms))

 

 

 (require '(clojure [zip :as zip]))

 

 

 

 

 (defn tree->str [original]

   (loop [s ".\n" loc (zip/down (zip/seq-zip (seq original)))]

     (if (zip/end? loc) s

         (let [d (count (zip/path loc))

 	      rep

               (str

                s

                (if (and (zip/up loc)

                         (> (count (-> loc zip/up zip/rights)) 0))

                  "|" "")

                (apply str (repeat (dec d) "   "))

                (if (= (count (zip/rights loc)) 0)

                  "`-- "

                  "|-- ")

                (zip/node loc)

                "\n")]

           (recur rep (zip/next loc))))))