oakdex-battle 0.0.1

data/lib/oakdex/battle/pokemon_stat.rb

@@ -0,0 +1,109 @@
+module Oakdex
+  class Battle
+    # Calculates Pokemon Stats
+    class PokemonStat
+      STAGE_MULTIPLIERS = {
+        -6 => Rational(2, 8),
+        -5 => Rational(2, 7),
+        -4 => Rational(2, 6),
+        -3 => Rational(2, 5),
+        -2 => Rational(2, 4),
+        -1 => Rational(2, 3),
+        0 => Rational(2, 2),
+        1 => Rational(3, 2),
+        2 => Rational(4, 2),
+        3 => Rational(5, 2),
+        4 => Rational(6, 2),
+        5 => Rational(7, 2),
+        6 => Rational(8, 2)
+      }
+
+      STAGE_MULTIPLIERS_CRITICAL_HIT = {
+        0 => Rational(1, 24),
+        1 => Rational(1, 8),
+        2 => Rational(1, 2),
+        3 => Rational(1, 1)
+      }
+
+      STAGE_MULTIPLIERS_ACC_EVA = {
+        -6 => Rational(3, 9),
+        -5 => Rational(3, 8),
+        -4 => Rational(3, 7),
+        -3 => Rational(3, 6),
+        -2 => Rational(3, 5),
+        -1 => Rational(3, 4),
+        0 => Rational(3, 3),
+        1 => Rational(4, 3),
+        2 => Rational(5, 3),
+        3 => Rational(6, 3),
+        4 => Rational(7, 3),
+        5 => Rational(8, 3),
+        6 => Rational(9, 3)
+      }
+
+      class << self
+        def initial_stat(stat, options = {})
+          first_part = initial_stat_first_part(stat, options)
+          (
+            if stat == :hp
+              first_part + options[:level] + 10
+            elsif stat.to_s == options[:nature].increased_stat
+              (first_part + 5) * 1.1
+            elsif stat.to_s == options[:nature].decreased_stat
+              (first_part + 5) * 0.9
+            else
+              first_part + 5
+            end
+          ).to_i
+        end
+
+        def exp_by_level(leveling_rate, level)
+          case leveling_rate
+          when 'Fast' then ((4.0 * level**3) / 5).to_i
+          when 'Slow' then ((5.0 * level**3) / 4).to_i
+          when 'Medium Slow' then medium_slow_exp(level)
+          when 'Fluctuating' then fluctuating_exp(level)
+          else level**3
+          end
+        end
+
+        def level_by_exp(leveling_rate, exp)
+          level = 2
+          level += 1 while exp_by_level(leveling_rate, level) <= exp
+          level - 1
+        end
+
+        private
+
+        def medium_slow_exp(level)
+          (
+            ((6.0 / 5) * level**3) - 15 * level**2 + (100 * level) - 140
+          ).to_i
+        end
+
+        def fluctuating_exp(level)
+          (
+          if level <= 15
+            level**3 * ((((level + 1) / 3.0) + 24) / 50)
+          elsif level <= 36
+            level**3 * ((level + 14) / 50.0)
+          else
+            level**3 * (((level / 2.0) + 32) / 50)
+          end
+          ).to_i
+        end
+
+        def initial_stat_first_part(stat, options = {})
+          (
+            (
+              2.0 *
+              options[:base_stats][stat.to_s] +
+              options[:iv][stat] +
+              (options[:ev][stat] / 4)
+            ) * options[:level]
+          ) / 100
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/side.rb

@@ -0,0 +1,76 @@
+require 'forwardable'
+
+module Oakdex
+  class Battle
+    # Represents a side in an active battle, has n trainers
+    class Side
+      extend Forwardable
+
+      def_delegators :@battle, :add_to_log
+
+      attr_reader :trainers, :battle
+
+      def initialize(battle, trainers)
+        @battle = battle
+        @trainers = trainers
+      end
+
+      def next_position
+        left_position.first
+      end
+
+      def send_to_battle
+        @trainers.map do |trainer|
+          pokemon_per_trainer.times do |i|
+            break unless trainer.team[i]
+            trainer.send_to_battle(trainer.team[i], self)
+          end
+        end
+      end
+
+      def remove_fainted
+        @trainers.each(&:remove_fainted)
+      end
+
+      def trainer_on_side?(trainer)
+        @trainers.include?(trainer)
+      end
+
+      def pokemon_in_battle?(position)
+        in_battle_pokemon.any? do |ibp|
+          ibp.position == position
+        end
+      end
+
+      def pokemon_left?
+        !in_battle_pokemon.empty?
+      end
+
+      def in_battle_pokemon
+        @trainers.map(&:in_battle_pokemon).flatten(1)
+      end
+
+      def fainted?
+        @trainers.all?(&:fainted?)
+      end
+
+      private
+
+      def pokemon_per_trainer
+        (battle.pokemon_per_side / trainers.size)
+      end
+
+      def left_position
+        all_position - taken_positions
+      end
+
+      def taken_positions
+        in_battle_pokemon.map(&:position).sort
+      end
+
+      def all_position
+        battle.pokemon_per_side.times.to_a
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions.rb

