If I wanted to play the game using only Generation I rules, I could just import all of the Pokémon Yellow data from my earlier project and develop questions based on those.

(:use com.aurellem.gb.hxc) ;; my earlier project

(defn map-vals [f m]
  (into {} (map (fn [[k v]] [k (f v)]) m)))


;; POKEMON YELLOW DATA
(def pokemon (rest (hxc-pokedex-names)))
(def evolutions (hxc-evolution-pretty))
(def types (map-vals :types (hxc-pokemon-base)))
(def advantage (hxc-advantage))


(def stones
  (set
   (remove nil?
           (apply concat
                  (map
                   (comp (partial map :item)
                         evolutions)
                   pokemon)))))

On the other hand, in order to have the full experience of a game with my friends, I knew I would have to collect analogous data from Pokémon Gold so that my program could ask questions about both Generation I and II Pokémon.

The process was identical to the one I used for Yellow: I looked for the relevant data in the ROM, and when I found it, I wrote code to extract it and to put it in a more usable format.

;; HELPER FUNCTIONS
(defn fork [pred f g]
  (fn [x]
    (if (pred x) (f x) (g x))))

(def format-name
  (fn [s]
    (keyword (.toLowerCase
              (apply str
                     (map #(if (= % \space) "-" %) s))))))

(def unkeyword (comp (partial apply str) rest str))

(defn hxc-pokenames* []
  (map
   (comp format-name
         character-codes->str
         (partial remove (partial = 0x50)))
   (partition 10
              (take 2510
                    (drop 0x1B0B74
                          gold)))))


(defn hxc-pokedex* []
  (let [caps?
        (comp not nil? (set "ABCDEFGHIJKLMNOPQRSTUVWXYZ "))]
    (map 
     (fn [[[kind] [x & xs] ]]
       (let [htwt (take 4 x)
             y (drop 4 x)]           
         {:kind
          (character-codes->str kind)
          :text
          (apply str
                 (interleave
                  (repeat " ")
                  (map character-codes->str (cons y xs))))
            }))
     (partition 2
                (partition-by
                 (comp (partial every? caps?)
                       character-codes->str)
                 (take-nth 2 
                           (partition-by
                            (partial = 0x50)
                            (take 55664
                                  (drop 0x1A0000
                                        gold)))))))))

(def pokeid
  (comp (zipmap (hxc-pokenames*) (range))))

(def type-map
        {0 :normal
         1 :fighting
         2 :flying
         3 :poison
         4 :ground
         5 :rock
         7 :bug
         8 :ghost
         9 :steel
         ;; a gap separates physical from special types
         20 :fire
         21 :water
         22 :grass
         23 :electric
         24 :psychic
         25 :ice
         26 :dragon
         27 :dark
        })

(defn hxc-types* 
  "A thunk which returns a map from pokemon to their types."
  []
  (map (comp format-name character-codes->str)
       (take-nth 2
                 (partition-by
                  (partial = 0x50)
                  (take 117
                        (drop 0x509E6
                              gold))))))


;; a list of every type
(def all-types
  (distinct (reduce concat (map types pokemon))))


(defn hxc-advantage* []
  (let [types (hxc-types*)]
  (map
   (fn[[a b c]]
     [(get type-map a a)
      (get type-map b b)
      (/ c 10)] )
   (partition 3
              (remove (partial = 254) ;; why was this inserted?
                      (take 333 (drop 0x34d01 gold)))))))



(defn hxc-dex-data*
  "Hardcoded pokedex data from gold. Here, used only to get the types
  of every Pokemon; the rest of the data is ignored."
  []
  (let [entry-size 32]
    (zipmap
     pokemon
     (map
      (fn [[dex#
            _ _ _ _ _ _
            type-1
            type-2
            & _
            ]]
        {:types (set (map type-map [type-1 type-2]))}
        )
      
      (partition entry-size 
                 (take (* 251 32) (drop 0x51B0B gold)))))))

(defn item-names* []
  (map (comp format-name
                character-codes->str)
                (take-nth 2
                          (partition-by
                           (partial = 0x50)
                           (take 2012 (drop 0x1b0000 gold))))))
  

(defn evo-ptrs
  "Pointers to evolution data for each pokemon.
The game alternates between evolution and learnset data."
  []
  (map
   (comp
    (partial + 0x3c000)
    (fn [[lo hi]] (+ lo (* 0x100 hi))))

    (partition 2
               (take (* 2 251)
                     (drop 0x427BD
                           gold)))))

(defn evo-data* []
  (let [pokemon (hxc-pokenames*)
        items (item-names*)]
    (zipmap pokemon
        (map
         (comp
          (fn parse-data
            [[a b c & d]]
            (let [x
                  (cond
                    (= a 1) ;; level-up
                    {:method :level-up
                     :min-level b
                     :into (nth pokemon (dec c))}
                    
                    (= a 2) ;; item
                    {:method :item
                     :item (nth items (dec b))
                     :into (nth pokemon (dec c))}
                    
                    (= a 3) ;; trade
                    {:method :trade
                     :item (if (= b 0xFF) nil (nth items (dec b)))
                     :into (nth pokemon (dec c))}
                    
                    (= a 4) ;; happiness
                    {:method :happiness
                     :when (get [:anytime :day :night] (dec b))
                     :into (nth pokemon (dec c))}
                    
                    (= a 5)
                    {:method :stat
                     :min-level b
                     :stat (get [:atk :def :equal] (dec c))
                     :into (nth pokemon (dec (first d)))
                     })

                  ys (if (= a 5) (rest d) d)
                  ]
              (cond
                (nil? x) '()
                (empty? ys) (list x)
                :else (cons x (parse-data ys)))))
          
          
          #(take-while
            (comp not zero?) ;;zero separates evolution from move data
            (drop % gold)))
         (evo-ptrs)))))

(defn evo-data-raw []
  (let [pokemon (hxc-pokenames*)
        items (item-names*)]
    (zipmap pokemon
        (map
         (comp
          (fn parse-data
            [[a b c & d]]
            (let [x
                  (cond
                    (= a 1) ;; level-up
                    [a b c]
                    
                    (= a 2) ;; item
                    [a b c]
                    
                    (= a 3) ;; trade
                    [a b c]
                    
                    (= a 4) ;; happiness
                    [a b c]
                    
                    (= a 5)
                    [a b c (first d)])

                  ys (if (= a 5) (rest d) d)
                  ]
              (cond
                (nil? x) '()
                (empty? ys) (list x)
                :else (cons x (parse-data ys)))))
          
          
          #(take-while
            (comp not zero?) ;;zero separates evolution from move data
            (drop % gold)))
         (evo-ptrs)))))

;; POKEMON GOLD
(def pokemon (hxc-pokenames*))
(def evolutions (evo-data*))
(def advantage (hxc-advantage*))
(def stones
  #{:fire-stone
    :thunderstone
    :water-stone
    :leaf-stone
    :sun-stone
    :moon-stone})


(def types (map-vals :types (hxc-dex-data*)))

Now that I had the necessary data, I needed to manipulate that data into usable form. For example, my program knew that bulbasaur evolves into ivysaur:

(pokeclass.idtree/evolutions :bulbasaur)

:method

:level-up

:min-level

16

:into

:ivysaur

but I had no convenient way to tell that it was part of a three-stage evolution — that is, I had no automatic way to look at all of a Pokémon's pre-evolutions or post-evolutions.

First, I defined a variable all-families, which used the individual evolution data of each Pokémon to build a list of all the evolutionary families. Here, each evolutionary family is stored as a set, meaning that the Pokémon aren't in any particular order.

;; all-families consists of sets of evolution groups
(def all-families
  (let [twos ;; twos are adjacent evolution pairs
        (pmap
         #(cons %
                ((comp
                  (partial map :into)
                  evolutions) %))
         pokemon)]

    (loop [open (map set twos)
           closed []]
      ;;(println (first open))
      
      (if (empty? open)
        closed
        (let [x (first open)
              matches (remove (partial not-any? x) (rest open))
              non-matches (filter (partial not-any? x) (rest open))]

          (if (empty? matches)
            (recur non-matches
                   (conj closed x))
            (recur (conj non-matches
                         (set (reduce concat x matches)))
                   closed)))))))
            

Check it out:

pokeclass.idtree/all-families

[#{:bulbasaur :ivysaur :venusaur} #{:charizard :charmeleon :charmander} #{:squirtle :wartortle :blastoise} #{:caterpie :butterfree :metapod} #{:weedle :kakuna :beedrill} #{:pidgeotto :pidgeot :pidgey} #{:raticate :rattata} #{:fearow :spearow} #{:arbok :ekans} #{:pikachu :pichu :raichu} #{:sandshrew :sandslash} #{:nidorina :nidoqueen :nidoran♀} #{:nidoran♂ :nidorino :nidoking} #{:clefairy :cleffa :clefable} #{:vulpix :ninetales} #{:wigglytuff :igglybuff :jigglypuff} #{:golbat :zubat :crobat} #{:bellossom :gloom :vileplume :oddish} #{:paras :parasect} #{:venomoth :venonat} #{:diglett :dugtrio} #{:persian :meowth} #{:psyduck :golduck} #{:mankey :primeape} #{:arcanine :growlithe} #{:politoed :poliwhirl :poliwrath :poliwag} #{:abra :kadabra :alakazam} #{:machamp :machop :machoke} #{:weepinbell :bellsprout :victreebel} #{:tentacool :tentacruel} #{:golem :geodude :graveler} #{:rapidash :ponyta} #{:slowking :slowpoke :slowbro} #{:magnemite :magneton} #{:farfetch'd} #{:doduo :dodrio} #{:seel :dewgong} #{:muk :grimer} #{:shellder :cloyster} #{:gengar :haunter :gastly} #{:steelix :onix} #{:drowzee :hypno} #{:krabby :kingler} #{:electrode :voltorb} #{:exeggutor :exeggcute} #{:cubone :marowak} #{:hitmonchan :hitmontop :hitmonlee :tyrogue} #{:lickitung} #{:weezing :koffing} #{:rhydon :rhyhorn} #{:chansey :blissey} #{:tangela} #{:kangaskhan} #{:seadra :kingdra :horsea} #{:seaking :goldeen} #{:starmie :staryu} #{:mr.mime} #{:scyther :scizor} #{:jynx :smoochum} #{:elekid :electabuzz} #{:magmar :magby} #{:pinsir} #{:tauros} #{:magikarp :gyarados} #{:lapras} #{:ditto} #{:flareon :espeon :vaporeon :jolteon :umbreon :eevee} #{:porygon2 :porygon} #{:omastar :omanyte} #{:kabutops :kabuto} #{:aerodactyl} #{:snorlax} #{:articuno} #{:zapdos} #{:moltres} #{:dragonair :dratini :dragonite} #{:mewtwo} #{:mew} #{:chikorita :meganium :bayleef} #{:quilava :typhlosion :cyndaquil} #{:croconaw :feraligatr :totodile} #{:sentret :furret} #{:hoothoot :noctowl} #{:ledyba :ledian} #{:spinarak :ariados} #{:lanturn :chinchou} #{:togetic :togepi} #{:xatu :natu} #{:flaaffy :ampharos :mareep} #{:marill :azumarill} #{:sudowoodo} #{:hoppip :jumpluff :skiploom} #{:aipom} #{:sunflora :sunkern} #{:yanma} #{:quagsire :wooper} #{:murkrow} #{:misdreavus} #{:unown} #{:wobbuffet} #{:girafarig} #{:pineco :forretress} #{:dunsparce} #{:gligar} #{:granbull :snubbull} #{:qwilfish} #{:shuckle} #{:heracross} #{:sneasel} #{:ursaring :teddiursa} #{:slugma :magcargo} #{:piloswine :swinub} #{:corsola} #{:octillery :remoraid} #{:delibird} #{:mantine} #{:skarmory} #{:houndoom :houndour} #{:phanpy :donphan} #{:stantler} #{:smeargle} #{:miltank} #{:raikou} #{:entei} #{:suicune} #{:tyranitar :larvitar :pupitar} #{:lugia} #{:ho-oh} #{:celebi}]

Using all-families, you can write a function that returns an individual Pokémon's evolutionary family; here, I call that function evolution-group.

(defn evolution-group [pkmn]
  (first (filter #(% pkmn) all-families)))

Check it out:

(pokeclass.idtree/evolution-group :charmander )

#{:charizard :charmeleon :charmander}

Finally, while having the unordered evolution data was useful, I also wanted to be able to ask questions about the pre-evolutions and post-evolutions of a Pokémon. So, I wrote three more functions: pre-evolutions, post-evolutions, and evolution-line.

• The function pre-evolutions takes a Pokémon as an argument and returns a list that is either empty or which contains the Pokémon that directly evolves into it.
• The function post-evolutions takes a Pokémon as an argument and returns a list of all the Pokémon that it can directly evolve into.
• The function evolution-line combines both of these functions; it takes a Pokémon and produces a list of its evolutionary precursors and successors.

Importantly, this new function evolution-line is different than the function evolution-group we defined earlier: evolution-line returns a list containing only the precursors and successors of a Pokémon, whereas evolution-group returns a set that contains the entire family, even other branches of evolution.

(defn pre-evolutions [pkmn]
  (filter
   (comp
    not nil?
    (partial some #{pkmn})
    (partial map (comp :into))
    evolutions)
   pokemon))

(def post-evolutions
  (comp
   (partial map :into)
   evolutions))



(defn evolution-line [pkmn]
  (concat
   (pre-evolutions (first (pre-evolutions pkmn)))
   (pre-evolutions pkmn)
   (list pkmn)
   (post-evolutions pkmn)
   (post-evolutions (first (post-evolutions pkmn)))))

;; EVOLUTION LINE
(println
 (pokeclass.idtree/evolution-line :vaporeon))

(println
 (pokeclass.idtree/evolution-line :bellossom))
 
(println
 (pokeclass.idtree/evolution-line :poliwag))


(println)


;; EVOLUTION GROUP
(println
 (pokeclass.idtree/evolution-group :vaporeon))

(println
 (pokeclass.idtree/evolution-group :bellossom))

(println
 (pokeclass.idtree/evolution-group :poliwag))

(:eevee :vaporeon)
(:oddish :gloom :bellossom)
(:poliwag :poliwhirl :poliwrath :politoed)

#{:flareon :espeon :vaporeon :jolteon :umbreon :eevee}
#{:bellossom :gloom :vileplume :oddish}
#{:politoed :poliwhirl :poliwrath :poliwag}

;; does the pokemon have this particular type?
(def has-type?
  (fn ([type]
         (fn [pkmn]
           ( (comp not nil? (types pkmn)) type))))
    ([type pkmn]
       ((has-type? type) pkmn)))

;; is the pokemon a pure ____ type?
(defn pure-type?
  ([type]
     (comp (partial = #{type})
           types))
  ([type pkmn]
     ((pure-type? type) pkmn)))

;; does the pokemon have more than one type?
(defn dual-type? [pkmn]
  (> (count (types pkmn)) 1))

;; does the pokemon change type when it evolves?
;; (e.g. like magikarp, poliwhirl, nidorino, eevee) 
(def change-type?
  (comp
   not zero?
   dec count set
   (partial map types)
   #(cons % (post-evolutions %))))

;; is the pokemon unable to evolve?
(defn final-form? [pkmn]
  (empty? (evolutions pkmn)))


;; does the pokemon have any pre- or post-evolutions?
(def evolution-line?
  (comp pos? dec count evolution-group))


;; can it evolve in more than one way?
(def evolve-multiple?
  (comp pos? dec count post-evolutions))

;; can it evolve by levelling up?
(def evolve-levelup?
  (comp not
        nil?
        (partial some #{:level-up :stat})
        (partial map :method)
        evolutions))


;; can it use an item to evolve? (including held items, in gen II)
(def evolve-item?
  (comp
   not nil?
   (partial some (comp not nil? :item))
   evolutions))

;; can it use an evolutionary stone to evolve?
(def evolve-stone?
  (comp
   not nil?
   (partial some (comp not nil? stones))
   (partial map :item)
   evolutions))


;; can it use the specific item ____ in order to evolve?
(defn evolve-with? [item]
  (comp not nil?
        #(% item)
        set
        (partial map :item)
        evolutions))


;; can it evolve by being traded? (e.g. onix, machoke)
(def evolve-trade?
  (comp not
        nil?
        :trade
        set
        (partial map :method)
        evolutions))


;; does it evolve when traded with a particular item?
(def evolve-trade-item?
  #(and (evolve-item? %)
        (evolve-trade? %)))


;; can it evolve through happiness?
(def evolve-happy?
  (comp not
        nil?
        :happiness
        set
        (partial map :method)
        evolutions))






;; can it evolve into something that evolves?
(def evolve-twice? ;;at least twice = exactly twice, here.
  (comp
   not empty?
   (partial apply concat)
   (partial map post-evolutions)
   post-evolutions))


;; does it evolve into something that can't evolve?
(def evolve-once? ;; exactly once
  #(not
    (or (empty? (post-evolutions %))
        (evolve-twice? %))))


;; is it part of a three-stage evolution?
(def three-stage?
  (comp
   (partial = 3)
   count
   evolution-group))




;; The following is a hack that works for generation I only:
;; I ask whether the size of the evolution group is even.
;; For generation I, the only pokemon with an even-sized evolution
;; group are pokemon that are part of a pair of evolutions, including eevee.

;; This hack breaks in generation II, e.g. for politoed, bellossom.

(def evolution-pair?
  ;; is it eevee or part of a pair of evolutions?
  (comp even? count evolution-group))

(def generation-1?
  (comp (partial >= 150) pokeid))

(def generation-2?
  (comp not generation-1?))

;; is it a GI pokemon that evolves into a GII pokemon?
(def evolve-1->2?
  #(and (generation-2? %)
        (not (empty? (pre-evolutions %)))
        (generation-1? (first (pre-evolutions %)))))

;; is it a GII pokemon that evolves into a GI pokemon?
(def evolve-2->1?
  #(and (generation-2? %)
        (not(nil?(some generation-1? (post-evolutions %))))))

;; note: this fn returns a list of baby pokemon, but misses togepi.

(defn weakness
  "If type is supplied, returns the damage multiplier for that type
against the given pokemon. Otherwise, returns a map from types to
  their damage multipliers against the pokemon."
  ([pkmn]
     (apply merge-with *
           (map
            #(hash-map (nth % 0) (nth % 2))
            (apply concat
                    (map #(filter (comp (partial = %) second) advantage)
                         (types pkmn))))))
  ([type pkmn]
     (get (weakness pkmn) type 1))) 


;; is it immune to some type?
(def has-immunity?
  (fn [pkmn]
    (let [type-match? (comp not nil? (set(types pkmn)))]
      (not(nil?
           (some (comp zero? second rest)
            (filter
             (comp type-match? second)
             advantage)))))))


;; is it immune to the _____ type?
(def immune-to?
  (fn [pkmn type]
    (let [type-match? (comp not nil? (set(types pkmn)))]
      
      (reduce
       (fn [x [atk def y]]
         (if (type-match? def)
           (* x y)
           x))
       1
       advantage))))

Although I wanted to avoid including handwritten data as much as possible, there were some very reasonable questions which were easier to code by hand rather than to extract directly.

;; is it a baby pokemon?
(def baby?
  (comp not nil?
        #{:pichu
          :cleffa
          :igglybuff
          :togepi ;;?
          :tyrogue
          :smoochum
          :elekid
          :magby
          }))


;; is it legendary?
(def legendary?
  (comp not nil? (set [:articuno :zapdos :moltres
                       :mewtwo :mew

                       :raikou :entei :suicune
                       :lugia :ho-oh
                       :celebi
                       ])))

;; is it a fossil pokemon?
(def fossil?
  (comp not nil? (set [:omanyte :omastar :kabuto :kabutops :aerodactyl])))

(defn genetic
  "Transform a predicate about a pokemon into a predicate about its
  evolutionary line."
  [pred]
    (comp
     not nil?
     (partial some pred)
     evolution-line
     ))

Check it out:

;; does magikarp have the flying type?
(println
 ((pokeclass.idtree/has-type? :flying)
  :magikarp))

;; does any member of magikarp's line have the flying type?
(println
 ((pokeclass.idtree/genetic
   (pokeclass.idtree/has-type? :flying))
  :magikarp ))



;; is raichu a baby pokemon?
 (println
  (pokeclass.idtree/baby?
   :raichu))

;; is any member of raichu's line a baby pokemon?
(println
 ((pokeclass.idtree/genetic
   pokeclass.idtree/baby?)
  :raichu))

false
true
false
true

(def log #(Math/log %))

(def entropy
  (memoize
   (fn [pkmns pred]
     (if (empty? pkmns) 0
         (apply +
                ((fn [[ys ns]]
                   (map
                    (fn [p]
                      (if (zero? p) 0
                          (* p (Math/log p))))
                    [(/ ys (+ ys ns))
                     (/ ns (+ ys ns))]
                            ))
                 (reduce
                  (partial map +)
                  (pmap #(if (pred %) [1 0] [0 1])pkmns))))))))
  

(def complexity
  (fn [pkmns]
    (juxt (comp (partial entropy pkmns) first)
          (comp count second))))

• Some Pokémon are indistinguishable given the available questions.
• best-question sometimes asks a roundabout question, where it should really guess a Pokémon directly. (articuno example)
• The subroutine is slow and inefficient, iterating over the same predicates multiple times at high cost.

(def fffirst (comp first first first))


(defn best-question [questions pkmns answers]  

  (if (<= (count pkmns) 1)
    ;; one pokemon remaining
    (if (empty? answers)
      [nil (str "It's " (first pkmns) "!")]
      [nil ""])

    ;; more than one pokemon remaining
    (let [half (set (take-nth 2 pkmns))

          questions
          (->>
           questions

           ;; sort by entropy, then by question length
           ((comp (partial sort-by second)
                  (partial pmap (juxt identity (complexity pkmns)))))      

           
           ;; ask a partition question if there isn't a better option
           (#(if (<= (entropy pkmns (fffirst %))
                    (+ 0.1 (entropy pkmns (comp not nil? half))))
               %
               (if (> 2 (count pkmns)) ;; how large is the group?
                 (conj %
                      [[(comp not nil? half)
                        (str "Is it " (first half) "?")]])
                 (conj %
                       [[(comp not nil? half)
                         (str "Is it one of these: " (vec half) "?")]]))))
           
           
           )
          
          ;; separate matching and non-matching pokemon
          pred (fffirst questions)

          [ins outs] (reduce
                      (fn [[ins outs] x]
                        (if (pred x)
                          [(conj ins x) outs]
                          [ins (conj outs x)]))
                      [[][]]
                      pkmns)


          ;; ask if it's a specific pokemon, if it would be equivalent to the
          ;; best question you could ask.
          questions
          (pmap first
                (cond (= 1 (count ins))
                      (cons
                       [[pred (str "Is it " (first ins) "?")]]
                       questions)
                      
                      (= 1 (count outs))
                      (cons
                       [[(comp not pred) (str "Is it " (first outs) "?")]]
                       questions)
                      
                      :else
                      questions))
          ]


      

      
      (if (empty? answers)
        (do (println)
        (first questions))
        (do (println (str (second(first questions)) "\t" (first answers))) 
        (recur (rest questions)
               (filter
                (comp (partial = (first answers))
                      (ffirst questions))
                pkmns)
                (rest answers)))))))

(defn auto-question [questions pkmns pkmn!]
  (do (println (.toUpperCase (str pkmn!)))
  (loop [qns []
         ans []]
    (let [x (best-question questions pokemon ans)]
      (if (nil? (first x))
        (map vector (conj qns (second x)) (conj ans nil))
        (recur (conj qns (second x))
               (conj ans ((first x) pkmn!))))))))

(def count-auto
  (comp count
        (partial auto-question questions-2 pokemon)))