(ns com.aurellem.gb.moves

   (:use (com.aurellem.gb gb-driver util constants))

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

 

 (def move-code->move-name

   {

    0x00   :end-of-moves

    0x01   :pound

    0x02   :karate-chop

    0x03   :doubleslap

    0x04   :comet-punch

    0x05   :mega-punch

    0x06   :pay-day

    0x07   :fire-punch

    0x08   :ice-punch

    0x09   :thunderpunch

    0x0A   :scratch

    0x0B   :vicegrip

    0x0C   :guillotine

    0x0D   :razor-wind

    0x0E   :swords-dance

    0x0F   :cut

    0x10   :gust

    0x11   :wing-attack

    0x12   :whirlwind

    0x13   :fly

    0x14   :bind

    0x15   :slam

    0x16   :vine-whip

    0x17   :stomp

    0x18   :double-kick

    0x19   :mega-kick

    0x1A   :jump-kick

    0x1B   :rolling-kick

    0x1C   :sand-attack

    0x1D   :headbutt

    0x1E   :horn-attack

    0x1F   :fury-attack

    0x20   :horn-drill

    0x21   :tackle

    0x22   :body-slam

    0x23   :wrap

    0x24   :take-down

    0x25   :thrash

    0x26   :double-edge

    0x27   :tail-whip

    0x28   :poison-sting

    0x29   :twinneedle

    0x2A   :pin-missle

    0x2B   :leer

    0x2C   :bite

    0x2D   :growl

    0x2E   :roar

    0x2F   :sing

    0x30   :supersonic

    0x31   :sonicboom

    0x32   :disable

    0x33   :acid

    0x34   :ember

    0x35   :flamethrower

    0x36   :mist

    0x37   :water-gun

    0x38   :hydro-pump

    0x39   :surf

    0x3A   :ice-beam

    0x3B   :blizzard

    0x3C   :psybeam

    0x3D   :bubblebeam

    0x3E   :aurora-beam

    0x3F   :hyper-beam

    0x40   :peck

    0x41   :drill-peck

    0x42   :submission

    0x43   :low-kick

    0x44   :counter

    0x45   :seismic-toss

    0x46   :strength

    0x47   :absorb

    0x48   :mega-drain

    0x49   :leech-seed

    0x4A   :growth

    0x4B   :razor-leaf

    0x4C   :solarbeam

    0x4D   :poisonpowder

    0x4E   :stun-spore

    0x4F   :sleep-powder

    0x50   :petal-dance

    0x51   :string-shot

    0x52   :dragon-rage

    0x53   :fire-spin

    0x54   :thundershock

    0x55   :thunderbolt

    0x56   :thunder-wave

    0x57   :thunder

    0x58   :rock-throw

    0x59   :earthquake

    0x5A   :fissure

    0x5B   :dig

    0x5C   :toxic

    0x5D   :confusion

    0x5E   :psychic

    0x5F   :hypnosis

    0x60   :meditate

    0x61   :agility

    0x62   :quick-attack

    0x63   :rage

    0x64   :teleport

    0x65   :night-shade

    0x66   :mimic

    0x67   :screech

    0x68   :double-team

    0x69   :recover

    0x6A   :harden

    0x6B   :minimize

    0x6C   :smokescreen

    0x6D   :confuse-ray

    0x6E   :withdraw

    0x6F   :defense-curl

    0x70   :barrier

    0x71   :light-screen

    0x72   :haze

    0x73   :reflect

    0x74   :focus-energy

    0x75   :bide

    0x76   :metronome

    0x77   :mirror-move

    0x78   :selfdestruct

    0x79   :egg-bomb

    0x7A   :lick

    0x7B   :smog

    0x7C   :sludge

    0x7D   :bone-club

    0x7E   :fire-blast

    0x7F   :waterfall

    0x80   :clamp

    0x81   :swift

    0x82   :skull-bash

    0x83   :spike-cannon

    0x84   :constrict

    0x85   :amnesia

    0x86   :kinesis

    0x87   :softboiled

    0x88   :hi-jump-kick

    0x89   :glare

    0x8A   :dream-eater

    0x8B   :poison-gas

    0x8C   :barrage

    0x8D   :leech-life

    0x8E   :lovely-kiss

    0x8F   :sky-attack

    0x90   :transform

    0x91   :bubble

    0x92   :dizzy-punch

    0x93   :spore

    0x94   :flash

    0x95   :psywave

    0x96   :splash

    0x97   :acid-armor

    0x98   :crabhammer

    0x99   :explosion

    0x9A   :fury-swipes

    0x9B   :bonemerang

    0x9C   :rest

    0x9D   :rock-slide

    0x9E   :hyper-fang

    0x9F   :sharpen

    0xA0   :conversion

    0xA1   :tri-attack

    0xA2   :super-fang

    0xA3   :slash

    0xA4   :substitute

    0xA5   :struggle       })

 

 (def move-name->move-code

   (zipmap (vals move-code->move-name)

           (keys move-code->move-name)))

 

 (def moves-codes-pokemon-1 0xD172)

 

 (defn moves-codes-start [pokemon-num]

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

   (+ moves-codes-pokemon-1

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

 

 (defn read-moves

   ([^SaveState state poke-num]

      (let [start (moves-codes-start poke-num)]

        (vec

         (take-while

          (partial not= :end-of-moves)

          (map

           move-code->move-name

           (subvec (vec (memory state))

                   start (+ start 4)))))))

   ([poke-num]

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

              

 (defn give-moves

   ([^SaveState state pokemon-num moves]

      (assert (<= (count moves) 4))

      (set-memory-range

       state

       (moves-codes-start pokemon-num)

       (map #(move-name->move-code % %)

            (concat moves

                    (repeat (- 4 (count moves)) :end-of-moves)))))

   ([pokemon-num moves]

      (give-moves @current-state pokemon-num moves))

   ([moves]

      (give-moves 0 moves)))

 

 ;; Note regarding PP of moves -- both the current PP and the

 ;; total PP are stored in the same value.

 ;; they are bit-packed, with the first 2 bits containing the

 ;; number of pp-ups that have been applied, and the next

 ;; six bits containing the current pp of the move.

 ;; thus, a move can have up to 63 current pp and up to

 ;; three pp-ups applied.

 

 (def pokemon-1-pp-start 0xD187)

 

 (defn moves-pp-start [pokemon-num]

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

   (+ pokemon-1-pp-start (* pokemon-num pokemon-record-width)))

 

 (defn read-pp

   ([^SaveState state pokemon-num move-num]

      (assert (<= 0 move-num 3))

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

      (let [pp-raw

            (aget (memory state)

                  (+ (moves-pp-start pokemon-num)

                     move-num))

            pp-up

            (bit-shift-right

             (bit-and

              pp-raw

              (Integer/parseInt "11000000" 2)) 6)

            current-pp

            (bit-and

             pp-raw

             (Integer/parseInt "00111111" 2))]

        {:pp-ups pp-up :current-pp current-pp}))

   ([pokemon-num move-num]

      (read-pp @current-state pokemon-num move-num)))

 

 (defn give-pp

   ([^SaveState state pokemon-num move-num pp-ups current-pp]

      (assert (<= 0 move-num 3))

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

      (assert (<= 0 pp-ups 3))

      (assert (<= 0 current-pp 63))

 

      (set-memory

       state

       (+ (moves-pp-start pokemon-num)

          move-num)

       (+

        (bit-shift-left pp-ups 6)

        (bit-and (Integer/parseInt

                  "00111111" 2)

                 current-pp))))

   ([pokemon-num move-num pp-ups current-pp]

      (give-pp @current-state

              pokemon-num move-num pp-ups current-pp)))

 

 (defn give-moves-pps

   ([^SaveState state poke-num moves-pps]

      (let [new-moves

            (-> state

                ;; zero out the pp of the pokemon's moves

                (give-pp poke-num 0 0 0)

                (give-pp poke-num 1 0 0)

                (give-pp poke-num 2 0 0)

                (give-pp poke-num 3 0 0)

                (give-moves poke-num (map first moves-pps)))]

        (reduce (fn [state move-num]

                  (let [pp (second (nth moves-pps move-num))]

                    (give-pp state poke-num move-num

                             (:pp-ups pp)

                             (:current-pp    pp))))

                new-moves (range (count moves-pps)))))

   ([poke-num moves-pps]

      (give-moves-pps @current-state poke-num moves-pps)))

            

 

 (def move-name->move-pp

   {

    :absorb        20

    :acid          30

    :acid-armor    40 ;; WTF happens with 3 PP-UPs??! (answer: 61PP!)

    :agility       30

    :amnesia       20

    :aurora-beam   20

    :barrage       20

    :barrier       30

    :bide          10

    :bind          20

    :bite          25

    :blizzard       5 

    :body-slam     15

    :bone-club     20

    :bonemerang    10

    :bubble        30

    :bubblebeam    20

    :clamp         10

    :comet-punch   15

    :confuse-ray   10

    :confusion     25

    :constrict     35

    :conversion    30

    :counter       20

    :crabhammer    10

    :cut           30

    :defense-curl  40

    :dig           10

    :disable       20

    :dizzy-punch   10

    :double-edge   15

    :double-kick   30

    :double-team   10

    :doubleslap    15

    :dragon-rage   10

    :dream-eater   15

    :drill-peck    20

    :earthquake    10

    :egg-bomb      10

    :ember         25

    :explosion      5

    :fire-blast     5

    :fire-punch    15

    :fire-spin     15

    :fissure        5

    :flamethrower  15

    :flash         20

    :fly           15

    :focus-energy  30

    :fury-attack   20

    :fury-swipes   15

    :glare         30

    :growl         40

    :growth        40

    :guillotine     5

    :gust          35

    :harden        30

    :haze          30

    :headbutt      15

    :hi-jump-kick  20

    :horn-attack   25

    :horn-drill     5

    :hydro-pump     5

    :hyper-beam     5

    :hyper-fang    15

    :hypnosis      20

    :ice-beam      10

    :ice-punch     15

    :jump-kick     25

    :karate-chop   25

    :kinesis       15

    :leech-life    15

    :leech-seed    10

    :leer          30

    :lick          30

    :light-screen  30

    :lovely-kiss   10

    :low-kick      20

    :meditate      40

    :mega-drain    10

    :mega-kick      5

    :mega-punch    20

    :metronome     10

    :mimic         10

    :minimize      20

    :mirror-move   20

    :mist          30

    :night-shade   15

    :pay-day       20

    :peck          35

    :petal-dance   20

    :pin-missle    20

    :poison-gas    40

    :poison-sting  35

    :poisonpowder  35

    :pound         35

    :psybeam       20

    :psychic       10

    :psywave       15

    :quick-attack  30

    :rage          20

    :razor-leaf    25

    :razor-wind    10

    :recover       20

    :reflect       20

    :rest          10

    :roar          20

    :rock-slide    10

    :rock-throw    15

    :rolling-kick  15

    :sand-attack   15

    :scratch       35

    :screech       40

    :seismic-toss  20

    :selfdestruct   5

    :sharpen       30

    :sing          15

    :skull-bash    15

    :sky-attack     5

    :slam          20

    :slash         20

    :sleep-powder  15

    :sludge        20

    :smog          20

    :smokescreen   20

    :softboiled    10

    :solarbeam     10

    :sonicboom     20

    :spike-cannon  15

    :splash        40

    :spore         15

    :stomp         20

    :strength      15

    :string-shot   40

    :struggle       1

    :stun-spore    30

    :submission    25

    :substitute    10

    :super-fang    10

    :supersonic    20

    :surf          15

    :swift         20

    :swords-dance  30

    :tackle        35

    :tail-whip     30

    :take-down     20

    :teleport      20

    :thrash        20

    :thunder       10

    :thunder-wave  20

    :thunderbolt   15

    :thunderpunch  15

    :thundershock  30

    :toxic         10

    :transform     10

    :tri-attack    10

    :twinneedle    20

    :vicegrip      30

    :vine-whip     10

    :water-gun     25

    :waterfall     15

    :whirlwind     20

    :wing-attack   35

    :withdraw      40

    :wrap          20})

 

 (defn max-pp [name pp-ups]

   (if (= 40 (move-name->move-pp name))

     (+ 40 (* 7 pp-ups))

     (int (* (+ 1 (* (/ 1 5) pp-ups))

             (move-name->move-pp name)))))