rubygoal-core 1.0.0

data/lib/rubygoal/coaches/coach_definition_home.rb

@@ -0,0 +1,76 @@
+require 'rubygoal/coach_definition'
+require 'rubygoal/formation'
+
+module Rubygoal
+  class CoachDefinitionHome < CoachDefinition
+
+    team do
+      name "Uruguay"
+
+      players do
+        captain :godin
+
+        fast :cavani
+        fast :rolan
+        fast :suarez
+
+        average :pereira
+        average :gimenez
+        average :arevalo
+        average :lodeiro
+        average :cacerez
+        average :rodriguez
+      end
+    end
+
+    def formation(match)
+      formation = Formation.new
+
+      if match.me.winning?
+        formation.defenders :pereira, :cacerez, :gimenez, :godin, :rodriguez
+        formation.midfielders :lodeiro, :none, :rolan, :none, :arevalo
+        formation.attackers :none, :cavani, :none, :suarez, :none
+      elsif match.time < 20
+        formation.defenders :none, :rolan, :cacerez, :gimenez, :none
+        formation.midfielders :arevalo, :lodeiro, :godin, :none, :pereira
+        formation.attackers :suarez, :none, :none, :cavani, :rodriguez
+      elsif match.time < 20 && match.me.winning?
+        # Mirror opponent players
+
+        opponent = match.other.positions
+        my_players = players
+
+        opponent.each_with_index do |(opponent_name, opponent_pos), index|
+          formation.lineup do
+            custom_position do
+              player my_players[index].name
+              position opponent_pos.x, 100.0 - opponent_pos.y
+            end
+          end
+        end
+      else
+        formation.lineup do
+          if match.ball.x < 50
+            lines do
+              defenders 10
+              midfielders 30
+              attackers 50
+            end
+          else
+            lines do
+              defenders 30
+              midfielders 50
+              attackers 70
+            end
+          end
+
+          defenders :pereira, :cacerez, :gimenez, :godin, :rodriguez
+          midfielders :lodeiro, :none, :rolan, :none, :arevalo
+          attackers :none, :cavani, :none, :suarez, :none
+        end
+      end
+
+      formation
+    end
+  end
+end

data/lib/rubygoal/configuration.rb

@@ -0,0 +1,49 @@
+require 'rubygoal/coordinate'
+
+module Rubygoal
+  class Configuration
+    attr_accessor :average_players_count, :fast_players_count, :captain_players_count,
+                  :kick_strength, :kick_again_delay, :distance_control_ball,
+                  :deceleration_coef, :initial_player_positions, :game_time,
+                  :average_lower_error, :average_upper_error, :average_speed,
+                  :fast_lower_error, :fast_upper_error, :fast_speed,
+                  :captain_error, :captain_speed, :debug_output, :record_game
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+
+  Rubygoal.configure do |config|
+    config.average_players_count = 6
+    config.fast_players_count    = 3
+
+    config.kick_strength         = 20
+    config.kick_again_delay      = 1
+    config.distance_control_ball = 30
+    config.deceleration_coef     = 0.95
+
+    config.average_lower_error   = 0.1
+    config.average_upper_error   = 0.15
+    config.average_speed         = 3.5
+
+    config.fast_lower_error      = 0.1
+    config.fast_upper_error      = 0.15
+    config.fast_speed            = 4
+
+    config.captain_error         = 0.05
+    config.captain_speed         = 4.5
+
+    config.game_time             = 120
+    config.debug_output          = true
+    config.record_game           = false
+  end
+end

data/lib/rubygoal/coordinate.rb

@@ -0,0 +1,33 @@
+require 'rubygoal/util'
+
+module Rubygoal
+  class Coordinate < Struct.new(:x, :y)
+    def distance(coordinate)
+      Util.distance(x, y, coordinate.x, coordinate.y)
+    end
+
+    def add(coordinate)
+      self.class.new(x + coordinate.x, y + coordinate.y)
+    end
+
+    def mult(coeficient)
+      self.class.new(x * coeficient, y * coeficient)
+    end
+
+    def to_s
+      "(#{x}, #{y})"
+    end
+
+    def to_hash
+      { x: x, y: y }
+    end
+  end
+
+  class Position < Coordinate; end
+
+  class Velocity < Coordinate
+    def nonzero?
+      x != 0 || y != 0
+    end
+  end
+end

data/lib/rubygoal/field.rb

