oakdex-battle 0.0.2 → 0.1.0

data/lib/oakdex/battle/pokemon_factory.rb

@@ -1,130 +0,0 @@
-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
-          (generate_available_moves + additional_moves).take(4)
-        end
-      end
-
-      def generate_available_moves
-        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
-
-      def additional_moves
-        return [] unless @options[:additional_moves]
-        @options[:additional_moves].map do |move_name|
-          move_type = Oakdex::Pokedex::Move.find!(move_name)
-          Move.new(move_type, move_type.pp, move_type.pp)
-        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

data/lib/oakdex/battle/pokemon_stat.rb

@@ -1,109 +0,0 @@
-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