@@ -0,0 +1,16 @@
+require 'oakdex/battle/status_conditions/base'
+require 'oakdex/battle/status_conditions/non_volatile'
+require 'oakdex/battle/status_conditions/poison'
+require 'oakdex/battle/status_conditions/burn'
+require 'oakdex/battle/status_conditions/freeze'
+require 'oakdex/battle/status_conditions/paralysis'
+require 'oakdex/battle/status_conditions/badly_poisoned'
+require 'oakdex/battle/status_conditions/sleep'
+
+module Oakdex
+  class Battle
+    # Status conditions that belong to a pokemon
+    module StatusConditions
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/badly_poisoned.rb

@@ -0,0 +1,36 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents BadlyPoisoned status condition
+      class BadlyPoisoned < NonVolatile
+        def initialize(pokemon)
+          super
+          @turn_count = 0
+        end
+
+        def after_turn(turn)
+          return if pokemon.current_hp.zero?
+          turn.battle.add_to_log('damage_by_badly_poisoned',
+                                 pokemon.trainer.name,
+                                 pokemon.name, hp_by_turn)
+          pokemon.change_hp_by(hp_by_turn)
+          @turn_count += 1
+        end
+
+        def after_switched_out(_battle)
+          @turn_count = 0
+        end
+
+        private
+
+        def hp_by_turn
+          [-(pokemon.hp * percent).to_i, -1].min
+        end
+
+        def percent
+          ([@turn_count.to_f, 15].min + 1) / 16.0
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/base.rb

@@ -0,0 +1,36 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Abstract Class Base
+      class Base
+        attr_reader :pokemon
+
+        def initialize(pokemon)
+          @pokemon = pokemon
+        end
+
+        def before_turn(turn); end
+
+        def after_turn(turn); end
+
+        def after_fainted(battle); end
+
+        def after_switched_out(battle); end
+
+        def after_received_damage(move_execution); end
+
+        def stat_modifier(_stat)
+          1.0
+        end
+
+        def damage_modifier(_move_execution)
+          1.0
+        end
+
+        def prevents_move?(_move_execution)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/burn.rb

@@ -0,0 +1,26 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Burn status condition
+      class Burn < NonVolatile
+        def after_turn(turn)
+          return if pokemon.current_hp.zero?
+          turn.battle.add_to_log('damage_by_burn',
+                                 pokemon.trainer.name,
+                                 pokemon.name, hp_by_turn)
+          pokemon.change_hp_by(hp_by_turn)
+        end
+
+        def damage_modifier(move_execution)
+          move_execution.move.category == 'physical' ? 0.5 : super
+        end
+
+        private
+
+        def hp_by_turn
+          [-(pokemon.hp / 16).to_i, -1].min
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/freeze.rb

@@ -0,0 +1,36 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Freeze status condition
+      class Freeze < NonVolatile
+        def prevents_move?(move_execution)
+          move_execution
+            .battle
+            .add_to_log('frozen',
+                        move_execution.pokemon.trainer.name,
+                        move_execution.pokemon.name)
+          true
+        end
+
+        def after_received_damage(move_execution)
+          return unless move_execution.move.type == 'fire'
+          defrost(move_execution.battle)
+        end
+
+        def before_turn(turn)
+          return unless rand(1..100) <= 20
+          defrost(turn.battle)
+        end
+
+        private
+
+        def defrost(battle)
+          pokemon.remove_status_condition(self)
+          battle.add_to_log('defrosts',
+                            pokemon.trainer.name,
+                            pokemon.name)
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/non_volatile.rb

@@ -0,0 +1,12 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Abstract Class Base NonVolatile
+      class NonVolatile < Base
+        def after_fainted(_battle)
+          pokemon.remove_status_condition(self)
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/paralysis.rb

@@ -0,0 +1,26 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Paralysis status condition
+      class Paralysis < NonVolatile
+        def stat_modifier(stat)
+          return 0.5 if stat == :speed
+          super
+        end
+
+        def prevents_move?(move_execution)
+          if rand(1..100) <= 25
+            move_execution
+              .battle
+              .add_to_log('paralysed',
+                          move_execution.pokemon.trainer.name,
+                          move_execution.pokemon.name)
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/poison.rb

@@ -0,0 +1,22 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Poison status condition
+      class Poison < NonVolatile
+        def after_turn(turn)
+          return if pokemon.current_hp.zero?
+          turn.battle.add_to_log('damage_by_poison',
+                                 pokemon.trainer.name,
+                                 pokemon.name, hp_by_turn)
+          pokemon.change_hp_by(hp_by_turn)
+        end
+
+        private
+
+        def hp_by_turn
+          [-(pokemon.hp / 8).to_i, -1].min
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/status_conditions/sleep.rb

@@ -0,0 +1,37 @@
+module Oakdex
+  class Battle
+    module StatusConditions
+      # Represents Sleep status condition
+      class Sleep < NonVolatile
+        def initialize(pokemon)
+          super
+          @turn_count = 0
+          @max_turn_count = rand(1..3)
+        end
+
+        def after_turn(turn)
+          wake_up(turn.battle) if @turn_count >= @max_turn_count
+          @turn_count += 1
+        end
+
+        def prevents_move?(move_execution)
+          move_execution
+            .battle
+            .add_to_log('sleeping',
+                        pokemon.trainer.name,
+                        pokemon.name)
+          true
+        end
+
+        private
+
+        def wake_up(battle)
+          pokemon.remove_status_condition(self)
+          battle.add_to_log('wake_up',
+                            pokemon.trainer.name,
+                            pokemon.name)
+        end
+      end
+    end
+  end
+end