@@ -0,0 +1,134 @@
+require 'forwardable'
+
+require 'rubygoal/ball'
+require 'rubygoal/coach_loader'
+require 'rubygoal/teams/home'
+require 'rubygoal/teams/away'
+module Rubygoal
+  module Field
+    WIDTH               = 1394.0
+    HEIGHT              = 938.0
+    OFFSET              = Position.new(262, 112)
+    GOAL_HEIGHT         = 275
+    CLOSE_GOAL_DISTANCE = 275
+
+    class << self
+      def center_position
+        center = Position.new(
+          WIDTH / 2,
+          HEIGHT / 2
+        )
+        OFFSET.add(center)
+      end
+
+      def goal_position(side)
+        position = center_position
+        case side
+        when :home
+          position.x = OFFSET.x
+        when :away
+          position.x = OFFSET.x + WIDTH
+        end
+
+        position
+      end
+
+      def absolute_position(field_position, side)
+        case side
+        when :home
+          OFFSET.add(field_position)
+        when :away
+          OFFSET.add(
+            Position.new(
+              WIDTH - field_position.x,
+              HEIGHT - field_position.y
+            )
+          )
+        end
+      end
+
+      def field_position(absolute_position, side)
+        case side
+        when :home
+          absolute_position.add(
+            Position.new(
+              - OFFSET.x,
+              - OFFSET.y
+            )
+          )
+        when :away
+          Position.new(
+            WIDTH - (absolute_position.x - OFFSET.x),
+            HEIGHT - (absolute_position.y - OFFSET.y)
+          )
+        end
+      end
+
+      def position_from_percentages(position_in_percentages)
+        Position.new(
+          position_in_percentages.x / 100.0 * Field::WIDTH,
+          position_in_percentages.y / 100.0 * Field::HEIGHT
+        )
+      end
+
+      def position_to_percentages(position)
+        Position.new(
+          position.x / Field::WIDTH * 100,
+          position.y / Field::HEIGHT * 100
+        )
+      end
+
+      def position_side(position)
+        position.x < center_position.x ? :home : :away
+      end
+
+      def out_of_bounds_width?(position)
+        lower_limit = OFFSET.x
+        upper_limit = OFFSET.x + WIDTH
+        !(lower_limit..upper_limit).include?(position.x)
+      end
+
+      def out_of_bounds_height?(position)
+        lower_limit = OFFSET.y
+        upper_limit = OFFSET.y + HEIGHT
+        !(lower_limit..upper_limit).include?(position.y)
+      end
+
+      def goal?(position)
+        if out_of_bounds_width?(position)
+          lower_limit = center_position.y - GOAL_HEIGHT / 2
+          upper_limit = center_position.y + GOAL_HEIGHT / 2
+
+          (lower_limit..upper_limit).include?(position.y)
+        else
+          false
+        end
+      end
+
+      def close_to_goal?(position, side)
+        goal_position = Field.goal_position(side)
+        goal_position.distance(position) < CLOSE_GOAL_DISTANCE
+      end
+
+      def default_player_field_positions
+        defenders = Field::WIDTH / 6
+        midfielders = Field::WIDTH / 2
+        attackers = Field::WIDTH * 5 / 6
+
+        [
+          Position.new(50, Field::HEIGHT / 2),
+          Position.new(defenders, Field::HEIGHT / 5),
+          Position.new(defenders, Field::HEIGHT * 2 / 5),
+          Position.new(defenders, Field::HEIGHT * 3 / 5),
+          Position.new(defenders, Field::HEIGHT * 4 / 5),
+          Position.new(midfielders, Field::HEIGHT / 5),
+          Position.new(midfielders, Field::HEIGHT * 2 / 5),
+          Position.new(midfielders, Field::HEIGHT * 3 / 5),
+          Position.new(midfielders, Field::HEIGHT * 4 / 5),
+          Position.new(attackers, Field::HEIGHT / 3),
+          Position.new(attackers, Field::HEIGHT * 2 / 3)
+        ]
+      end
+    end
+  end
+end

data/lib/rubygoal/formation.rb

@@ -0,0 +1,73 @@
+require 'rubygoal/formation/formation_dsl'
+
+module Rubygoal
+  class Formation
+    attr_accessor :players_position, :lines_definition
+
+    def initialize
+      @players_position = {}
+
+      @lines_definition = {
+        defenders: Field::WIDTH / 6,
+        def_midfielders: Field::WIDTH / 3,
+        midfielders: Field::WIDTH / 2,
+        att_midfielders: Field::WIDTH / 3 * 2,
+        attackers: Field::WIDTH / 6 * 5,
+      }
+    end
+
+    def method_missing(method, *args)
+      line_name = method.to_s.chomp('=').to_sym
+      if lines_definition[line_name]
+        set_players_in_custom_line(lines_definition[line_name], args)
+      end
+    end
+
+    def lineup(&block)
+      instance_eval(&block)
+    end
+
+    def errors
+      errors = []
+
+      # TODO Check if we need to count for the goalkeeper as well
+      if players_position.size != 10
+        errors << 'Incorrect number of players, are you missing a name?'
+      end
+
+      errors
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    private
+
+    def lines(&block)
+      CustomLines.apply(self, &block)
+    end
+
+    def custom_position(&block)
+      CustomPosition.apply(self, &block)
+    end
+
+    def set_players_in_custom_line(position_x, players)
+      base_position = Position.new(position_x, 0)
+      separation = line_position_separation(players)
+
+      players.each_with_index do |player, i|
+        next if player == :none
+
+        offset = Position.new(0, separation * (i + 1))
+        position = base_position.add(offset)
+
+        self.players_position[player] = position
+      end
+    end
+
+    def line_position_separation(players)
+      Field::HEIGHT / (players.size + 1)
+    end
+  end
+end

