oakdex-battle 0.0.1

data/lib/oakdex/battle/move.rb

@@ -0,0 +1,27 @@
+require 'forwardable'
+
+module Oakdex
+  class Battle
+    # Represents Pokemon Move with PP
+    class Move
+      extend Forwardable
+
+      attr_reader :max_pp
+      attr_accessor :pp
+
+      def_delegators :@move_type, :target, :priority, :accuracy,
+                     :category, :power, :type, :stat_modifiers,
+                     :in_battle_properties
+
+      def initialize(move_type, pp, max_pp)
+        @move_type  = move_type
+        @pp         = pp
+        @max_pp     = max_pp
+      end
+
+      def name
+        @move_type.names['en']
+      end
+    end
+  end
+end

data/lib/oakdex/battle/move_execution.rb

@@ -0,0 +1,148 @@
+require 'forwardable'
+
+module Oakdex
+  class Battle
+    # Represents one Action. One turn has many actions.
+    class MoveExecution
+      RECALL_PRIORITY = 6
+
+      extend Forwardable
+
+      def_delegators :@action, :battle, :turn, :pokemon,
+                     :move, :trainer
+
+      attr_reader :action, :target
+
+      def initialize(action, target)
+        @action = action
+        @target = target
+      end
+
+      def hitting_probability
+        ((move.accuracy / 100.0) * (pokemon.accuracy / target.evasion)) * 1000
+      end
+
+      def hitting?
+        @hitting = rand(1..1000) <= hitting_probability ? 1 : 0
+        @hitting == 1
+      end
+
+      def execute
+        return if prevented_by_status_condition?
+        pokemon.change_pp_by(move.name, -1)
+        if hitting?
+          add_uses_move_log
+          execute_damage
+          execute_stat_modifiers
+          execute_status_conditions
+          execute_status_condition_callbacks
+        else
+          add_move_does_not_hit_log
+        end
+
+        battle.remove_fainted
+      end
+
+      private
+
+      def prevented_by_status_condition?
+        pokemon.status_conditions.reduce(false) do |res, condition|
+          res || condition.prevents_move?(self)
+        end
+      end
+
+      def execute_status_condition_callbacks
+        return if move.power.zero?
+        target.status_conditions.each do |c|
+          c.after_received_damage(self)
+        end
+      end
+
+      def execute_status_conditions
+        status_conditions.each do |condition|
+          execute_status_condition(condition)
+        end
+      end
+
+      def status_conditions
+        return [] if move.in_battle_properties.nil?
+        move.in_battle_properties['status_conditions'] || []
+      end
+
+      def execute_status_condition(condition)
+        return unless rand(1..100) <= condition['probability']
+        add_target_condition_added(condition['condition'])
+        target.add_status_condition(condition['condition'])
+      end
+
+      def execute_stat_modifiers
+        return if move.stat_modifiers.empty?
+        move.stat_modifiers.each do |stat_modifier|
+          modifier_target = stat_modifier['affects_user'] ? pokemon : target
+          stat = stat_modifier['stat']
+          stat = random_stat if stat == 'random'
+          if modifier_target.change_stat_by(stat.to_sym,
+                                            stat_modifier['change_by'])
+            add_changes_stat_log(modifier_target, stat,
+                                 stat_modifier['change_by'])
+          else
+            add_changes_no_stat_log(modifier_target, stat,
+                                    stat_modifier['change_by'])
+          end
+        end
+      end
+
+      def execute_damage
+        return if move.power.zero?
+        @damage = Damage.new(turn, self)
+        if @damage.damage > 0
+          add_received_damage_log
+          target.change_hp_by(-@damage.damage)
+        else
+          add_received_no_damage_log
+        end
+      end
+
+      def random_stat
+        (Pokemon::BATTLE_STATS + Pokemon::OTHER_STATS).sample
+      end
+
+      def add_log(*args)
+        battle.add_to_log(*args)
+      end
+
+      def add_changes_stat_log(target, stat, change_by)
+        add_log 'changes_stat', target.trainer.name, target.name,
+                stat, change_by
+      end
+
+      def add_changes_no_stat_log(target, stat, change_by)
+        add_log 'changes_no_stat', target.trainer.name, target.name,
+                stat, change_by
+      end
+
+      def add_target_condition_added(condition_name)
+        add_log 'target_condition_added', target.trainer.name, target.name,
+                condition_name
+      end
+
+      def add_uses_move_log
+        add_log 'uses_move', trainer.name, pokemon.name, move.name
+      end
+
+      def add_move_does_not_hit_log
+        add_log 'move_does_not_hit', trainer.name, pokemon.name, move.name
+      end
+
+      def add_received_damage_log
+        add_log 'received_damage', target.trainer.name, target.name,
+                move.name, @damage.damage
+      end
+
+      def add_received_no_damage_log
+        add_log 'received_no_damage', target.trainer.name, target.name,
+                move.name
+      end
+    end
+  end
+end

