rubygoal 2.0.0 → 2.1.0

data/lib/rubygoal/goal.rb

@@ -0,0 +1,26 @@
+require 'rubygoal/configuration'
+
+module Rubygoal
+  class Goal
+    def initialize
+      @celebration_time = 0
+    end
+
+    def celebrating?
+      celebration_time > 0
+    end
+
+    def start_celebration
+      self.celebration_time = 3
+    end
+
+    def update(elapsed_time)
+      start_celebration unless celebrating?
+      self.celebration_time -= elapsed_time
+    end
+
+    protected
+
+    attr_accessor :celebration_time
+  end
+end

data/lib/rubygoal/match_data.rb

@@ -0,0 +1,130 @@
+module Rubygoal
+  class MatchData
+    class Factory
+      extend Forwardable
+      def_delegators :game, :ball_position, :score_home, :score_away, :time,
+                     :home_players_positions, :away_players_positions
+
+      def initialize(game, side)
+        @game = game
+        @side = side
+      end
+
+      def create
+        MatchData.new(
+          my_score,
+          other_score,
+          ball_match_position,
+          my_positions,
+          other_positions,
+          time
+        )
+      end
+
+      private
+
+      attr_reader :game, :side
+
+      def remove_goalkeeper_position(positions)
+        positions.tap do |ps|
+          ps.delete(:goalkeeper)
+        end
+      end
+
+      def home_players_positions
+        remove_goalkeeper_position(game.home_players_positions)
+      end
+
+      def away_players_positions
+        remove_goalkeeper_position(game.away_players_positions)
+      end
+
+      def other_side
+        side == :home ? :away : :home
+      end
+
+      def my_score
+        send("score_#{side}")
+      end
+
+      def other_score
+        send("score_#{other_side}")
+      end
+
+      def my_positions
+        send("#{side}_players_positions")
+      end
+
+      def other_positions
+        send("#{other_side}_players_positions")
+      end
+
+      def ball_field_position
+        Field.field_position(ball_position, side)
+      end
+
+      def ball_match_position
+        Field.position_to_percentages(ball_field_position)
+      end
+    end
+
+    class Team
+      attr_reader :score, :result, :positions
+
+      def initialize(score, result, positions = nil)
+        @score  = score
+        @result = result
+        @positions = positions
+
+        convert_positions_to_percentages
+      end
+
+      def draw?
+        result == :draw
+      end
+
+      def winning?
+        result == :win
+      end
+
+      def losing?
+        result == :lose
+      end
+
+      private
+
+      def convert_positions_to_percentages
+        @positions = positions.each_with_object({}) do |(name, pos), hash|
+          hash[name] = Field.position_to_percentages(pos)
+        end
+      end
+    end
+
+    attr_reader :me, :other, :time, :ball
+
+    def initialize(my_score, other_score, ball_position, my_positions, other_positions, time)
+      @me = MatchData::Team.new(
+        my_score,
+        result(my_score, other_score),
+        my_positions
+      )
+      @other = MatchData::Team.new(
+        other_score,
+        result(other_score, my_score),
+        other_positions
+      )
+      @time = time
+      @ball = ball_position
+    end
+
+    def result(my_score, other_score)
+      if my_score > other_score
+        :win
+      elsif my_score < other_score
+        :lose
+      else
+        :draw
+      end
+    end
+  end
+end

data/lib/rubygoal/moveable.rb

