(ns com.aurellem.exp.pokemon

   "Here I find out how pokemon are stored in memory."

   (:use (com.aurellem.gb gb-driver items assembly util

                          constants

                          characters species moves))

   (:import java.io.File)

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

 

 

 (def pidgeot-lvl-36 (mid-game))

 

 

 (def pidgeot-lvl-37 (read-state "pidgeot-lvl-37"))

 

 

 (def pidgeot-lvl-38  (read-state "pidgeot-lvl-38"))

 

 

 (def pidgeot-lvl-39  (read-state "pidgeot-lvl-39"))

 

 

 (def pidgeot-lvl-40  (read-state "pidgeot-lvl-40"))

 

 

 (defn level-analysis []

   (apply common-differences

          (map (comp vec memory)

               [pidgeot-lvl-36

                pidgeot-lvl-37

                pidgeot-lvl-38

                pidgeot-lvl-39

                pidgeot-lvl-40])))

 

 ;; inconclusive -- implies that level is calculated from

 ;; some other values.

 

 

 (def name-pidgeotto (read-state "name-pidgeotto"))

 (def named-A (read-state "named-A"))

 (def named-B (read-state "named-B"))

 (def named-C (read-state "named-C"))

 (def named-D (read-state "named-D"))

 (def named-E (read-state "named-E"))

 (def named-F (read-state "named-F"))

 

 (defn name-analysis []

   (apply common-differences

          (map (comp vec memory)

               [named-A

                named-B

                named-C

                named-D

                named-E

                named-F])))

 

 ;; resluted in 3 separate locations that could

 ;; possibly hold the first letter of the pokemon's name

 

 0xCF4A

 0xD2EB

 0xCEED

 

 ;; try changing each of them

 

 

 (defn test-cf4a []

   (continue!

    (set-memory named-A 0xCF4A (character->character-code "Z"))))

 ;; result -- pidgeotto named "A"

 

 (defn test-d2eb []

   (continue!

    (set-memory named-A 0xD2EB (character->character-code "Z"))))

 ;; result -- pidgeotto named "Z"

 

 (defn test-ceed []

   (continue!

    (set-memory named-A 0xCEED (character->character-code "Z"))))

 ;; result -- pidgeotto named "A"

 

 (def sixth-pokemon-name-start 0xD2EB)

 

 

 (defn set-sixth-pokemon-name-first-character

   ([state character]

      (set-memory state sixth-pokemon-name-start

                  (character->character-code character)))

   ([character]

      (set-sixth-pokemon-name-first-character @current-state

                                              character)))

 

 

 (def end-of-name-marker 0x50)

 (def max-name-length 10)

 (def name-width 11)

 

 (defn read-name [codes]

   (character-codes->str

    (take-while

     (partial not= end-of-name-marker) codes)))

     

 

 (defn sixth-pokemon-name [^SaveState state]

   (read-name

     (subvec (vec (memory state))

             sixth-pokemon-name-start

             (+ (inc max-name-length)

                sixth-pokemon-name-start))))

 

 (defn rename-sixth-pokemon

   ([^SaveState state new-name]

      (assert (< (count new-name) max-name-length))

      (set-memory-range state sixth-pokemon-name-start

                        (concat (str->character-codes new-name)

                                [end-of-name-marker])))

   ([new-name]

      (rename-sixth-pokemon @current-state new-name)))

 

 (defn print-text

   ([^SaveState state begin end]

      (dorun

       (map (fn [character-code line]

              (println

               (format "0x%04X: " line)

               (str (character-code->character character-code))))

            (subvec (vec (memory state)) begin end)

            (range begin end)))

      state)

   ([begin end]

      (print-text @current-state begin end)))

 

 (defn examine-name-memory []

   (print-text

    named-A

    (- sixth-pokemon-name-start 100)

    (+ sixth-pokemon-name-start 100)))

 

 ;; results:

 ;; 0xD287:  end-of-name-sentinel

 ;; 0xD288:  R

 ;; 0xD289:  L

 ;; 0xD28A:  M

 ;; 0xD28B:  end-of-pokemon-name-sentinel

 ;; 0xD28C:  end-of-name-sentinel

 ;; 0xD28D:  end-of-name-sentinel

 ;; 0xD28E:  end-of-name-sentinel

 ;; 0xD28F:  end-of-name-sentinel

 ;; 0xD290:  end-of-name-sentinel

 ;; 0xD291:  end-of-name-sentinel

 ;; 0xD292:  end-of-name-sentinel

 ;; 0xD293:  R

 ;; 0xD294:  L

 ;; 0xD295:  M

 ;; 0xD296:  end-of-pokemon-name-sentinel

 ;; 0xD297:  end-of-name-sentinel

 ;; 0xD298:  end-of-name-sentinel

 ;; 0xD299:  end-of-name-sentinel

 ;; 0xD29A:  end-of-name-sentinel

 ;; 0xD29B:  end-of-name-sentinel

 ;; 0xD29C:  end-of-name-sentinel

 ;; 0xD29D:  end-of-name-sentinel

 ;; 0xD29E:  R

 ;; 0xD29F:  L

 ;; 0xD2A0:  M

 ;; 0xD2A1:  end-of-pokemon-name-sentinel

 ;; 0xD2A2:  end-of-name-sentinel

 ;; 0xD2A3:  end-of-name-sentinel

 ;; 0xD2A4:  end-of-name-sentinel

 ;; 0xD2A5:  end-of-name-sentinel

 ;; 0xD2A6:  end-of-name-sentinel

 ;; 0xD2A7:  end-of-name-sentinel

 ;; 0xD2A8:  end-of-name-sentinel

 ;; 0xD2A9:  R

 ;; 0xD2AA:  L

 ;; 0xD2AB:  M

 ;; 0xD2AC:  end-of-pokemon-name-sentinel

 ;; 0xD2AD:  end-of-name-sentinel

 ;; 0xD2AE:  end-of-name-sentinel

 ;; 0xD2AF:  end-of-name-sentinel

 ;; 0xD2B0:  end-of-name-sentinel

 ;; 0xD2B1:  end-of-name-sentinel

 ;; 0xD2B2:  end-of-name-sentinel

 ;; 0xD2B3:  end-of-name-sentinel

 ;; 0xD2B4:  P

 ;; 0xD2B5:  I

 ;; 0xD2B6:  D

 ;; 0xD2B7:  G

 ;; 0xD2B8:  E

 ;; 0xD2B9:  O

 ;; 0xD2BA:  T

 ;; 0xD2BB:  end-of-pokemon-name-sentinel

 ;; 0xD2BC:  end-of-pokemon-name-sentinel

 ;; 0xD2BD:  end-of-pokemon-name-sentinel

 ;; 0xD2BE:  end-of-pokemon-name-sentinel

 ;; 0xD2BF:  P

 ;; 0xD2C0:  I

 ;; 0xD2C1:  K

 ;; 0xD2C2:  A

 ;; 0xD2C3:  C

 ;; 0xD2C4:  H

 ;; 0xD2C5:  U

 ;; 0xD2C6:  end-of-pokemon-name-sentinel

 ;; 0xD2C7:  end-of-pokemon-name-sentinel

 ;; 0xD2C8:  end-of-pokemon-name-sentinel

 ;; 0xD2C9:  end-of-pokemon-name-sentinel

 ;; 0xD2CA:  C

 ;; 0xD2CB:  H

 ;; 0xD2CC:  A

 ;; 0xD2CD:  R

 ;; 0xD2CE:  I

 ;; 0xD2CF:  Z

 ;; 0xD2D0:  A

 ;; 0xD2D1:  R

 ;; 0xD2D2:  D

 ;; 0xD2D3:  end-of-pokemon-name-sentinel

 ;; 0xD2D4:  end-of-pokemon-name-sentinel

 ;; 0xD2D5:  V

 ;; 0xD2D6:  E

 ;; 0xD2D7:  N

 ;; 0xD2D8:  U

 ;; 0xD2D9:  S

 ;; 0xD2DA:  A

 ;; 0xD2DB:  U

 ;; 0xD2DC:  R

 ;; 0xD2DD:  end-of-pokemon-name-sentinel

 ;; 0xD2DE:  end-of-pokemon-name-sentinel

 ;; 0xD2DF:  end-of-pokemon-name-sentinel

 ;; 0xD2E0:  P

 ;; 0xD2E1:  R

 ;; 0xD2E2:  I

 ;; 0xD2E3:  M

 ;; 0xD2E4:  E

 ;; 0xD2E5:  A

 ;; 0xD2E6:  P

 ;; 0xD2E7:  E

 ;; 0xD2E8:  end-of-pokemon-name-sentinel

 ;; 0xD2E9:  end-of-pokemon-name-sentinel

 ;; 0xD2EA:  end-of-pokemon-name-sentinel

 ;; 0xD2EB:  A

 ;; 0xD2EC:  end-of-pokemon-name-sentinel

 ;; 0xD2ED:  S

 ;; 0xD2EE:  T

 ;; 0xD2EF:  E

 ;; 0xD2F0:  R

 ;; 0xD2F1:  

 ;; 0xD2F2:  B

 ;; 0xD2F3:  A

 ;; 0xD2F4:  L

 ;; 0xD2F5:  L

 ;; 0xD2F6:  

 ;; 0xD2F7:  A

 ;; 0xD2F8:  

 ;; 0xD2F9:  

 ;; 0xD2FA:  end-of-name-sentinel

 ;; 0xD2FB:  end-of-name-sentinel

 ;; 0xD2FC:  A

 ;; 0xD2FD:  

 ;; 0xD2FE:  end-of-name-sentinel

 ;; 0xD2FF:  end-of-name-sentinel

 ;; 0xD300:  end-of-name-sentinel

 ;; 0xD301:  end-of-name-sentinel

 ;; 0xD302:  end-of-name-sentinel

 ;; 0xD303:  end-of-name-sentinel

 ;; 0xD304:  end-of-name-sentinel

 ;; 0xD305:  end-of-name-sentinel

 ;; 0xD306:  end-of-name-sentinel

 ;; 0xD307:  end-of-name-sentinel

 ;; 0xD308:  end-of-name-sentinel

 ;; 0xD309:  

 ;; 0xD30A:  w

 ;; 0xD30B:  

 ;; 0xD30C:  V

 ;; 0xD30D:  

 ;; 0xD30E:  

 ;; 0xD30F:  K

 ;; 0xD310:  

 ;; 0xD311:  

 ;; 0xD312:  

 ;; 0xD313:  A

 ;; 0xD314:  

 ;; 0xD315:  

 ;; 0xD316:  

 ;; 0xD317:  i

 ;; 0xD318:  

 ;; 0xD319:  

 ;; 0xD31A:  end-of-name-sentinel

 ;; 0xD31B:  end-of-name-sentinel

 ;; 0xD31C:  

 ;; 0xD31D:  

 ;; 0xD31E:  

 ;; 0xD31F:  

 ;; 0xD320:  

 ;; 0xD321:  

 ;; 0xD322:  

 ;; 0xD323:  

 ;; 0xD324:  

 ;; 0xD325:  

 ;; 0xD326:  

 ;; 0xD327:  

 ;; 0xD328:  

 ;; 0xD329:  

 ;; 0xD32A:  

 ;; 0xD32B:  

 ;; 0xD32C:  

 ;; 0xD32D:  

 ;; 0xD32E:  

 ;; 0xD32F:  

 ;; 0xD330:  

 ;; 0xD331:  9

 ;; 0xD332:  end-of-name-sentinel

 ;; 0xD333:  9

 ;; 0xD334:  

 ;; 0xD335:  9

 ;; 0xD336:  

 ;; 0xD337:  9

 ;; 0xD338:  end-of-name-sentinel

 ;; 0xD339:  end-of-name-sentinel

 ;; 0xD33A:  end-of-name-sentinel

 ;; 0xD33B:  end-of-name-sentinel

 ;; 0xD33C:  end-of-name-sentinel

 ;; 0xD33D:  end-of-name-sentinel

 ;; 0xD33E:  end-of-name-sentinel

 ;; 0xD33F:  end-of-name-sentinel

 ;; 0xD340:  end-of-name-sentinel

 ;; 0xD341:  end-of-name-sentinel

 ;; 0xD342:  end-of-name-sentinel

 ;; 0xD343:  end-of-name-sentinel

 ;; 0xD344:  end-of-name-sentinel

 ;; 0xD345:  end-of-name-sentinel

 ;; 0xD346:  

 ;; 0xD347:  

 ;; 0xD348:  

 ;; 0xD349:  G

 ;; 0xD34A:  A

 ;; 0xD34B:  R

 ;; 0xD34C:  Y

 ;; 0xD34D:  end-of-pokemon-name-sentinel

 ;; 0xD34E:  J

 

   

 ;; from this, it looks like the pokemon names are stored all

 ;; together in one location that begins at 0xD2B4 and

 ;; extends until 0xD2F5, with each name taking up 11 bytes.

 ;;

 ;; rival's name again clearly starts at 0xD349.

 

 

 (def pokemon-names-start 0xD2B4)

      

 

 ;; determine whether "number of pokemon in party"

 ;; might be kept in RAM and if so, where?

 

 (def six-pokemon (read-state "6-pokemon"))

 (def five-pokemon (read-state "5-pokemon"))

 (def four-pokemon (read-state "4-pokemon"))

 (def three-pokemon (read-state "3-pokemon"))

 (def two-pokemon (read-state "2-pokemon"))

 (def one-pokemon (read-state "1-pokemon"))

 

 

 (defn analyze-num-pokemon []

     (apply common-differences

          (map (comp vec memory)

               [one-pokemon

                two-pokemon

                three-pokemon

                four-pokemon

                five-pokemon

                six-pokemon])))

 

 ;; ;; results

 ;; ([53602 (1 2 3 4 5 6)]

 ;;  [65314 (105 61 93 60 92 34)]

 ;;  [55875 (34 36 43 52 7 0)]

 ;;  [55876 (18 0 33 52 54 30)]

 ;;  [49158 (197 194 77 117 174 134)]

 ;;  [49160 (29 26 57 239 15 243)]

 ;;  [49736 (74 93 34 89 91 59)]

 ;;  [49162 (165 162 182 179 197 109)]

 ;;  [49227 (187 105 204 5 90 238)]

 ;;  [53067 (128 136 132 145 135 11)]

 ;;  [53068 (147 131 141 136 128 7)]

 ;;  [53069 (136 134 148 140 145 2)]

 ;;  [49904 (2 11 10 3 27 12)]

 ;;  [49172 (100 109 213 195 68 104)]

 ;;  [65492 (11 103 128 160 19 56)]

 ;;  [49173 (80 77 72 75 76 67)]

 ;;  [49334 (8 10 11 5 3 1)]

 ;;  [49335 (49 10 11 19 17 15)]

 ;;  [49336 (8 10 11 5 3 1)]

 ;;  [49720 (106 14 118 0 38 11)]

 ;;  [65304 (32 88 19 114 106 33)]

 ;;  [53561 (59 229 48 17 155 103)]

 ;;  [55935 (6 5 4 3 2 1)])

 

 

 ;; two canidates : 0xD162 or 0xDA7F

 ;; they seem to always sum to 6...

 

 ;; try to set both of them when having only one pokemon.

 

 (defn change-party-number [^SaveState state new-num]

   (set-memory state 0xD162 new-num))

 

 ;; (continue! (change-party-number one-pokemon 3))

 ;; result -- can scroll down beyone first pokemon, finding

 ;; glitched pokemon in places where there were previously no

 ;; pokemon.

 

 

 (defn change-party-number* [^SaveState state new-num]

   (set-memory state 0xDA7F new-num))

 

 

 ;; (continue! (change-party-number* one-pokemon 3))

 ;; cannot widthdraw any pokemon from box 1 past the third

 ;; pokemon.

 

 (def party-number-address 0xD162)

 

 (defn party-number

   ([^SaveState state]

      (aget (memory state) party-number-address))

   ([] (party-number @current-state)))

 

 (def pokemon-in-box-1-address 0xDA7F)

 

 (defn party-names

   ([^SaveState state]

      (let [raw-names

            (subvec (vec (memory state))

                    pokemon-names-start

                    (+ pokemon-names-start

                       (* name-width 6)))]

        (map

         read-name

         (take

          (party-number state)

           (partition name-width

                    raw-names)))))

   ([] (party-names @current-state)))

 

 

 (defn rename-pokemon

   ([^SaveState state n new-name]

      (assert (<= 0 n (dec (party-number state))))

      (assert (<= (count new-name) max-name-length))

      (set-memory-range

       state

       (+ (* n name-width) pokemon-names-start)

       (concat (str->character-codes new-name) [end-of-name-marker])))

   ([n new-name]

      (rename-pokemon @current-state n new-name)))

 

 ;; on further analysis, it appears that the original

 ;; trainer info for each pokemon is also stored together,

 ;; starting at 0xD272 and continuing to 0xD2B3, with

 ;; 11 bytes reserved for each OT name.

 

 (def OT-start 0xD272)

 

 (defn original-trainers

   ([^SaveState state]

      (let [raw-names

            (subvec (vec (memory state))

                    OT-start

                    (+ OT-start

                       (* name-width 6)))]

        (map read-name

             (take (party-number state)

                   (partition name-width raw-names)))))

   ([] (original-trainers @current-state)))

        

 (defn set-original-trainer

   "Set the OT name for a pokemon.

    Note that a pokemon is still considered 'yours' if

    the OT ID is the same as your own."

   ([^SaveState state n new-name]

      (assert (<= 0 n (dec (party-number state))))

      (assert (<= (count new-name) max-name-length))

      (set-memory-range

       state

       (+ (* n name-width) OT-start)

       (concat (str->character-codes new-name) [end-of-name-marker])))

   ([n new-name]

      (set-original-trainer @current-state n new-name)))

 

 ;; PIKACHU stops following if you set it's OT to another name

 ;; and then back to you own.

 ;; But not if you set it to your own name, obviously.

 

 

 

 

 ;; OT ID Numbers.

 ;; My own id is 05195.  A quick search of memory between

 ;; 0xD162 and 0xD31B revealed the pattern 0x144B exactly

 ;; six times.

 

 ;; the locations were:

 

 (def OT-ID-addresses [0xD176 0xD1A2 0xD1CE 0xD1FA 0xD228 0xD252])

 

 

 (defn set-pokemon-id

   ([^SaveState state n new-id]

      (assert (<= 0 n (dec (party-number state))))

      (assert (<= 0 new-id 0xFFFF))

      (set-memory-range 

       state

       (OT-ID-addresses n)

       [(bit-shift-right (bit-and new-id 0xFF00) 8)

        (bit-and new-id 0xFF)

        ]))

   ([n new-id]

      (set-pokemon-id @current-state n new-id)))

 

 

 

 

 

 (defn get-pokemon-1-info

   ([state]

      (subvec (vec (memory state))

              0xD162 0xD197))

   ([] (get-pokemon-1-info @current-state)))

 

 (def baseline (File. "/home/r/baseline-poke"))

 

 

 

 

 (import java.io.File)

 

 (defn set-baseline [state]

   (clojure.java.io/copy 

    (with-out-str (print-listing state 0xD162 0xD197))

    baseline))

 

 (defn compare-pokemon

   ([state]

      (let [target (File. "/home/r/temp-poke")]

        (clojure.java.io/copy 

         (with-out-str (print-listing state 0xD162 0xD197))

         target)

        (println (:out

                  (clojure.java.shell/sh "diff"

                                         (.getCanonicalPath baseline)

                                         (.getCanonicalPath target))))))

   ([] (compare-pokemon @current-state)))

                                   

 

 (defn crazy-pid []

   (read-state "crazy-pidgeot"))

 

 (def unknown "[[[UNKNOWN]]]")

 

 (def unknown "")

 

 (def pokemon-1-info

   {0xD16A "Color Map"            ;; 0

    0xD16B "Current-HP (h)"       ;; 1

    0xD16C "Current-HP (l)"       ;; 2

    0XD16D unknown                ;; 3

    0xD16E unknown                ;; 4

    0xD16F unknown                ;; 5

    0xD170 unknown                ;; 6

    0xD171 unknown                ;; 7

    0xD172 "Move 1 ID"            ;; 8

    0xD173 "Move 2 ID"            ;; 9

    0xD174 "Move 3 ID"            ;; 10

    0xD175 "Move 4 ID"            ;; 11

    0xD176 "OT-ID (h)"            ;; 12

    0xD177 "OT-ID (l)"            ;; 13

    0xD178 "Exp. Points (h)"      ;; 14

    0xD179 "Exp. Points (m)"      ;; 15

    0xD17A "Exp. Points (l)"      ;; 16

    0xD17B "HP Exp. (h)"          ;; 17

    0xD17C "HP Exp. (l)"          ;; 18

    0xD17D "Attack Exp. (h)"      ;; 19

    0xD17E "Attack Exp. (l)"      ;; 20

    0xD17F "Defense Exp. (h)"     ;; 21

    0xD180 "Defense Exp. (l)"     ;; 22

    0xD181 "Speed Exp. (h)"       ;; 23

    0xD182 "Speed Exp. (l)"       ;; 24

    0xD183 "Special Exp. (h)"     ;; 25

    0xD184 "Special Exp. (l)"     ;; 26

    0xD185 unknown                ;; 27

    0xD186 unknown                ;; 28

    0xD187 "PP Move 1"            ;; 29

    0xD188 "PP Move 2"            ;; 30

    0xD189 "PP Move 3"            ;; 31

    0xD18A "PP Move 4"            ;; 32

    0xD18B "Current Level"        ;; 33

    0xD18C "HP Total (h)"         ;; 34

    0xD18D "HP Total (l)"         ;; 35

    0xD18E "Attack   (h)"         ;; 36

    0xD18F "Attack   (l)"         ;; 37

    0xD190 "Defense  (h)"         ;; 38

    0xD191 "Defense  (l)"         ;; 39

    0xD192 "Speed    (h)"         ;; 40

    0xD193 "Speed    (l)"         ;; 41

    0xD194 "Special  (h)"         ;; 42

    0xD195 "Special  (l)"         ;; 43

    })

    

 (defn pokemon-data

   ([^SaveState state pokemon-num]

      (assert (<= 0 pokemon-num 5))

      (let [base (+ (* pokemon-num  pokemon-record-width) 0xD16A)]

        (subvec (vec (memory state)) base

                (+ base pokemon-record-width))))

   ([pokemon-num] (pokemon-data @current-state pokemon-num)))

 

 (defn set-pokemon-data

   ([^SaveState state pokemon-num new-data]

      (assert (<= 0 pokemon-num 5))

      (let [base (+ (* pokemon-num  pokemon-record-width) 0xD16A)]

        (set-memory-range state base new-data)))

   ([pokemon-num new-data]

      (set-pokemon-data @current-state pokemon-num new-data)))

 

 (defn print-pokemon-data

   ([^SaveState state pokemon-num]

      (assert (<= 0 pokemon-num 5))

      (let [poke-data (pokemon-data state pokemon-num)

            backbone (sort (keys pokemon-1-info))]

        (println "Pokemon " pokemon-num  " -- "

                 (nth (party-names state)

                      pokemon-num) \newline)

 

        (println "    Desc.          | Hex  | Dec |  Binary  |")

        (println "-------------------+------+-----+----------+")

        (dorun

         (map

          (comp println

                (fn [desc data]

                  (format "%-16s   | 0x%02X | %3d | %s |"

                          desc data data

                          (let [s (Integer/toBinaryString data)]

                            (apply

                             str 

                             (concat (repeat (- 8 (count s)) "0" )

                                     s)))

 

 

                          )))

          

          (map pokemon-1-info backbone)

          poke-data))))

   ([pokemon-num]

      (print-pokemon-data @current-state pokemon-num)))

         

 

 

 (defn pre-battle [] (read-state "prepare-for-battle"))

 

 

 (defn pika-lvl-100-DV-0 []

   (read-state "at-pc-lv-100-pikachu"))

 

 ;; Performed following experiment:

 ;; Raised Pikachu to Lvl 100 with rare-candies,

 ;; then put it at the head of the party and

 ;; set 0xD185 and 0xD186 to zero.

 

 ;; then, for each pattern, deposited pikachu into

 ;; Box 1 and immediately widthdrew it and observed the

 ;; stats.

 

 

 ;; Pikachu L:100 Base Stats with DVs = 0

 ;; HP      :  187

 ;; Attack  :  123

 ;; Defense :   73

 ;; Speed   :  194

 ;; Special :  112

 

 ;; 0xD185:

 

 ;; 00000001

 ;; Defense => 75  (+2)

 ;; HP => 195      (+8)

 

 ;; 00000010

 ;; Defense => 77  (+4)

 

 ;; 00000100

 ;; Defense => 81  (+8)

 

 ;; 00001000

 ;; Defense => 89  (+16)

 

 ;; 00010000

 ;; HP => 203      (+16)

 ;; Attack => 125  (+2)

 

 ;; 00100000

 ;; Attack => 127  (+4)

 

 ;; 01000000

 ;; Attack -> 131  (+8)

 

 ;; 10000000

 ;; Attack -> 139  (+16)

 

 ;; 0xD186

 

 ;; 00000001

 ;; HP => 189      (+2)

 ;; Special =>     (+2)

 

 ;; 00000010

 ;; Special => 116 (+4)

 

 ;; 00000100

 ;; Special => 120 (+8)

 

 ;; 00001000

 ;; Special => 128 (+16)

 

 ;; 00010000

 ;; HP => 191      (+4)

 ;; Speed => 196   (+2)

 

 ;; 00100000

 ;; Speed => 198   (+4)

 

 ;; 01000000

 ;; Speed => 202   (+8)

 

 ;; 10000000

 ;; Speed => 210   (+16)

 

 (def pokemon-1-DV-start 0xD185)

 

 (defn pokemon-DV-start-point [poke-num]

   (+ (* poke-num pokemon-record-width)

      pokemon-1-DV-start))

 

 (def reverse-4-bit

   {0   0

    1   8

    2   4

    3   12

    5   10

    6   6

    7   14

    9   9

    15  15

    13  11

 

    8   1 

    4   2 

    12  3 

    10  5

    11  13

    14  7 })

    

 (defn read-DV

   ([^SaveState state poke-num]

      (assert (<= 0 poke-num 5))

      (let [[raw-DV-1

             raw-DV-2]

            (subvec (vec (memory state))

                    (pokemon-DV-start-point poke-num)

                    (+ 2 (pokemon-DV-start-point poke-num)))

            defense-DV (bit-and raw-DV-1 0x0F)

            attack-DV (bit-shift-right

                        (bit-and raw-DV-1 0xF0)

                         4)

            special-DV (bit-and raw-DV-2 0x0F)

            speed-DV (bit-shift-right

                         (bit-and raw-DV-2 0xF0)

                         4)

            HP-DV

            (+

             (if (bit-test special-DV 0)   1 0)

             (if (bit-test speed-DV 0)     2 0)

             (if (bit-test defense-DV 0)   4 0)

             (if (bit-test attack-DV 0)    8 0))]

        {:attack  attack-DV

         :defense  defense-DV

         :speed  speed-DV

         :special  special-DV

         :hp  HP-DV}))

   ([poke-num]

      (read-DV @current-state poke-num)))

      

 

 (defn give-DV

   ([^SaveState state poke-num dv-values]

      

      (assert (<= 0 poke-num 5))

      (map #(assert (<= 0 % 15)) (vals dv-values))

      (let [raw-dv-1*

            (+ (:defense dv-values)

               (bit-shift-left (:attack dv-values) 4))

            raw-dv-2*

            (+ (:special dv-values)

               (bit-shift-left (:speed dv-values) 4))

            hp-dv (:hp dv-values)

            hp-masks-1

            [[0 (bit-test hp-dv 2)]

             [4 (bit-test hp-dv 3)]]

            hp-masks-2

            [[0 (bit-test hp-dv 0)]

             [4 (bit-test hp-dv 1)]]

            set-hp-bits

            (fn [init [index hp?]]

              (if hp?

                (bit-set init index)

                (bit-clear init index)))

 

            raw-dv-1 (reduce set-hp-bits raw-dv-1*

                             hp-masks-1)

                      

            raw-dv-2 (reduce set-hp-bits raw-dv-2*

                             hp-masks-2)

            

            dv-start (pokemon-DV-start-point poke-num)]

 

        (if (or (not= raw-dv-1* raw-dv-1)

                (not= raw-dv-2* raw-dv-2))

          (println "Warning: inconsistent DV-values."

                   "Using HP settings."))

        

        (set-memory 

         (set-memory state dv-start raw-dv-1)

         (inc dv-start) raw-dv-2)))

   ([poke-num dv-values]

      (give-DV @current-state poke-num dv-values)))

 

 (def good-DVs

   {:attack  15

    :defense 15

    :speed   15

    :special 15

    :hp      15})

 

 (def bad-DVs

   {:attack  0

    :defense 0

    :speed   0

    :special 0

    :hp      0})