rubygoal-core 1.0.0

data/lib/rubygoal/recorder.rb

@@ -0,0 +1,56 @@
+require 'rubygoal/game'
+
+module Rubygoal
+  class Recorder
+    def initialize(game)
+      @game   = game
+      @frames = []
+    end
+
+    def update
+      @frames << frame_info
+    end
+
+    def to_hash
+      {
+        teams: {
+          home: @game.coach_home.name,
+          away: @game.coach_away.name
+        },
+        score: {
+          home: @game.score_home,
+          away: @game.score_away
+        },
+        frames: @frames
+      }
+    end
+
+    private
+
+    attr_reader :game, :frames
+
+    def frame_info
+      {
+        time: @game.time.round(0),
+        score: { home: @game.score_home, away: @game.score_away },
+        ball: {
+          x: @game.ball.position.x.round(0),
+          y: @game.ball.position.y.round(0)
+        },
+        home_players: team_info(@game.team_home),
+        away_players: team_info(@game.team_away)
+      }
+    end
+
+    def team_info(team)
+      team.players.map do |_, player|
+        {
+          x:     player.position.x.round(0),
+          y:     player.position.y.round(0),
+          angle: player.rotation.round(0),
+          type:  player.type
+        }
+      end
+    end
+  end
+end

data/lib/rubygoal/simulator.rb

@@ -0,0 +1,33 @@
+require 'timecop'
+require 'json'
+require 'rubygoal/game'
+
+module Rubygoal
+  class Simulator
+    extend Forwardable
+    def_delegators :game, :recorded_game
+
+    def initialize
+      Rubygoal.configuration.record_game = true
+      @game = Rubygoal::Game.new(load_coach(:home), load_coach(:away))
+    end
+
+    def simulate
+      time = Time.now
+
+      while !game.ended? do
+        game.update
+        time += 1.0 / 60.0
+        Timecop.travel(time)
+      end
+    end
+
+    private
+
+    attr_reader :game
+
+    def load_coach(side)
+      CoachLoader.new(side).coach
+    end
+  end
+end

data/lib/rubygoal/team.rb