@@ -0,0 +1,68 @@
+require 'rubygoal/util'
+require 'rubygoal/coordinate'
+
+module Rubygoal
+  module Moveable
+    MIN_DISTANCE = 10
+
+    attr_accessor :position, :velocity, :rotation
+
+    def initialize
+      @position = Position.new(0, 0)
+      @velocity = Velocity.new(0, 0)
+      @speed = 0
+      @destination = nil
+      @rotation = 0
+    end
+
+    def moving?
+      velocity.nonzero?
+    end
+
+    def distance(position)
+      Util.distance(self.position.x, self.position.y, position.x, position.y)
+    end
+
+    def move_to(destination)
+      self.destination = destination
+
+      self.rotation = Util.angle(position.x, position.y, destination.x, destination.y)
+      velocity.x = Util.offset_x(rotation, speed)
+      velocity.y = Util.offset_y(rotation, speed)
+    end
+
+    def update(elapsed_time)
+      return unless moving?
+
+      if destination && distance(destination) < MIN_DISTANCE
+        stop
+        reset_rotation
+      else
+        self.position = position_after_update(elapsed_time)
+      end
+    end
+
+    def stop
+      self.destination = nil
+      self.velocity = Velocity.new(0, 0)
+    end
+
+    def position_after_update(elapsed_time)
+      custom_frame_rate = 1 / 60.0
+      coef = elapsed_time / custom_frame_rate
+      movement = velocity.mult(coef)
+
+      position.add(movement)
+    end
+
+    attr_accessor :destination
+
+    private
+
+    attr_reader :speed
+
+    def reset_rotation
+      self.rotation = 0
+    end
+  end
+end

data/lib/rubygoal/player.rb

@@ -0,0 +1,87 @@
+require 'rubygoal/coordinate'
+require 'rubygoal/moveable'
+require 'rubygoal/configuration'
+require 'rubygoal/util'
+
+require 'rubygoal/players/player_movement'
+
+module Rubygoal
+  class Player
+    STRAIGHT_ANGLE = 180
+
+    include Moveable
+
+    attr_reader :side, :type
+    attr_accessor :coach_defined_position
+
+    def initialize(game, side)
+      super()
+
+      @time_to_kick_again = 0
+      @side = side
+      @player_movement = PlayerMovement.new(game, self)
+    end
+
+    def can_kick?(ball)
+      !waiting_to_kick_again? && control_ball?(ball)
+    end
+
+    def kick(ball, target)
+      direction = random_direction(target)
+      strength = random_strength
+
+      ball.move(direction, strength)
+      reset_waiting_to_kick!
+    end
+
+    def move_to_coach_position
+      move_to(coach_defined_position)
+    end
+
+    def update(elapsed_time)
+      update_waiting_to_kick(elapsed_time)
+      player_movement.update(elapsed_time) if moving?
+
+      super
+    end
+
+    protected
+
+    attr_accessor :time_to_kick_again, :player_movement
+
+    private
+
+    attr_reader :error
+
+    def waiting_to_kick_again?
+      time_to_kick_again > 0
+    end
+
+    def reset_waiting_to_kick!
+      self.time_to_kick_again = Rubygoal.configuration.kick_again_delay
+    end
+
+    def update_waiting_to_kick(time_elapsed)
+      self.time_to_kick_again -= time_elapsed if waiting_to_kick_again?
+    end
+
+    def control_ball?(ball)
+      distance(ball.position) < Rubygoal.configuration.distance_control_ball
+    end
+
+    def random_strength
+      error_range = (1 - error)..(1 + error)
+      error_coef = Random.rand(error_range)
+      Rubygoal.configuration.kick_strength * error_coef
+    end
+
+    def random_direction(target)
+      direction = Util.angle(position.x, position.y, target.x, target.y)
+
+      max_angle_error = STRAIGHT_ANGLE * error
+      angle_error_range = -max_angle_error..max_angle_error
+
+      direction += Random.rand(angle_error_range)
+    end
+  end
+end

data/lib/rubygoal/players/average.rb

@@ -0,0 +1,16 @@
+require 'rubygoal/player'
+
+module Rubygoal
+  class AveragePlayer < Player
+    def initialize(*args)
+      super
+      config = Rubygoal.configuration
+      error_range = config.average_lower_error..config.average_upper_error
+
+      @error = Random.rand(error_range)
+      @speed = config.average_speed
+
+      @type = :average
+    end
+  end
+end

data/lib/rubygoal/players/captain.rb

@@ -0,0 +1,15 @@
+require 'rubygoal/player'
+
+module Rubygoal
+  class CaptainPlayer < Player
+    def initialize(*args)
+      super
+      config = Rubygoal.configuration
+
+      @error = config.captain_error
+      @speed = config.captain_speed
+
+      @type = :captain
+    end
+  end
+end

data/lib/rubygoal/players/fast.rb

