pokemon-types: org/types.org comparison

comparison org/types.org @ 7:d6b8dab05d9d

better explination of dual types

author	Robert McIntyre <rlm@mit.edu>
date	Wed, 02 Nov 2011 06:48:40 -0700
parents	3f26fc68ffbc
children	4f9ef752e2f0

comparison

equal deleted inserted replaced

-:3f26fc68ffbc
+:d6b8dab05d9d
-#+TITLE: Breadth-first Search for Effective Pokemon Types
+#+TITLE: Best-First Search for Effective Pokemon Types
 #+AUTHOR:    Robert McIntyre & Dylan Holmes
 #+EMAIL:     rlm@mit.edu
+#+description: Finding interesting pokemon type combinations through Best-First search in clojure.
 #+SETUPFILE: ../../aurellem/org/setup.org
 #+INCLUDE:   ../../aurellem/org/level-0.org
 * The Pok\eacute{}mon Type System
 introduction of pok\eacute{}mon Gold and Silver, and has been in use
 ever since.  It is called the /Generation II Type System/.
 Here are the the definitions of the two type systems.
-* The Pok\eacute{}mon Type Systems
+* Generation I and II Type System Data
 ** Generation II Type System
 #+label: pokemon-matchups
 #+tblname: pokemon-table-gen-two
 |          | normal | fire | water | electric | grass | ice | fighting | poison | ground | flying | psychic | bug | rock | ghost | dragon | dark | steel |
 The rows are attack types, while the columns are defense types.  To
 see the multiplier for a pokemon attack against a certain type, follow
 the row for the attack type to the column of the defending type.
 ** Generation I Type System
-#+label: pokemon-matchups-gen-1 +tblname: pokemon-table-gen-one
+#+label: pokemon-matchups-gen-1
+#+tblname: pokemon-table-gen-one
 |          | normal | fire | water | electric | grass | ice | fighting | poison | ground | flying | psychic | bug | rock | ghost | dragon |
 |----------+--------+------+-------+----------+-------+-----+----------+--------+--------+--------+---------+-----+------+-------+--------|
 | normal   |      1 |    1 |     1 |        1 |     1 |   1 |        1 |      1 |      1 |      1 |       1 |   1 |   .5 |     0 |      1 |
 | fire     |      1 |   .5 |    .5 |        1 |     2 |   2 |        1 |      1 |      1 |      1 |       1 |   2 |   .5 |     1 |     .5 |
 | water    |      1 |    2 |    .5 |        1 |    .5 |   1 |        1 |      1 |      2 |      1 |       1 |   1 |    2 |     1 |     .5 |
 | dragon   |      1 |    1 |     1 |        1 |     1 |   1 |        1 |      1 |      1 |      1 |       1 |   1 |    1 |     1 |      2 |
 This is the old table from Generation I. The differences from
 Generation II are:
-- Dark and Steel are missing.
+- Dark and Steel types are missing (these were introduced in
-- Bug is super-effective against Poison.
+Generation II).
-- Poison is super-effective against Bug.
+- Bug is super-effective against Poison (not-very-effective in
-- Bug is regularly effective against Ghost (instead of
+Generation II).
-super-effective like in Generation II).
+- Poison is super-effective against Bug (normal in Generation II).
-- Ice is normally effective against Fire, (it's not-very-effective in
+- Bug is regularly effective against Ghost (super-effective in
+Generation II).
+- Ice is normally effective against Fire, (not-very-effective in
 Generation II).
 - Ghost is completely ineffective against Psychic. This is considered
 to be a programning glitch.
 * Representing the Data
-After creating the Pok\eacute{}mon types namespace, we store the table
+After creating the Pok\eacute{}mon types namespace, we store the
-of susceptibilities in =pokemon-table-gen-one= and
+tables of susceptibilities above in =pokemon-table-gen-one= and
 =pokemon-table-gen-two=, each of which is a simple vector of
 vectors. Because a vector of vectors can be cumbersome, we do not
 access the tables directly; instead, we use the derivative structures
 =attack-strengths= and =defense-strengths=, which are functions which
 return hash-maps associating each row (respectively column) of the
 table with its corresponding Pok\eacute{}mon type.
 #+srcname: header
 #+begin_src clojure :results silent
 (ns pokemon.types
-(:use rlm.ns-rlm))
+(:use clojure.set)
-(rlm.ns-rlm/ns-clone rlm.light-base)
+(:use clojure.contrib.combinatorics)
-(use 'clojure.set)
+(:use clojure.contrib.math)
-#+end_src
+(:use clojure.contrib.def)
+(:use rlm.rlm-commands))
-#+srcname: data(pokemon-table-gen-one=pokemon-table-gen-one, pokemon-table-gen-two=pokemon-table-gen-two)
+#+end_src
+#+srcname: data
 #+begin_src clojure :results silent
 (in-ns 'pokemon.types)
 ;; record type strengths as a vector of vectors
+;; the variables pokemon-table-gen-one and pokemon-table-gen-two
+;; are replaced with the tables above when this file is tangled.
 (def pokemon-gen-one pokemon-table-gen-one)
 (def pokemon-gen-two pokemon-table-gen-two)
 (defn type-names [] (vec (doall (map (comp keyword first) pokemon-gen-two))))
 (zipmap (type-names)
 	     (map
 	      (apply juxt (map (attack-strengths) (type-names)))
 	      (range (count (type-names))))))
 #+end_src
+The two statements
+#+begin_src clojure :exports code
+(def pokemon-gen-one pokemon-table-gen-one)
+(def pokemon-gen-two pokemon-table-gen-two)
+#+end_src
+probably look weird.  When the actual source file is created, those
+variables are replaced with the data from the tables above.
+See [[../src/pokemon/types.clj][types.clj]] to look at the final tangled output.
 #+begin_src clojure :results output :exports both
 (clojure.pprint/pprint pokemon.types/pokemon-gen-two)
 #+end_src
 ("dragon" 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 0.5)
 ("dark" 1 1 1 1 1 1 0.5 1 1 1 2 1 1 2 1 0.5 0.5)
 ("steel" 1 0.5 0.5 0.5 1 2 1 1 1 1 1 1 2 1 1 1 0.5))
 #+end_example
