Mercurial > vba-clojure

     1 (ns com.aurellem.exp.item-bridge

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

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

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

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

     6 

     7 (defn corrupt-item-state []

     8   (second (destroy-item-end-of-list-marker)))

     9 

    10 (defn corrupt-item-state []

    11   (read-state "corrupt-items"))

    12 

    13 (defn view-memory-range [state start end]

    14   (dorun

    15    (map (fn [loc val]

    16           (println (format "%04X : %02X" loc val)))

    17         (range start end) (subvec (vec (memory state)) start end)))

    18   state)

    19 

    20 (defn almost-broken

    21   "if one more memory location is turned into 0x03, the game crashes."

    22   [n]

    23   (view-memory-range

    24    (set-inv-mem (mid-game)

    25                 (concat [0xFF] (repeat 64 0x03)

    26                         (subvec (vec (memory (mid-game)))

    27                                 (+ item-list-start 65)

    28                                 (+ item-list-start 65 n))

    29                         (repeat (- 255 65 n) 0x03)))

    30    item-list-start (+ item-list-start 255)))

    31 

    32 (defn actually-broken

    33   "if this memory location is turned into 0x03, the game crashes."

    34   []

    35   (set-memory (mid-game) 0xD35D 0x03))

    36 

    37 

    38 ;; (almost-broken 20) more or less works

    39 

    40 (defn capture-program-counter

    41   "records the program counter for each tick"

    42   [^SaveState state ticks]

    43   (let [i (atom 0)]

    44     (reduce (fn [[program-counters state] _]

    45               (println (swap! i inc))

    46                [(conj program-counters (PC state))

    47                 (tick state)])

    48               [[] state]

    49               (range ticks))))

    50 

    51 

    52 (defn capture-program-counter

    53   [^SaveState state ticks]

    54   (tick state)

    55   

    56   (loop [i 0

    57          pcs []]

    58     (if (= i ticks)

    59       (filter (partial < 0x2000)(sort (set pcs)))

    60       (do 

    61         (com.aurellem.gb.Gb/tick)

    62         (recur (inc i)

    63                (conj pcs (first (registers))))))))

    64 

    65 (defn loop-program []

    66   [0x00     ;0xD31D  ;; disable-interrupts

    67 

    68    0xC3     ;; loop forever

    69    0x1D

    70    0xD3])

    71 

    72 (def map-function-address-start 0xD36D)

    73 

    74 (defn test-loop []

    75   (continue!

    76    (-> (mid-game) 

    77        (set-memory-range 0xD31D (loop-program))

    78        (set-memory-range

    79         map-function-address-start

    80         [0xD3 0x1D]))))

    81        

    82 

    83 

    84 

    85 (defn-memo corrupt-moves []

    86   (concat

    87    (first

    88     (->>

    89      [[] (mid-game)]

    90      (advance [:b] [:b :start])

    91      (advance [] [:d])

    92      (play-moves [[] [] [] [:d] [] [] [] [:d] [] [] [:a]])

    93      scroll-text

    94      (play-moves

    95       ;; this section is copied from speedrun-2942

    96       ;; and corrupts the save so that the end-of-list marker

    97       ;; for the pokemon roster is destroyed, but the save is still

    98       ;; playable.

    99       [[] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] []

   100        [] [] [] [] [] [] [] [] [] [] [:select] [:restart]])

   101      (play-moves

   102       (first (title)))

   103      (advance [] [:start])

   104      (advance [] [:a])

   105      (advance [:a] [:a :start])))

   106    [[]]))

   107   

   108 

   109 

   110 (defn corrupt

   111   "enter the codes to destroy the

   112    pokemon list using save corruption"

   113   ([^SaveState state]

   114   (run-moves

   115    state

   116    (corrupt-moves)))

   117   ([] (corrupt @current-state)))

   118 

   119 (defn mid-game-corrupt []

   120   (read-state "corrupt-mid-game"))

   121 

   122 

   123      

   124 

   125 

   126 

   127 (defn test-memory-fun [n]

   128   (capture-program-counter

   129    (set-memory-range

   130     (tick (mid-game))

   131     0xD36D

   132     [0 0])

   133    n))

   134 

   135 ;;(def good (test-memory-fun 17000))

   136 

   137 ;;(def bad (test-memory-fun 18000))

   138 

   139 

   140 

   141 (defn menu-open-state []

   142   (read-state "menu-open"))

   143 

   144 (defn prepare-memory

   145   ([^SaveState state]

   146      (-> state

   147          (set-memory-range 0xD31D (loop-program))

   148          (set-memory-range 0xD36D [0x1D 0xD3])))

   149   ([] (prepare-memory @current-state)))

   150 

   151 

   152 (defn succesful-PC-capture

   153   "This function demonstrates successful PC capturing by

   154    setting 0xD36D to the value of the start location of

   155    a specially prepared program.

   156 

   157    You must run the function and then exit the open menu

   158    to see the effect."

   159   []

   160   (dorun

   161    (map #(println (Integer/toHexString %))

   162         (capture-program-counter 

   163          (prepare-memory (menu-open-state))

   164          9000000))))

   165
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 24 Mar 2012 15:02:49 -0500
parents	8523faa122b0
children	49a709c555f2