data/lib/rubygoal/formation/formation_dsl.rb

@@ -0,0 +1,67 @@
+module Rubygoal
+  class Formation
+    class FormationDSL
+      def self.apply(formation, &block)
+        dsl = self.new(formation)
+        dsl.instance_eval(&block)
+        dsl.apply
+      end
+
+      private
+
+      def field_width
+        100.0
+      end
+
+      def field_height
+        100.0
+      end
+    end
+
+    class CustomLines < FormationDSL
+      def initialize(formation)
+        @formation = formation
+        @lines = {}
+      end
+
+      def apply
+        formation.lines_definition.merge!(lines)
+      end
+
+      private
+
+      attr_reader :formation, :lines
+
+      def method_missing(method, *args)
+        define_line(method, args.first)
+      end
+
+      def define_line(name, x_position)
+        lines[name] = x_position / 100.0 * Field::WIDTH
+      end
+    end
+
+    class CustomPosition < FormationDSL
+      def initialize(formation)
+        @formation = formation
+      end
+
+      def apply
+        formation.players_position[player_name] = player_position
+      end
+
+      private
+
+      attr_reader :formation
+      attr_accessor :player_name, :player_position
+
+      def player(name)
+        self.player_name = name
+      end
+
+      def position(x, y)
+        self.player_position = Field.position_from_percentages(Position.new(x, y))
+      end
+    end
+  end
+end

data/lib/rubygoal/game.rb

@@ -0,0 +1,162 @@
+require 'forwardable'
+
+require 'rubygoal/coordinate'
+require 'rubygoal/field'
+require 'rubygoal/goal'
+require 'rubygoal/recorder'
+
+module Rubygoal
+  class Game
+    attr_reader :team_home, :team_away, :ball,
+                :time, :goal, :recorder,
+                :coach_home, :coach_away,
+                :score_home, :score_away
+
+    def initialize(coach_home, coach_away)
+      @coach_home = coach_home
+      @coach_away = coach_away
+
+      if debug_output?
+        puts "Home coach: #{@coach_home.name}"
+        puts "Away coach: #{@coach_away.name}"
+      end
+
+      @recorder = Recorder.new(self) if record_game?
+
+      @ball = Ball.new
+
+      @team_home = HomeTeam.new(self, coach_home)
+      @team_away = AwayTeam.new(self, coach_away)
+
+      @goal = Goal.new
+
+      @state = :playing
+
+      @time = Rubygoal.configuration.game_time
+      @score_home = 0
+      @score_away = 0
+
+      reinitialize_players
+    end
+
+    def update
+      return if ended?
+
+      update_elapsed_time
+
+      if celebrating_goal?
+        update_goal
+      else
+        update_remaining_time
+        team_home.update(elapsed_time)
+        team_away.update(elapsed_time)
+        update_ball
+      end
+
+      recorder.update if record_game?
+
+      end_match! if time <= 0
+    end
+
+    def players
+      teams.map(&:players_list).flatten
+    end
+
+    def celebrating_goal?
+      goal.celebrating?
+    end
+
+    def home_players_positions
+      team_home.players_position
+    end
+
+    def away_players_positions
+      team_away.players_position
+    end
+
+    def ball_position
+      ball.position
+    end
+
+    def recorded_game
+      recorder.to_hash if record_game?
+    end
+
+    def ended?
+      state == :ended
+    end
+
+    protected
+
+    attr_writer :time, :score_home, :score_away
+    attr_accessor :state, :last_time, :elapsed_time
+
+    private
+
+    def update_elapsed_time
+      self.last_time ||= Time.now
+
+      self.elapsed_time = Time.now - last_time
+      self.last_time = Time.now
+    end
+
+    def update_remaining_time
+      self.time -= elapsed_time
+    end
+
+    def update_ball
+      ball.update(elapsed_time)
+      if ball.goal?
+        update_score
+        goal.start_celebration
+      end
+    end
+
+    def update_goal
+      goal.update(elapsed_time)
+      reinitialize_match unless goal.celebrating?
+    end
+
+    def reinitialize_match
+      reinitialize_players
+      reinitialize_ball
+    end
+
+    def update_score
+      if Field.position_side(ball_position) == :home
+        self.score_away += 1
+      else
+        self.score_home += 1
+      end
+    end
+
+    def reinitialize_players
+      teams.each(&:players_to_initial_position)
+    end
+
+    def reinitialize_ball
+      ball.position = Field.center_position
+    end
+
+    def teams
+      [team_home, team_away]
+    end
+
+    def end_match!
+      self.state = :ended
+      puts_score if debug_output?
+    end
+
+    def puts_score
+      puts "#{coach_home.name} #{score_home} - #{score_away} #{coach_away.name}"
+    end
+
+    def debug_output?
+      Rubygoal.configuration.debug_output
+    end
+
+    def record_game?
+      Rubygoal.configuration.record_game
+    end
+  end
+end