@@ -0,0 +1,16 @@
+require 'rubygoal/player'
+
+module Rubygoal
+  class FastPlayer < Player
+    def initialize(*args)
+      super
+      config = Rubygoal.configuration
+      error_range = config.fast_lower_error..config.fast_upper_error
+
+      @error = Random.rand(error_range)
+      @speed = config.fast_speed
+
+      @type = :fast
+    end
+  end
+end

data/lib/rubygoal/players/goalkeeper.rb

@@ -0,0 +1,26 @@
+require 'rubygoal/players/average'
+require 'rubygoal/field'
+require 'rubygoal/util'
+
+module Rubygoal
+  class GoalKeeperPlayer < AveragePlayer
+    def move_to_cover_goal(ball)
+      move_without_rotation_to(position_to_cover_goal(ball))
+    end
+
+    private
+
+    def position_to_cover_goal(ball)
+      Util.y_intercept_with_line(
+        coach_defined_position.x,
+        Field.goal_position(side),
+        ball.position
+      )
+    end
+
+    def move_without_rotation_to(pos)
+      move_to(pos)
+      reset_rotation
+    end
+  end
+end

data/lib/rubygoal/players/player_movement.rb

@@ -0,0 +1,98 @@
+require 'rubygoal/player'
+
+module Rubygoal
+  class PlayerMovement
+    PLAYERS_MIN_DISTANCE   = 50
+    CLOSE_TO_DESTINATION   = 60
+    PLAYERS_CLOSE_DISTANCE = 70
+
+    extend Forwardable
+    def_delegators :player, :position, :velocity, :destination
+
+    def initialize(game, player)
+      @game = game
+      @player = player
+    end
+
+    def update(elapsed_time)
+      self.elapsed_time = elapsed_time
+
+      if blocking_player
+        if close_to_destination? || any_moving_and_very_close_player?
+          player.stop
+        elsif blocking_player_very_close?
+          adapt_velocity_when_very_close
+        elsif blocking_player_close?
+          adapt_velocity_when_close
+        end
+      end
+    end
+
+    private
+
+    attr_reader :game, :player
+    attr_accessor :elapsed_time
+
+    def game_players_except_me
+      game.players - [player]
+    end
+
+    def game_players_closer_to_destination
+      game_players_except_me.select do |p|
+        destination.distance(position_after_update) >
+          destination.distance(p.position)
+      end
+    end
+
+    def blocking_player
+      game_players_closer_to_destination.min_by do |p|
+        position_after_update.distance(p.position)
+      end
+    end
+
+    def close_to_destination?
+      position_after_update.distance(destination) < CLOSE_TO_DESTINATION
+    end
+
+    def blocking_player_very_close?
+      blocking_player.distance(position) < PLAYERS_MIN_DISTANCE
+    end
+
+    def blocking_player_close?
+      blocking_player.distance(position) < PLAYERS_CLOSE_DISTANCE
+    end
+
+    def any_moving_and_very_close_player?
+      game_players_closer_to_destination.any? do |p|
+        p.moving? && p.distance(position_after_update) < PLAYERS_MIN_DISTANCE
+      end
+    end
+
+    def adapt_velocity_when_very_close
+      vel_angle = Util.angle(0, 0, velocity.x, velocity.y) - 45
+      vel_magnitude = Util.distance(0, 0, velocity.x, velocity.y)
+
+      player.velocity = Velocity.new(
+        Util.offset_x(vel_angle, vel_magnitude),
+        Util.offset_y(vel_angle, vel_magnitude),
+      )
+    end
+
+    def adapt_velocity_when_close
+      distance_to_run =
+        blocking_player.distance(position_after_update) - PLAYERS_MIN_DISTANCE
+
+      close_range_distance = (PLAYERS_CLOSE_DISTANCE - PLAYERS_MIN_DISTANCE).to_f
+
+      # We want to decelerate when close, but we do not want to
+      # have velocity = 0, so we add 0.5 to still be in movement
+      deceleration_coef = (distance_to_run * 0.5) / close_range_distance + 0.5
+
+      player.velocity = velocity.mult(deceleration_coef)
+    end
+
+    def position_after_update
+      player.position_after_update(elapsed_time)
+    end
+  end
+end