rubygoal-core 1.0.0

data/test/match_data_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+module Rubygoal
+  class MatchDataTest < Minitest::Test
+    def test_home_team_is_winning
+      match_data = create_match_data(
+        :home,
+        score_home: 2,
+        score_away: 0
+      )
+
+      assert match_data.me.winning?
+      assert match_data.other.losing?
+    end
+
+    def test_home_team_is_losing
+      match_data = create_match_data(
+        :home,
+        score_home: 1,
+        score_away: 3
+      )
+
+      assert match_data.me.losing?
+      assert match_data.other.winning?
+    end
+
+    def test_away_team_is_winning
+      match_data = create_match_data(
+        :away,
+        score_home: 0,
+        score_away: 2
+      )
+
+      assert match_data.me.winning?
+      assert match_data.other.losing?
+    end
+
+    def test_away_team_is_losing
+      match_data = create_match_data(
+        :away,
+        score_home: 3,
+        score_away: 1
+      )
+
+      assert match_data.me.losing?
+      assert match_data.other.winning?
+    end
+
+    def test_home_team_is_a_draw
+      match_data = create_match_data(
+        :home,
+        score_home: 1,
+        score_away: 1
+      )
+
+      assert match_data.me.draw?
+      assert match_data.other.draw?
+    end
+
+    def test_away_team_is_a_draw
+      match_data = create_match_data(
+        :away,
+        score_home: 1,
+        score_away: 1
+      )
+
+      assert match_data.me.draw?
+      assert match_data.other.draw?
+    end
+
+    def test_match_info_includes_time
+      match_data = create_match_data(
+        :away,
+        time: 100
+      )
+
+      assert_equal 100, match_data.time
+    end
+
+    def test_match_info_includes_player_positions
+      match_data = create_match_data(
+        :away,
+        home_players_positions: {
+          name: Position.new(Field::WIDTH, Field::HEIGHT)
+        },
+        away_players_positions: {
+          name: Position.new(Field::WIDTH / 2, 0)
+        }
+      )
+
+      assert_equal({ name: Position.new(50, 0) }, match_data.me.positions)
+      assert_equal({ name: Position.new(100, 100) }, match_data.other.positions)
+    end
+
+    def test_match_info_exclude_goalkeeper_position
+      match_data = create_match_data(
+        :home,
+        home_players_positions: {
+          goalkeeper: Position.new(Field::WIDTH, Field::HEIGHT),
+          name:       Position.new(Field::WIDTH, Field::HEIGHT)
+        },
+      )
+
+      assert_equal({ name: Position.new(100, 100) }, match_data.me.positions)
+    end
+
+    def test_home_match_info_includes_ball_position
+      match_data = create_match_data(
+        :home,
+        ball_position: Field.absolute_position(
+          Position.new(Field::WIDTH / 4, Field::HEIGHT / 2),
+          :home
+        )
+      )
+
+      assert_equal Position.new(25, 50), match_data.ball
+    end
+
+    def test_away_match_info_includes_ball_position
+      match_data = create_match_data(
+        :away,
+        ball_position: Field.absolute_position(
+          Position.new(Field::WIDTH / 4, Field::HEIGHT / 2),
+          :away
+        )
+      )
+
+      assert_equal Position.new(25, 50), match_data.ball
+    end
+
+    private
+
+    def create_match_data(side, game_options)
+      MatchData::Factory.new(game_test_double(game_options), side)
+        .create
+    end
+
+    def game_test_double(game_options)
+      OpenStruct.new({
+        time: 0,
+        score_home: 0,
+        score_away: 0,
+        ball_position: Field.center_position,
+        home_players_positions: {},
+        away_players_positions: {}
+      }.merge(game_options))
+    end
+  end
+end