-=pokemon-gen-two= is a simple list-of-list data structure.
+=pokemon-gen-two= is a simple list-of-lists data structure.
 #+begin_src clojure :results output :exports both
 (clojure.pprint/pprint (pokemon.types/defense-strengths))
 #+end_src
 :dark [1 1 1 1 1 1 2 1 1 1 0 2 1 0.5 1 0.5 1],
 :steel [0.5 2 1 1 0.5 0.5 2 0 2 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5],
 :bug [1 2 1 1 0.5 1 0.5 1 0.5 2 1 1 2 1 1 1 1]}
 #+end_example
-=defense-strengths= is a more convenient form of =pokemon-gen-two=, with key/value pair access.
+=defense-strengths= is a more convenient form of =pokemon-gen-two=,
+with key/value pair access.
 * Interfacing with the Data
+In the pok\eacute{}mon games, a pok\eacute{}mon can have up to two
+types at the same time.  For example, Zapdos, the fearsome legendary
+that can control lightning, has both the Electric and Flying types. A
+pok\eacute{}mon with more than one type gains the advantages and
+disadvanteags of both types.  The suceptibilitys of each type are
+multiplied together to produce the hybrid type's susceptibilities. For
+example, Electric is weak to Ground (susceptibility of 2), but Flying
+is immune to Ground (suceptibility of 0). Zapdos' type,
+Electrig/Flying, is immune to Ground because $2 \times 0 = 0$.
 #+srcname: types
 #+begin_src clojure :results silent
 (in-ns 'pokemon.types)
 (defn multitypes "All combinations of up to n types" [n]
 (map vec
 	(reduce concat
 		(map (partial combinations (type-names))
 		     (range 1 (inc n)))))))
-(defn susceptibility ;; susceptibility-map
+(defn susceptibility
 "Hash-map of the susceptibilities of the given type combination
 to each type of attack"
 [pkmn-types]
 (rlm.map-utils/map-vals
 clojure.core/rationalize
 (apply hash-map
 	  (interleave (type-names)
 		      (apply (partial map *)
 			     (map (defense-strengths) pkmn-types))))))
-(defn susceptance ;; susceptibility
+(defn susceptance
 "The cumulative susceptibility of the given type combination"
 [types]
-(reduce + (map sqr (vals (susceptibility types)))))
+(reduce + (map #(expt % 2) (vals (susceptibility types)))))
 #+end_src
+Now we can work out the suceptability of Zapdos automatically.
+Electric is weak to Ground.
+#+begin_src clojure :exports both
+(:ground (pokemon.types/susceptibility [:electric]))
+#+end_src
+#+results:
+: 2
+Flying is immune to Ground.
+#+begin_src clojure :exports both
+(:ground (pokemon.types/susceptibility [:flying]))
+#+end_src
+#+results:
+: 0
+Together, they are immune to Ground.
+#+begin_src clojure :exports both
+(:ground (pokemon.types/susceptibility [:electric :flying]))
+#+end_src
+#+results:
+: 0
 * Best-First Search
 I'd like to find type combinations that are interesting, but the total
 number of combinations gets huge as we begin to consider more
 types. For example, the total possible number of type combinations
-given just 8 possible types is: 17^{8} = 6975757441 combinations.
+given just 8 possible types is: 17^{8} = 6,975,757,441 combinations.
 Therefore, it's prudent to use search.
 These functions are a simple implementation of best-first search in
 clojure. The idea to start off with a collection of nodes and some way
 of finding the best node, and to always expand the best node at every

Mercurial > pokemon-types

comparison org/types.org @ 7:d6b8dab05d9d