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

 

 ;; Savestates

 (defrecord SaveState [frame data])

 

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

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

 

 (defn frame->filename [frame]

   (File. *save-state-cache* (format "%07d.sav" frame)))

   

 (defn write-state! [^SaveState save]

   (let [buf (:data save)

         bytes (byte-array (.limit buf))

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

     (.get buf bytes)

     (FileUtils/writeByteArrayToFile dest bytes)

     (.rewind buf)

     dest))

 

 (defn read-state [frame]

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

     (if (.exists save)

       (let [buf (Gb/saveBuffer)

             bytes (FileUtils/readFileToByteArray save)]

         (.put buf bytes)

         (.flip buf)

         (SaveState. frame buf)))))

 ;;;;;;;;;;;;;;;;

 

 ;; Gameboy management

 (Gb/loadVBA)

 

 (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 on? (atom nil))

 

 (defn shutdown! [] (Gb/shutdown) (reset! on? false))

 

 (defn restart! []

   (shutdown!)

   (.delete yellow-save-file)

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

   (reset! on? true))

 

 ;;; The first state!

 (defn gen-root! []

   (restart!)

   (let [state (SaveState. 0  (Gb/saveState))]

     (write-state! state)

     state))

 

 (defn root []

   (if (.exists (frame->filename 0))

     (read-state 0)

     (gen-root!)))

 

 ;;;; Press Buttons

 

 (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

 

    ;; pseudo-buttons

    :restart   0x0800 ; hard reset 

    :listen -1        ; listen for user input

    })

 

 (defn button-mask [buttons]

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

 

 (def current-state (atom nil))

 

 (defn set-state! [^SaveState state]

   (assert (:data state) "Not a valid state!")

   (if (not @on?) (restart!))

   (if (not= @current-state state)

     (Gb/loadState (:data state)))

   (reset! current-state state))

 

 (defrecord Move [keys state])

 

 (defn update-state []

   (reset! current-state

           (SaveState. (:frame @current-state)

                       (Gb/saveState))))

 

 (defn step

   ([^SaveState state buttons]

      (set-state! state)

      (Gb/step (button-mask buttons))

      (reset! current-state 

              (SaveState. (inc (:frame state))(Gb/saveState))))

   ([^SaveState state]

      (step state [:listen]))

   ([] (step (if @current-state @current-state (root)))))

 

 (defn move

   [^Move move buttons]

   (Move. (step (:state move) buttons) buttons))

 

 (defn play

   ([^SaveState state n]

      (reduce (fn [s _] (step s)) state (range n)))

   ([n]

      (play @current-state n)))

 

 (defn play-moves

   ([moves [prev state]]

      (set-state! state)

      (dorun (map (fn [move] (step @current-state move)) moves))

      [(concat prev moves) @current-state]))

   

 ;;;;;;;;;;;

 

 

 ;;;;;;;;;;;;;;; CPU data

 

 (defn cpu-data [size arr-fn]

   (let [store (int-array size)]

     (fn get-data

       ([] (get-data @current-state))

       ([state]

          (set-state! state) (arr-fn store) store))))

 

 (def memory

   (cpu-data Gb/GB_MEMORY #(Gb/getMemory %)))

 

 (def ram

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

 

 (def rom 

   (cpu-data Gb/ROM_SIZE #(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 %)))

 

 

 (defn write-memory! [new-memory]

   (let [store (int-array new-memory)]

     (assert (= Gb/GB_MEMORY) (count new-memory))

     (Gb/writeMemory new-memory)))

     

 

 ;; TODO add register names

 

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 

 (defn AF [state]

   (nth (registers state) 2))

 

 (defn BC [state]

   (nth (registers state) 3))

 

 (defn DE [state]

   (nth (registers state) 4))

             

 ;;;;;;;;;;;;;;;

 

 (defmacro defn-memo

   [& forms]

   (let [fun-name (first forms)]

     `(do

        (defn ~@forms)

        (alter-var-root (var ~fun-name) memoize))))