data/test/player_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+module Rubygoal
+  class PlayerTest < Minitest::Test
+    def setup
+      home_coach = Coach.new(TestHomeCoachDefinition.new)
+      away_coach = Coach.new(TestAwayCoachDefinition.new)
+      @game = Game.new(home_coach, away_coach)
+
+      @player = game.players.first
+      @player.send(:time_to_kick_again=, 0)
+    end
+
+    def test_player_can_kick_the_ball_in_the_same_position
+      position = Position.new(100, 100)
+      game.ball.position = position
+      player.position = position
+
+      assert player.can_kick?(game.ball)
+    end
+
+    def test_player_can_kick_the_ball_when_is_close
+      game.ball.position = Position.new(100, 100)
+      player.position = Position.new(110, 115)
+
+      assert player.can_kick?(game.ball)
+    end
+
+    def test_player_can_not_kick_the_ball_when_is_far
+      game.ball.position = Position.new(100, 100)
+      player.position = Position.new(200, 200)
+
+      refute player.can_kick?(game.ball)
+    end
+
+    def test_player_can_not_kick_the_ball_again
+      position = Position.new(100, 100)
+      game.ball.position = position
+      player.position = position
+
+      player.kick(game.ball, Position.new(300, 300))
+
+      refute player.can_kick?(game.ball)
+    end
+
+    def test_player_can_kick_the_ball_again_after_time
+      position = Position.new(100, 100)
+      game.ball.position = position
+      player.position = position
+
+      player.kick(game.ball, Position.new(300, 300))
+      player.update(Rubygoal.configuration.kick_again_delay)
+
+      assert player.can_kick?(game.ball)
+    end
+
+    def test_kick_the_ball_to_a_different_place
+      position = Position.new(100, 100)
+      game.ball.position = position
+      game.ball.velocity = Velocity.new(0, 0)
+      player.position = position
+
+      player.kick(game.ball, Position.new(300, 300))
+
+      refute_equal Velocity.new(0, 0), game.ball.velocity
+    end
+
+    def test_kick_direction_range_right
+      # Set little error: < 2 degrees (180 * 0.01 < 2)
+      player.instance_variable_set(:@error, 0.01)
+
+      position = Position.new(100, 100)
+      game.ball.position = position
+      game.ball.velocity = Velocity.new(0, 0)
+      player.position = position
+
+      # 0 degree kick
+      player.kick(game.ball, Position.new(200, 100))
+
+      velocity = game.ball.velocity
+      velocity_angle = Util.angle(0, 0, velocity.x, velocity.y)
+
+      assert_in_delta 0, velocity_angle, 2
+    end
+
+    def test_kick_direction_range_left
+      # Set little error: < 2 degrees (180 * 0.01 < 2)
+      player.instance_variable_set(:@error, 0.01)
+
+      position = Position.new(100, 100)
+      game.ball.position = position
+      game.ball.velocity = Velocity.new(0, 0)
+      player.position = position
+
+      # 180 degree kick
+      player.kick(game.ball, Position.new(0, 100))
+
+      velocity = game.ball.velocity
+      velocity_angle = Util.positive_angle(0, 0, velocity.x, velocity.y)
+
+      assert_in_delta 180, velocity_angle, 2
+    end
+
+    def test_kick_strength
+      # Set little error: distance error = 1 (20 * 0.05 = 1)
+      player.instance_variable_set(:@error, 0.05)
+
+      position = Position.new(100, 100)
+      game.ball.position = position
+      game.ball.velocity = Velocity.new(0, 0)
+      player.position = position
+
+      player.kick(game.ball, Position.new(200, 200))
+
+      velocity = game.ball.velocity
+      velocity_strength = Util.distance(0, 0, velocity.x, velocity.y)
+
+      assert_in_delta 20, velocity_strength, 1
+    end
+
+    private
+
+    attr_reader :game, :player
+  end
+end

data/test/players/goalkeeper_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Rubygoal
+  class GaolKeeperPlayerTest < Minitest::Test
+    def setup
+      home_coach = Coach.new(TestHomeCoachDefinition.new)
+      away_coach = Coach.new(TestAwayCoachDefinition.new)
+      @game = Game.new(home_coach, away_coach)
+
+      @player = game.players.first
+    end
+
+    def test_goalkeeper_is_already_covering_goal
+      goal_pos = Field.goal_position(:home)
+      game.ball.position = Position.new(300, goal_pos.y)
+
+      player.move_to_cover_goal(game.ball)
+      player.update(elapsed_time)
+
+      assert_equal Velocity.new(0, 0), player.velocity
+    end
+
+    def test_goalkeeper_moves_down_to_cover_goal
+      game.ball.position = Position.new(300, 300)
+
+      player.move_to_cover_goal(game.ball)
+      player.update(elapsed_time)
+
+      assert_in_delta Velocity.new(0, -3.5), player.velocity, 0.001
+    end
+
+    def test_goalkeeper_moves_up_to_cover_goal
+      game.ball.position = Position.new(300, 900)
+
+      player.move_to_cover_goal(game.ball)
+      player.update(elapsed_time)
+
+      assert_in_delta Velocity.new(0, 3.5), player.velocity, 0.001
+    end
+
+    private
+
+    attr_reader :game, :player
+
+    def elapsed_time
+      1 / 60.0
+    end
+  end
+end

