Mercurial > vba-clojure

     1 (ns com.aurellem.gb-driver

     2     (:import com.aurellem.gb.Gb)

     3     (:import java.io.File)

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

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

     6 

     7 ;; Savestates

     8 (defrecord SaveState [frame data])

     9 

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

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

    12 

    13 (defn frame->filename [frame]

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

    15   

    16 (defn write-save! [^SaveState save]

    17   (let [buf (:data save)

    18         bytes (byte-array (.limit buf))

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

    20     (.get buf bytes)

    21     (FileUtils/writeByteArrayToFile dest bytes)

    22     (.rewind buf)

    23     save))

    24 

    25 (defn read-save [frame]

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

    27     (if (.exists save)

    28       (let [buf (Gb/saveBuffer)

    29             bytes (FileUtils/readFileToByteArray save)]

    30         (.put buf bytes)

    31         (.flip buf)

    32         (SaveState. frame buf)))))

    33 ;;;;;;;;;;;;;;;;

    34 

    35 ;; Gameboy management

    36 (Gb/loadVBA)

    37 

    38 (def yellow-rom-image

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

    40 

    41 (def yellow-save-file

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

    43 

    44 (def on? (atom nil))

    45 

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

    47 

    48 (defn restart! []

    49   (shutdown!)

    50   (.delete yellow-save-file)

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

    52   (reset! on? true))

    53 

    54 ;;; The first state!

    55 (defn gen-root! []

    56   (restart!)

    57   (write-save! (SaveState. 0  (Gb/saveState))))

    58 

    59 (defn root []

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

    61     (read-save 0)

    62     (gen-root!)))

    63 

    64 ;;;; Press Buttons

    65 

    66 (def button-code

    67   {;; main buttons

    68    :a         0x0001

    69    :b         0x0002

    70 

    71    ;; directional pad

    72    :r         0x0010

    73    :l         0x0020

    74    :u         0x0040

    75    :d         0x0080

    76 

    77    ;; meta buttons

    78    :select    0x0004

    79    :start     0x0008

    80 

    81    ;; pseudo-buttons

    82    :restart   0x0800 ; hard reset 

    83    :listen -1        ; listen for user input

    84    })

    85 

    86 (defn button-mask [buttons]

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

    88 

    89 (def current-state (atom nil))

    90 

    91 

    92 (defn set-state! [^SaveState state]

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

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

    95   (if (not= @current-state state)

    96     (Gb/loadState (:data state)))

    97   (reset! current-state state))

    98 

    99 (defrecord Move [keys state])

   100 

   101 (defn step

   102   ([^SaveState state buttons]

   103      (set-state! state)

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

   105      (reset! current-state 

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

   107   ([^SaveState state]

   108      (step state [:listen]))

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

   110 

   111 (defn move

   112   [^Move move buttons]

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

   114 

   115 

   116 (defn play

   117   ([^SaveState state n]

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

   119   ([n]

   120      (play @current-state n)))

   121 

   122 (defn play-moves

   123   ([moves [prev state]]

   124      (set-state! state)

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

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

   127   

   128 ;;;;;;;;;;;

   129 

   130 

   131 ;;;;;;;;;;;;;;; CPU data

   132 

   133 

   134 

   135 (defn cpu-data [size arr-fn]

   136   (let [store (int-array size)]

   137     (fn [state] (set-state! state) (arr-fn store) store)))

   138 

   139 (def ram

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

   141 

   142 (def rom 

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

   144 

   145 (def working-ram 

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

   147 

   148 (def video-ram 

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

   150 

   151 (def registers

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

   153 

   154 ;; TODO add register names

   155 

   156 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

   157 

   158 (defn AF [state]

   159   (nth (registers state) 2))

   160 

   161 (defn BC [state]

   162   (nth (registers state) 3))

   163 

   164 (defn DE [state]

   165   (nth (registers state) 4))

   166             

   167 ;;;;;;;;;;;;;;;

   168 

   169 (defmacro defn-memo

   170   [& forms]

   171   (let [fun-name (first forms)]

   172     `(do

   173        (defn ~@forms)

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

   175
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 10 Mar 2012 14:48:17 -0600
parents	95cb2152d7cd
children	65c2854c5875