data/lib/oakdex/battle/pokemon.rb

@@ -0,0 +1,168 @@
+require 'forwardable'
+require 'oakdex/battle/pokemon_stat'
+require 'oakdex/battle/move'
+require 'oakdex/battle/pokemon_factory'
+require 'oakdex/battle/status_conditions'
+
+module Oakdex
+  class Battle
+    # Represents detailed pokemon instance
+    class Pokemon
+      extend Forwardable
+
+      BATTLE_STATS = %i[hp atk def sp_atk sp_def speed]
+      OTHER_STATS = %i[accuracy evasion critical_hit]
+      STATUS_CONDITIONS = {
+        'poison' => StatusConditions::Poison,
+        'burn' => StatusConditions::Burn,
+        'freeze' => StatusConditions::Freeze,
+        'paralysis' => StatusConditions::Paralysis,
+        'badly_poisoned' => StatusConditions::BadlyPoisoned,
+        'sleep' => StatusConditions::Sleep
+      }
+
+      def_delegators :@species, :types
+
+      attr_accessor :trainer
+
+      def self.create(species_name, options = {})
+        species = Oakdex::Pokedex::Pokemon.find!(species_name)
+        Oakdex::Battle::PokemonFactory.create(species, options)
+      end
+
+      def initialize(species, attributes = {})
+        @species = species
+        @attributes = attributes
+        @attributes[:status_conditions] ||= []
+        reset_stats
+      end
+
+      def name
+        @species.names['en']
+      end
+
+      def moves
+        @attributes[:moves]
+      end
+
+      def current_hp
+        @attributes[:hp]
+      end
+
+      def status_conditions
+        @attributes[:status_conditions]
+      end
+
+      def moves_with_pp
+        moves.select { |m| m.pp > 0 }
+      end
+
+      def change_hp_by(hp_change)
+        @attributes[:hp] = if hp_change < 0
+                             [@attributes[:hp] + hp_change, 0].max
+                           else
+                             [@attributes[:hp] + hp_change, hp].min
+                           end
+      end
+
+      def change_pp_by(move_name, pp_change)
+        move = moves.find { |m| m.name == move_name }
+        return unless move
+        move.pp = if pp_change < 0
+                    [move.pp + pp_change, 0].max
+                  else
+                    [move.pp + pp_change, move.max_pp].min
+                  end
+      end
+
+      def change_stat_by(stat, change_by)
+        modifiers = stage_multipliers(stat)
+        stat_before = @stat_modifiers[stat]
+        min_value = modifiers.keys.first
+        max_value = modifiers.keys.last
+        @stat_modifiers[stat] = if change_by < 0
+                                  [stat_before + change_by, min_value].max
+                                else
+                                  [stat_before + change_by, max_value].min
+                                end
+        stat_before != @stat_modifiers[stat]
+      end
+
+      def add_status_condition(condition_name)
+        @attributes[:status_conditions] << status_condition(condition_name)
+      end
+
+      def remove_status_condition(condition)
+        @attributes[:status_conditions] = @attributes[:status_conditions]
+          .reject { |s| s == condition }
+      end
+
+      def reset_stats
+        @stat_modifiers = (BATTLE_STATS + OTHER_STATS - %i[hp]).map do |stat|
+          [stat, 0]
+        end.to_h
+      end
+
+      def level
+        PokemonStat.level_by_exp(@species.leveling_rate, @attributes[:exp])
+      end
+
+      def accuracy
+        stage(:accuracy)
+      end
+
+      def evasion
+        stage(:evasion)
+      end
+
+      def critical_hit_prob
+        stage(:critical_hit)
+      end
+
+      BATTLE_STATS.each do |stat|
+        define_method stat do
+          (initial_stat(stat) * stage(stat) *
+            status_condition_modifier(stat)).to_i
+        end
+      end
+
+      private
+
+      def status_condition_modifier(stat)
+        status_conditions.reduce(1.0) do |modifier, condition|
+          condition.stat_modifier(stat) * modifier
+        end
+      end
+
+      def status_condition(condition_name)
+        STATUS_CONDITIONS[condition_name].new(self)
+      end
+
+      def stage(stat)
+        multipliers = stage_multipliers(stat)
+        multipliers[@stat_modifiers[stat] || 0]
+      end
+
+      def initial_stat(stat)
+        PokemonStat.initial_stat(stat,
+                                 level:      level,
+                                 nature:     @attributes[:nature],
+                                 iv:         @attributes[:iv],
+                                 ev:         @attributes[:ev],
+                                 base_stats: @species.base_stats
+                                )
+      end
+
+      def stage_multipliers(stat)
+        case stat
+        when :evasion, :accuracy
+          PokemonStat::STAGE_MULTIPLIERS_ACC_EVA
+        when :critical_hit
+          PokemonStat::STAGE_MULTIPLIERS_CRITICAL_HIT
+        else
+          PokemonStat::STAGE_MULTIPLIERS
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/pokemon_factory.rb

