oakdex-battle 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ecd31f627a41112b511d36b3f229b4f39f16c50db2f30d2152d6d8be6c2a4084
+  data.tar.gz: c4d2ff60f0bc64a148b278f8dc9493a71191298672d0f365fa0a5ce2a3e8ab61
+SHA512:
+  metadata.gz: eae5231ca258390c2d3b3f2af6979b34f66c9615ed6e55c7c636d96267cdae3f76a8a86475f19a819aa0bdda1746f6b3efb8f84c0547cbb7290099efd6889ba4
+  data.tar.gz: 5a22eb518390c80e4eb7d5ab086ef744588a11de5260043050958a2930286dca62a88efe27f957bd6fccdc2c47c397325a11f5fa143fc5ff6d04399d4f11a2b5

data/README.md

@@ -0,0 +1,103 @@
+# <img src="https://v20.imgup.net/oakdex_logfbad.png" alt="fixer" width=282>
+
+[![Build Status](https://travis-ci.org/jalyna/oakdex-battle.svg?branch=master)](https://travis-ci.org/jalyna/oakdex-battle) [![Maintainability](https://api.codeclimate.com/v1/badges/ef91681257a6900f03ac/maintainability)](https://codeclimate.com/github/jalyna/oakdex-battle/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/ef91681257a6900f03ac/test_coverage)](https://codeclimate.com/github/jalyna/oakdex-battle/test_coverage)
+
+Based on [oakdex-pokedex](https://github.com/jalyna/oakdex-pokedex).
+
+## Getting Started
+
+### 1 vs. 1
+
+```ruby
+require 'oakdex/battle'
+
+pok1 = Oakdex::Battle::Pokemon.create('Pikachu', level: 10)
+pok2 = Oakdex::Battle::Pokemon.create('Bulbasaur', {
+  exp: 120,
+  gender: 'female',
+  ability: 'Soundproof',
+  nature: 'Bashful',
+  item: 'Earth Plate',
+  hp: 2,
+  iv: {
+    hp: 8,
+    atk: 12,
+    def: 31,
+    sp_atk: 12,
+    sp_def: 5,
+    speed: 14
+  },
+  ev: {
+    hp: 8,
+    atk: 12,
+    def: 99,
+    sp_atk: 4,
+    sp_def: 12,
+    speed: 14
+  },
+  moves: [
+    ['Swords Dance', 12, 30],
+    ['Cut', 40, 44]
+  ]
+})
+
+trainer1 = Oakdex::Battle::Trainer.new('Ash', [pok1])
+trainer2 = Oakdex::Battle::Trainer.new('Misty', [pok2])
+
+battle = Oakdex::Battle.new(trainer1, trainer2)
+battle.continue # => true
+battle.log.size # => 1
+battle.log.last # => [['sends_to_battle', 'Ash', 'Pikachu'], ['sends_to_battle', 'Misty', 'Bulbasaur']]
+battle.arena # => Snapshot of current state as Hash
+battle.finished? # => false
+battle.valid_actions_for(trainer1) # => [{ action: 'move', pokemon: pok1, move: <Move>, target: pok2 }, ...]
+
+battle.add_action(trainer1, { action: 'move', pokemon: pok1, move: <Move>, target: pok2 }) # => false
+
+battle.add_action(trainer1, { action: 'move', pokemon: pok1, move: <Move>, target: pok2 }) # => true
+
+battle.valid_actions_for(trainer1) # => []
+battle.continue # => false
+battle.simulate_action(trainer2) # => true
+battle.valid_actions_for(trainer2) # => []
+battle.continue # => true
+
+battle.log.size # => 2
+battle.log.last # => [['uses_move', 'Ash', 'Pikachu', 'Thunder Shock'], ['received_damage', 'Misty', 'Bulbasaur', 'Thunder Shock'], ['uses_move', 'Misty', 'Bulbasaur', 'Leech Seed'], ['move_failed', 'Misty', 'Bulbasaur', 'Leech Seed']]
+
+# ...
+
+battle.finished? # => true
+battle.winner # => trainer1
+```
+
+
+### Other Battle types
+
+```ruby
+pok3 = Oakdex::Battle::Pokemon.create('Altaria', level: 20)
+pok4 = Oakdex::Battle::Pokemon.create('Elekid', level: 14)
+trainer1 = Oakdex::Battle::Trainer.new('Ash', [pok1, pok3, pok9])
+trainer2 = Oakdex::Battle::Trainer.new('Misty', [pok2, pok4, pok10])
+trainer3 = Oakdex::Battle::Trainer.new('Brock', [pok5, pok6])
+trainer4 = Oakdex::Battle::Trainer.new('Erika', [pok7, pok8])
+
+# 2 vs. 2
+battle = Oakdex::Battle.new([trainer1], [trainer2], pokemon_per_side: 2)
+# 3 vs. 3
+battle = Oakdex::Battle.new([trainer1], [trainer2], pokemon_per_side: 3)
+# 2 vs. 2 (1 pokemon each trainer)
+battle = Oakdex::Battle.new([trainer1, trainer3], [trainer2, trainer4])
+```
+
+## Contributing
+
+I would be happy if you want to add your contribution to the project. In order to contribute, you just have to fork this repository.
+
+## License
+
+MIT License. See the included MIT-LICENSE file.
+
+## Credits
+
+Logo Icon by [Roundicons Freebies](http://www.flaticon.com/authors/roundicons-freebies).

data/lib/oakdex.rb

@@ -0,0 +1,3 @@
+# Main Namespace Oakdex
+module Oakdex
+end

data/lib/oakdex/battle.rb

@@ -0,0 +1,111 @@
+require 'oakdex/pokedex'
+
+require 'oakdex/battle/pokemon'
+require 'oakdex/battle/trainer'
+require 'oakdex/battle/move_execution'
+require 'oakdex/battle/action'
+require 'oakdex/battle/damage'
+require 'oakdex/battle/turn'
+require 'oakdex/battle/valid_action_service'
+require 'oakdex/battle/side'
+require 'oakdex/battle/in_battle_pokemon'
+
+module Oakdex
+  # Represents battle, with has n turns and m sides
+  class Battle
+    attr_reader :log, :actions, :team1, :team2,
+                :sides, :current_log
+
+    def initialize(team1, team2, options = {})
+      @team1 = team1.is_a?(Array) ? team1 : [team1]
+      @team2 = team2.is_a?(Array) ? team2 : [team2]
+      @options = options
+      @sides = []
+      @log = []
+      @current_log = []
+      @actions = []
+      @turns = []
+    end
+
+    def pokemon_per_side
+      @options[:pokemon_per_side] || @team1.size
+    end
+
+    def arena
+      { sides: sides }
+    end
+
+    def valid_actions_for(trainer)
+      valid_action_service.valid_actions_for(trainer)
+    end
+
+    def add_action(trainer, action)
+      return false unless valid_actions_for(trainer).include?(action)
+      @actions << Action.new(trainer, action)
+      true
+    end
+
+    def simulate_action(trainer)
+      valid_actions = valid_actions_for(trainer)
+      return false if valid_actions.empty?
+      add_action(trainer, valid_actions.sample)
+    end
+
+    def continue
+      return start if sides.empty?
+      return false unless trainers.all? { |t| valid_actions_for(t).empty? }
+      execute_actions
+      true
+    end
+
+    def finished?
+      !fainted_sides.empty?
+    end
+
+    def winner
+      return if fainted_sides.empty?
+      (sides - fainted_sides).flat_map(&:trainers)
+    end
+
+    def add_to_log(*args)
+      @current_log << args.to_a
+    end
+
+    def remove_fainted
+      sides.each(&:remove_fainted)
+    end
+
+    private
+
+    def valid_action_service
+      @valid_action_service ||= ValidActionService.new(self)
+    end
+
+    def fainted_sides
+      sides.select(&:fainted?)
+    end
+
+    def start
+      @sides = [@team1, @team2].map do |team|
+        Side.new(self, team).tap(&:send_to_battle)
+      end
+      finish_turn
+      true
+    end
+
+    def execute_actions
+      @turns << Turn.new(self, @actions).tap(&:execute)
+      finish_turn
+    end
+
+    def trainers
+      sides.flat_map(&:trainers)
+    end
+
+    def finish_turn
+      @log << @current_log
+      @current_log = []
+      @actions = []
+    end
+  end
+end

data/lib/oakdex/battle/action.rb

@@ -0,0 +1,115 @@
+require 'forwardable'
+
+module Oakdex
+  class Battle
+    # Represents one Action. One turn has many actions.
+    class Action
+      RECALL_PRIORITY = 6
+
+      extend Forwardable
+
+      def_delegators :@turn, :battle
+
+      attr_reader :trainer, :damage, :turn
+
+      def initialize(trainer, attributes)
+        @trainer = trainer
+        @attributes = attributes
+      end
+
+      def priority
+        move&.priority || RECALL_PRIORITY
+      end
+
+      def pokemon
+        recall? ? pokemon_by_position : @attributes[:pokemon]
+      end
+
+      def pokemon_position
+        recall? ? @attributes[:pokemon] : nil
+      end
+
+      def target
+        recall? ? @attributes[:target] : targets
+      end
+
+      def type
+        @attributes[:action]
+      end
+
+      def move
+        @attributes[:move]
+      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(turn)
+        @turn = turn
+        return execute_recall if type == 'recall'
+        targets.each { |t| MoveExecution.new(self, t).execute }
+      end
+
+      private
+
+      def targets
+        target_list.map do |target|
+          target_by_position(target[0], target[1])
+        end.compact
+      end
+
+      def target_list
+        list = @attributes[:target]
+        reutrn [] if list.empty?
+        list = [list] unless list[0].is_a?(Array)
+        list
+      end
+
+      def recall?
+        type == 'recall'
+      end
+
+      def pokemon_by_position
+        trainer.in_battle_pokemon
+          .find { |ibp| ibp.position == @attributes[:pokemon] }&.pokemon
+      end
+
+      def target_by_position(side, position)
+        side.in_battle_pokemon
+          .find { |ibp| ibp.position == position }&.pokemon
+      end
+
+      def side
+        battle.sides.find { |s| s.trainer_on_side?(trainer) }
+      end
+
+      def execute_recall
+        add_recalls_log
+        if pokemon
+          trainer.remove_from_battle(pokemon, side)
+          trainer.send_to_battle(target, side)
+        else
+          trainer.send_to_battle(target, side)
+        end
+      end
+
+      def add_log(*args)
+        battle.add_to_log(*args)
+      end
+
+      def add_recalls_log
+        if pokemon
+          add_log 'recalls', trainer.name, pokemon.name, target.name
+        else
+          add_log 'recalls_for_fainted', trainer.name, target.name
+        end
+      end
+    end
+  end
+end

data/lib/oakdex/battle/damage.rb

@@ -0,0 +1,99 @@
+require 'forwardable'
+
+module Oakdex
+  class Battle
+    # Calculates damage
+    class Damage
+      extend Forwardable
+
+      def_delegators :@action, :move, :pokemon, :target
+
+      def initialize(turn, action)
+        @turn = turn
+        @action = action
+      end
+
+      def damage
+        (simple_damage * modifier).to_i
+      end
+
+      def critical?
+        @critical ||= rand(1..1000) <= pokemon.critical_hit_prob * 1000 ? 1 : 0
+        @critical == 1
+      end
+
+      def effective?
+        type_modifier > 1.0
+      end
+
+      def ineffective?
+        type_modifier < 1.0
+      end
+
+      private
+
+      def modifier
+        target_modifier * weather_modifier * critical_hit_modifier *
+          random_modifier * stab_modifier * type_modifier *
+          burn_modifier * status_condition_modifier * other_modifiers
+      end
+
+      def status_condition_modifier
+        pokemon.status_conditions.reduce(1.0) do |modifier, condition|
+          modifier * condition.damage_modifier(@action)
+        end
+      end
+
+      def target_modifier
+        1.0 # TODO: 0.75 if move has more than one target
+      end
+
+      def weather_modifier
+        1.0 # TODO: 1.5 water at rain or fire at harsh sunlight, 0.5 vice versa
+      end
+
+      def critical_hit_modifier
+        if critical?
+          1.5
+        else
+          1.0
+        end
+      end
+
+      def random_modifier
+        @random_modifier ||= rand(850..1000) / 1000.0
+      end
+
+      def stab_modifier
+        pokemon.types.include?(move.type) ? 1.5 : 1.0
+      end
+
+      def type_modifier
+        type_data = Oakdex::Pokedex::Type.find!(move.type)
+        target.types.reduce(1.0) do |factor, type|
+          factor * type_data.effectivness[type]
+        end
+      end
+
+      def burn_modifier
+        1.0 # TODO: 0.5 if attack is burning and physical move
+      end
+
+      def other_modifiers
+        1.0 # TODO: See other https://bulbapedia.bulbagarden.net/wiki/Damage
+      end
+
+      def def_and_atk
+        if move.category == 'special'
+          (pokemon.sp_atk.to_f / target.sp_def.to_f)
+        else
+          (pokemon.atk.to_f / target.def.to_f)
+        end
+      end
+
+      def simple_damage
+        (((2 * pokemon.level) / 5.0 + 2) * move.power * def_and_atk) / 50 + 2
+      end
+    end
+  end
+end

data/lib/oakdex/battle/in_battle_pokemon.rb

@@ -0,0 +1,159 @@
+require 'forwardable'
+
+module Oakdex
+  class Battle
+    # Represents a pokemon that is in battle
+    class InBattlePokemon
+      extend Forwardable
+
+      def_delegators :@pokemon, :current_hp, :moves_with_pp
+      def_delegators :@side, :battle
+
+      attr_reader :pokemon, :position, :side
+
+      def initialize(pokemon, side, position = 0)
+        @pokemon = pokemon
+        @side = side
+        @position = position
+      end
+
+      def fainted?
+        current_hp.zero?
+      end
+
+      def action_added?
+        actions.any? { |a| a.pokemon == pokemon }
+      end
+
+      def valid_move_actions
+        return [] if action_added?
+        moves = moves_with_pp
+        moves = [struggle_move] if moves_with_pp.empty?
+        moves.flat_map do |move|
+          targets_in_battle(move).map do |target|
+            {
+              action: 'move',
+              pokemon: pokemon,
+              move: move,
+              target: target
+            }
+          end
+        end
+      end
+
+      private
+
+      def targets_in_battle(move)
+        available_targets(move).map do |targets|
+          if targets.last.is_a?(Array)
+            targets if targets_in_battle?(targets)
+          elsif target_in_battle?(targets)
+            targets
+          end
+        end.compact.reject(&:empty?)
+      end
+
+      def targets_in_battle?(targets)
+        targets.any? { |target| target[0].pokemon_in_battle?(target[1]) }
+      end
+
+      def target_in_battle?(target)
+        target[0].pokemon_in_battle?(target[1]) ||
+          (!target[0].pokemon_left? && target[1] == 0)
+      end
+
+      def struggle_move
+        @struggle_move ||= begin
+          move_type = Oakdex::Pokedex::Move.find('Struggle')
+          Oakdex::Battle::Move.new(move_type, move_type.pp, move_type.pp)
+        end
+      end
+
+      def available_targets(move)
+        with_target(move) || multiple_targets_adjacent(move) ||
+          multiple_targets(move) || []
+      end
+
+      def multiple_targets(move)
+        case move.target
+        when 'all_users' then [all_users]
+        when 'all_except_user' then [all_targets - [self_target]]
+        when 'all' then [all_targets]
+        when 'all_foes' then [all_foes]
+        end
+      end
+
+      def multiple_targets_adjacent(move)
+        case move.target
+        when 'all_adjacent' then [adjacent]
+        when 'adjacent_foes_all' then [adjacent_foes]
+        end
+      end
+
+      def with_target(move)
+        case move.target
+        when 'user', 'user_and_random_adjacent_foe' then [self_target]
+        when 'target_adjacent_user_single' then adjacent_users
+        when 'target_adjacent_single' then adjacent
+        when 'target_user_or_adjacent_user'
+          [self_target] + adjacent_users
+        end
+      end
+
+      def all_targets
+        all_foes + all_users
+      end
+
+      def target_adjacent_single
+        adjacent_foes + adjacent_users
+      end
+
+      def adjacent
+        adjacent_foes + adjacent_users
+      end
+
+      def self_target
+        [@side, position]
+      end
+
+      def adjacent_foes
+        [
+          [other_side, position - 1],
+          [other_side, position],
+          [other_side, position + 1]
+        ].select { |t| t[1] >= 0 && t[1] < pokemon_per_side }
+      end
+
+      def adjacent_users
+        [
+          [@side, position - 1],
+          [@side, position + 1]
+        ].select { |t| t[1] >= 0 && t[1] < pokemon_per_side }
+      end
+
+      def all_users
+        pokemon_per_side.times.map { |i| [@side, i] }
+      end
+
+      def all_foes
+        pokemon_per_side.times.map { |i| [other_side, i] }
+      end
+
+      def pokemon_per_side
+        battle.pokemon_per_side
+      end
+
+      def other_side
+        other_sides.first
+      end
+
+      def other_sides
+        battle.sides - [@side]
+      end
+
+      def actions
+        battle.actions
+      end
+    end
+  end
+end