@@ -0,0 +1,198 @@
+require 'forwardable'
+
+require 'rubygoal/formation'
+require 'rubygoal/field'
+require 'rubygoal/players/average'
+require 'rubygoal/players/fast'
+require 'rubygoal/players/captain'
+require 'rubygoal/players/goalkeeper'
+require 'rubygoal/match_data'
+
+module Rubygoal
+  class Team
+    attr_reader :players, :side, :opponent_side, :coach, :formation
+    attr_accessor :goalkeeper
+
+    INFINITE = 100_000
+
+    extend Forwardable
+    def_delegators :coach, :name
+    def_delegators :game, :ball
+
+    def initialize(game, coach)
+      @game    = game
+      @players = {}
+      @coach   = coach
+
+      @match_data_factory = MatchData::Factory.new(game, side)
+
+      initialize_lineup_values
+      initialize_players
+      initialize_formation
+    end
+
+    def players_to_initial_position
+      match_data = match_data_factory.create
+      formation = coach.formation(match_data)
+      restart_player_positions_in_own_field(formation)
+    end
+
+    def update(elapsed_time)
+      match_data = match_data_factory.create
+      self.formation = coach.formation(match_data)
+
+      unless formation.valid?
+        puts formation.errors
+        raise "Invalid formation: #{coach.name}"
+      end
+
+      update_coach_defined_positions(formation)
+
+      player_to_move = nil
+      min_distance_to_ball = INFINITE
+      players_list.each do |player|
+        pass_or_shoot(player) if player.can_kick?(ball)
+
+        distance_to_ball = player.distance(ball.position)
+        if min_distance_to_ball > distance_to_ball
+          min_distance_to_ball = distance_to_ball
+          player_to_move = player
+        end
+      end
+
+      player_to_move.move_to(ball.position)
+
+      players.each do |name, player|
+        if name == :goalkeeper
+          if player != player_to_move
+            player.move_to_cover_goal(ball)
+            player.update(elapsed_time)
+            next
+          end
+        end
+
+        player.move_to_coach_position unless player == player_to_move
+        player.update(elapsed_time)
+      end
+    end
+
+    def players_list
+      players.values
+    end
+
+    def players_position
+      players.each_with_object({}) do |(name, player), hash|
+        hash[name] = Field.field_position(player.position, side)
+      end
+    end
+
+    private
+
+    attr_reader :game, :match_data_factory
+    attr_writer :formation
+
+    def initialize_lineup_values
+      @average_players_count = 6
+      @fast_players_count = 3
+    end
+
+    def initialize_formation
+      @formation = @coach.initial_formation
+    end
+
+    def initialize_players
+      @players = { goalkeeper: GoalKeeperPlayer.new(game, side) }
+
+      unless @coach.valid?
+        puts @coach.errors
+        raise "Invalid team definition: #{@coach.name}"
+      end
+
+      @players[@coach.captain_player.name] = CaptainPlayer.new(game, side)
+
+      @coach.players_by_type(:fast).each do |player_def|
+        @players[player_def.name] = FastPlayer.new(game, side)
+      end
+
+      @coach.players_by_type(:average).each do |player_def|
+        @players[player_def.name] = AveragePlayer.new(game, side)
+      end
+
+      initialize_player_positions
+    end
+
+    def pass_or_shoot(player)
+      # Kick straight to the goal whether the distance is short (200)
+      # or we don't have a better option
+      target = shoot_target
+
+      unless Field.close_to_goal?(player.position, opponent_side)
+        if teammate = nearest_forward_teammate(player)
+          target = teammate.position
+        end
+      end
+
+      player.kick(ball, target)
+    end
+
+    def nearest_forward_teammate(player)
+      min_dist = INFINITE
+      nearest_teammate = nil
+
+      (players.values - [player]).each do |teammate|
+        if teammate_is_on_front?(player, teammate)
+          dist = player.distance(teammate.position)
+          if min_dist > dist
+            nearest_teammate = teammate
+            min_dist = dist
+          end
+        end
+      end
+
+      nearest_teammate
+    end
+
+    def shoot_target
+      # Do not kick always to the center, look for the sides of the goal
+      limit = Field::GOAL_HEIGHT / 2
+      offset = Random.rand(-limit..limit)
+
+      target = Field.goal_position(opponent_side)
+      target.y += offset
+      target
+    end
+
+    def initialize_player_positions
+      Field.default_player_field_positions.each_with_index do |pos, index|
+        players.values[index].position = lineup_to_position(pos)
+        players.values[index].coach_defined_position = lineup_to_position(pos)
+      end
+    end
+
+    def update_coach_defined_positions(formation)
+      formation.players_position.each do |player_name, pos|
+        players[player_name].coach_defined_position = lineup_to_position(pos)
+      end
+    end
+
+    def restart_player_positions_in_own_field(formation)
+      formation.players_position.each do |player_name, pos|
+        pos.x *= 0.5
+        pos = lineup_to_position(pos)
+
+        player = players[player_name]
+
+        player.coach_defined_position = pos
+        player.position = pos
+      end
+    end
+
+    def lineup_to_position(field_position)
+      Field.absolute_position(field_position, side)
+    end
+
+    def goalkeeper
+      players[:goalkeeper]
+    end
+  end
+end

data/lib/rubygoal/teams/away.rb

@@ -0,0 +1,15 @@
+require 'rubygoal/team'
+
+module Rubygoal
+  class AwayTeam < Team
+    def initialize(*args)
+      @side = :away
+      @opponent_side = :home
+      super
+    end
+
+    def teammate_is_on_front?(player, teammate)
+      teammate.position.x < player.position.x - 40
+    end
+  end
+end

data/lib/rubygoal/teams/home.rb

@@ -0,0 +1,15 @@
+require 'rubygoal/team'
+
+module Rubygoal
+  class HomeTeam < Team
+    def initialize(*args)
+      @side = :home
+      @opponent_side = :away
+      super
+    end
+
+    def teammate_is_on_front?(player, teammate)
+      teammate.position.x > player.position.x + 40
+    end
+  end
+end

data/lib/rubygoal/util.rb