@@ -0,0 +1,118 @@
+module Oakdex
+  class Battle
+    # Creates Pokemon instance and prefills attributes
+    class PokemonFactory
+      ATTRIBUTES = %i[exp gender ability nature hp iv ev moves]
+
+      class << self
+        def create(species, options = {})
+          factory = new(species, options)
+          attributes = Hash[ATTRIBUTES.map do |attr|
+            [attr, factory.send(attr)]
+          end]
+          Pokemon.new(species, attributes)
+        end
+      end
+
+      def initialize(species, options = {})
+        @species = species
+        @options = options
+      end
+
+      private
+
+      def moves
+        if @options[:moves]
+          @options[:moves].map do |move_data|
+            Move.new(
+              Oakdex::Pokedex::Move.find!(move_data[0]),
+              move_data[1],
+              move_data[2]
+            )
+          end
+        else
+          available_moves.sample(4).map do |move_name|
+            move_type = Oakdex::Pokedex::Move.find!(move_name)
+            Move.new(move_type, move_type.pp, move_type.pp)
+          end
+        end
+      end
+
+      def available_moves
+        @species.learnset.map do |m|
+          m['move'] if m['level'] && m['level'] <= level
+        end.compact
+      end
+
+      def ability
+        if @options['ability']
+          Oakdex::Pokedex::Ability.find!(@options['ability'])
+        else
+          Oakdex::Pokedex::Ability.find!(abilities.sample['name'])
+        end
+      end
+
+      def abilities
+        @species.abilities.select { |a| !a['hidden'] && !a['mega'] }
+      end
+
+      def exp
+        @options[:exp] || PokemonStat.exp_by_level(
+          @species.leveling_rate,
+          @options[:level]
+        )
+      end
+
+      def level
+        PokemonStat.level_by_exp(@species.leveling_rate, exp)
+      end
+
+      def hp
+        return @options[:hp] if @options[:hp]
+        PokemonStat.initial_stat(:hp,
+                                 level: level,
+                                 iv: iv,
+                                 ev: ev,
+                                 base_stats: @species.base_stats,
+                                 nature: nature
+                                )
+      end
+
+      def iv
+        return @options[:iv] if @options[:iv]
+        @iv ||= Hash[Pokemon::BATTLE_STATS.map do |stat|
+          [stat, rand(0..31)]
+        end]
+      end
+
+      def ev
+        return @options[:ev] if @options[:ev]
+        @ev ||= Hash[Pokemon::BATTLE_STATS.map do |stat|
+          [stat, 0]
+        end]
+      end
+
+      def gender
+        return @options[:gender] if @options[:gender]
+        return 'neuter' unless @species.gender_ratios
+        calculate_gender
+      end
+
+      def calculate_gender
+        if rand(1..1000) <= @species.gender_ratios['male'] * 10
+          'male'
+        else
+          'female'
+        end
+      end
+
+      def nature(options = {})
+        @nature ||= if options[:nature]
+                      Oakdex::Pokedex::Nature.find!(options[:nature])
+                    else
+                      Oakdex::Pokedex::Nature.all.values.sample
+                    end
+      end
+    end
+  end
+end