data/test/players/player_movement_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module Rubygoal
+  class PlayerMovementTest < Minitest::Test
+    def setup
+      home_coach = Coach.new(TestHomeCoachDefinition.new)
+      away_coach = Coach.new(TestAwayCoachDefinition.new)
+      game = Game.new(home_coach, away_coach)
+      home_team = game.team_home
+
+      @player = home_team.players.values[0]
+      @other_player = home_team.players.values[1]
+
+      @player_movement = PlayerMovement.new(game, player)
+    end
+
+    def test_do_not_modify_velocity_if_not_blocker
+      player.position = Position.new(100, 0)
+      other_player.position = Position.new(170, 0)
+
+      player.move_to(Position.new(500, 0))
+      player_movement.update(elapsed_time)
+
+      assert_equal Velocity.new(3.5, 0), player.velocity
+    end
+
+    def test_modify_velocity_if_there_is_a_blocker_very_close
+      player.position = Position.new(100, 0)
+      other_player.position = Position.new(149, 0)
+
+      player.move_to(Position.new(500, 0))
+      player_movement.update(elapsed_time)
+
+      assert_in_delta Velocity.new(2.5, -2.5), player.velocity, 0.1
+    end
+
+    def test_decelerate_if_there_is_a_blocker_a_bit_close
+      player.position = Position.new(100, 0)
+      other_player.position = Position.new(169, 0)
+
+      player.move_to(Position.new(500, 0))
+      player_movement.update(elapsed_time)
+
+      assert_in_delta Velocity.new(3.1, 0), player.velocity, 0.1
+    end
+
+    def test_stop_if_close_to_destination_and_there_is_blocker
+      player.position = Position.new(100, 0)
+      other_player.position = Position.new(149, 0)
+
+      player.move_to(Position.new(160, 0))
+      player_movement.update(elapsed_time)
+
+      assert_equal Velocity.new(0, 0), player.velocity
+    end
+
+    def test_stop_if_blocker_is_ver_close_and_moving
+      player.position = Position.new(100, 0)
+      other_player.position = Position.new(150, 0)
+
+      player.move_to(Position.new(500, 0))
+      other_player.move_to(Position.new(150, 500))
+      player_movement.update(elapsed_time)
+
+      assert_equal Velocity.new(0, 0), player.velocity
+    end
+
+    private
+
+    attr_reader :player_movement, :player, :other_player
+
+    def elapsed_time
+      1 / 60.0
+    end
+  end
+end

data/test/recorder_test.rb

@@ -0,0 +1,118 @@
+require 'test_helper'
+require 'timecop'
+
+require 'rubygoal/recorder'
+
+module Rubygoal
+  class RecorderTest < Minitest::Test
+    def setup
+      Rubygoal.configuration.record_game = true
+
+      home_coach = Coach.new(TestHomeCoachDefinition.new)
+      away_coach = Coach.new(TestAwayCoachDefinition.new)
+      @game = Game.new(home_coach, away_coach)
+      @recorder = @game.recorder
+    end
+
+    def test_recorded_team_names
+      expected_teams = {
+        home: 'Test Home Team',
+        away: 'Test Away Team'
+      }
+
+      assert_equal expected_teams, recorder.to_hash[:teams]
+    end
+
+    def test_recorded_score
+      expected_score = {
+        home: 0,
+        away: 0
+      }
+
+      assert_equal expected_score, recorder.to_hash[:score]
+    end
+
+    def test_initial_recorded_frames
+      assert_equal [], recorder.to_hash[:frames]
+    end
+
+    def test_recorded_frame_after_first_update
+      @game.update
+
+      ball_position = Field.center_position
+      frames = recorder.to_hash[:frames]
+
+      assert_equal 1, frames.count
+      assert_in_delta 120, frames.first[:time], 0.001
+      assert_equal(
+        { home: 0, away: 0 },
+        frames.first[:score]
+      )
+      assert_equal(
+        { x: ball_position.x, y: ball_position.y},
+        frames.first[:ball]
+      )
+    end
+
+    def test_recorded_frame_with_11_values_for_player_info
+      @game.update
+
+      first_frame = recorder.to_hash[:frames].first
+      home_players = first_frame[:home_players]
+      away_players = first_frame[:away_players]
+
+      assert_equal 11, home_players.count
+      assert_equal 11, away_players.count
+    end
+
+    def test_recorded_frame_with_detailed_player_info
+      @game.update
+
+      first_frame = recorder.to_hash[:frames].first
+      home_players = first_frame[:home_players]
+      away_players = first_frame[:away_players]
+
+      goalkeeper_field_pos = Position.new(50, Field::HEIGHT / 2)
+      goalkeeper_pos_home = Field.absolute_position(goalkeeper_field_pos, :home)
+      goalkeeper_pos_away = Field.absolute_position(goalkeeper_field_pos, :away)
+
+      assert_equal(
+        {
+          x: goalkeeper_pos_home.x,
+          y: goalkeeper_pos_home.y,
+          angle: 0,
+          type: :average
+        },
+        home_players.first
+      )
+      assert_equal(
+        {
+          x: goalkeeper_pos_away.x,
+          y: goalkeeper_pos_away.y,
+          angle: 0,
+          type: :average
+        },
+        away_players.first
+      )
+    end
+
+    def test_recorded_frame_some_updates
+      time = Time.now
+      21.times do
+        @game.update
+        time += 0.25
+        Timecop.travel(time)
+      end
+
+      frames = recorder.to_hash[:frames]
+
+      assert_equal 21, frames.count
+      assert_in_delta 120, frames.first[:time], 0.001
+      assert_in_delta 115, frames.last[:time], 0.001
+    end
+
+    private
+
+    attr_reader :game, :recorder
+  end
+end