@@ -0,0 +1,36 @@
+module Rubygoal
+  module Util
+    class << self
+      def offset_x(angle, distance)
+        distance * Math.cos(angle * Math::PI / 180.0)
+      end
+
+      def offset_y(angle, distance)
+        distance * Math.sin(angle * Math::PI / 180.0)
+      end
+
+      def distance(x1, y1, x2, y2)
+        Math.hypot(x2 - x1, y2 - y1)
+      end
+
+      def angle(x1, y1, x2, y2)
+        Math.atan2(y2 - y1, x2 - x1) / Math::PI * 180.0
+      end
+
+      def positive_angle(x1, y1, x2, y2)
+        angle = self.angle(x1, y1, x2, y2)
+        if angle < 0
+          360 + angle
+        else
+          angle
+        end
+      end
+
+      def y_intercept_with_line(x, pos1, pos2)
+        slope = (pos2.y - pos1.y) / (pos2.x - pos1.x)
+
+        Position.new(x, slope * (x - pos1.x) + pos1.y)
+      end
+    end
+  end
+end

data/lib/rubygoal/version.rb

@@ -0,0 +1,3 @@
+module Rubygoal
+  VERSION = Gem::Version.new '1.0.0'
+end

data/test/ball_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+require 'rubygoal/ball'
+require 'rubygoal/field'
+
+module Rubygoal
+  class BallTest < Minitest::Test
+    def setup
+      @ball = Ball.new
+    end
+
+    def test_ball_is_in_home_goal_position
+      ball.position = Field.goal_position(:home).add(Position.new(-1, 0))
+
+      assert ball.goal?
+    end
+
+    def test_ball_is_in_away_goal_position
+      ball.position = Field.goal_position(:away).add(Position.new(1, 0))
+
+      assert ball.goal?
+    end
+
+    def test_ball_is_not_in_goal_position
+      ball.position = Field.goal_position(:home)
+
+      assert !ball.goal?
+    end
+
+    def test_ball_velocity_drops_by_095_on_each_update
+      ball.velocity = Velocity.new(10, 10)
+      ball.update(elapsed_time)
+      ball.update(elapsed_time)
+
+      assert_equal Velocity.new(9.025, 9.025), @ball.velocity
+      assert_equal Position.new(978.5, 600.5), @ball.position
+    end
+
+    def test_ball_bounces_on_the_height
+      ball.position = Position.new(265, 500)
+      ball.velocity = Velocity.new(-10, 10)
+      ball.update(elapsed_time)
+
+      assert_equal Velocity.new(9.5, 9.5), @ball.velocity
+      assert_equal Position.new(255, 510), @ball.position
+    end
+
+    private
+
+    attr_reader :ball
+
+    def elapsed_time
+      1 / 60.0
+    end
+  end
+end

data/test/coach_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'fixtures/four_fast_players_coach_definition'
+require 'fixtures/less_players_coach_definition'
+require 'fixtures/more_players_coach_definition'
+require 'fixtures/two_captains_coach_definition'
+require 'fixtures/valid_coach_definition'
+
+module Rubygoal
+  class CoachTest < Minitest::Test
+    def test_valid_players
+      coach = Coach.new(ValidCoachDefinition.new)
+
+      assert coach.valid?
+      assert_empty coach.errors
+    end
+
+    def test_less_players
+      coach = Coach.new(LessPlayersCoachDefnition.new)
+      expected_error = ['The number of average players is 5']
+
+      refute coach.valid?
+      assert_equal expected_error, coach.errors
+    end
+
+    def test_more_players
+      coach = Coach.new(MorePlayersCoachDefinition.new)
+      expected_error = ['The number of average players is 7']
+
+      refute coach.valid?
+      assert_equal expected_error, coach.errors
+    end
+
+    def test_more_than_one_captain
+      coach = Coach.new(TwoCaptainsCoachDefinition.new)
+      expected_errors = ['The number of captains is 2']
+
+      refute coach.valid?
+      assert_equal expected_errors, coach.errors
+    end
+
+    def test_more_than_three_fast
+      coach = Coach.new(FourFastPlayersCoachDefinition.new)
+      expected_errors = ['The number of fast players is 4']
+
+      refute coach.valid?
+      assert_equal expected_errors, coach.errors
+    end
+  end
+end