rubygoal 0.0.1

data/lib/rubygoal/field.rb

@@ -0,0 +1,84 @@
+require 'forwardable'
+require 'gosu'
+
+require 'rubygoal/ball'
+require 'rubygoal/coach_loader'
+require 'rubygoal/team'
+require 'rubygoal/field_metrics'
+require 'rubygoal/match'
+require 'rubygoal/coaches/coach_home'
+require 'rubygoal/coaches/coach_away'
+
+module Rubygoal
+  class Field
+    attr_reader :ball, :team_home, :team_away
+
+    extend Forwardable
+    def_delegators :ball, :goal?
+
+    def initialize(game_window)
+      @game_window = game_window
+      @background_image = Gosu::Image.new(game_window, Config.field.background_image_file, true)
+
+      @ball = Ball.new(game_window, FieldMetrics.center_position)
+
+      coach_home = CoachLoader.get(CoachHome)
+      coach_away = CoachLoader.get(CoachAway)
+
+      puts "Home coach: #{coach_home.class.name}"
+      puts "Away coach: #{coach_away.class.name}"
+
+      @team_home = Team.new(game_window, :home, coach_home)
+      @team_away = Team.new(game_window, :away, coach_away)
+    end
+
+    def reinitialize
+      team_home.players_to_initial_position
+      team_away.players_to_initial_position
+      ball.position = FieldMetrics.center_position
+    end
+
+    def team_names
+      {
+        home: team_home.name,
+        away: team_away.name
+      }
+    end
+
+    def update
+      team_home.update(game_data(:home))
+      team_away.update(game_data(:away))
+      ball.update
+    end
+
+    def draw
+      background_image.draw(0, 0, 0);
+      ball.draw
+      team_home.draw
+      team_away.draw
+    end
+
+    private
+
+    def game_data(side)
+      case side
+      when :home
+        Match.new(
+          game_window.score_home,
+          game_window.score_away,
+          game_window.time,
+          team_away.formation
+        )
+      when :away
+        Match.new(
+          game_window.score_away,
+          game_window.score_home,
+          game_window.time,
+          team_home.formation
+        )
+      end
+    end
+
+    attr_reader :background_image, :game_window
+  end
+end

data/lib/rubygoal/field_metrics.rb

@@ -0,0 +1,85 @@
+require 'rubygoal/config'
+require 'rubygoal/coordinate'
+require 'rubygoal/field_metrics'
+
+module Rubygoal
+  module FieldMetrics
+    class << self
+      def center_position
+        center = Position.new(
+          Config.field.width / 2,
+          Config.field.height / 2
+        )
+        Config.field.offset.add(center)
+      end
+
+      def goal_position(side)
+        position = center_position
+        case side
+        when :home
+          position.x = Config.field.offset.x
+        when :away
+          position.x = Config.field.offset.x + Config.field.width
+        end
+        position
+      end
+
+      def initial_player_positions(side)
+        Config.team.initial_player_positions.map do |pos|
+          case side
+          when :home
+            Position.new(
+              Config.field.offset.x + pos[0],
+              Config.field.offset.y + pos[1]
+            )
+          when :away
+            Position.new(
+              Config.field.offset.x + Config.field.width - pos[0],
+              Config.field.offset.y + Config.field.height - pos[1]
+            )
+          end
+        end
+      end
+
+      def goalkeeper_position(side)
+        initial_player_positions(side).first
+      end
+
+      def position_side(position)
+        if position.x < FieldMetrics.center_position.x
+          :home
+        else
+          :away
+        end
+      end
+
+      def out_of_bounds_width?(position)
+        lower_limit = Config.field.offset.x
+        upper_limit = Config.field.offset.x + Config.field.width
+        !(lower_limit..upper_limit).include?(position.x)
+      end
+
+      def out_of_bounds_height?(position)
+        lower_limit = Config.field.offset.y
+        upper_limit = Config.field.offset.y + Config.field.height
+        !(lower_limit..upper_limit).include?(position.y)
+      end
+
+      def goal?(position)
+        if out_of_bounds_width?(position)
+          lower_limit = center_position.y - Config.field.goal_height / 2
+          upper_limit = center_position.y + Config.field.goal_height / 2
+
+          (lower_limit..upper_limit).include?(position.y)
+        else
+          false
+        end
+      end
+
+      def close_to_goal?(position, side)
+        goal_position = FieldMetrics.goal_position(side)
+        goal_position.distance(position) < Config.field.close_to_goal_distance
+      end
+    end
+  end
+end

data/lib/rubygoal/formation.rb

@@ -0,0 +1,69 @@
+module Rubygoal
+  class Formation
+    attr_accessor :lineup
+
+    def initialize
+      @lineup = [
+        [:none, :none, :none, :none, :none],
+        [:none, :none, :none, :none, :none],
+        [:none, :none, :none, :none, :none],
+        [:none, :none, :none, :none, :none],
+        [:none, :none, :none, :none, :none],
+      ]
+    end
+
+    def defenders
+      column(0)
+    end
+
+    def midfielders
+      column(2)
+    end
+
+    def attackers
+      column(4)
+    end
+
+    def column(i)
+      lineup.map { |row| row[i] }
+    end
+
+    def defenders=(f)
+      assign_column(0, f)
+    end
+
+    def midfielders=(f)
+      assign_column(2, f)
+    end
+
+    def attackers=(f)
+      assign_column(4, f)
+    end
+
+    def assign_column(index, column)
+      column.each_with_index do |player, row_index|
+        lineup[row_index][index] = player
+      end
+    end
+
+    def errors
+      errors = {}
+
+      unified  = lineup.flatten
+      captains = unified.count(:captain)
+      fast     = unified.count(:fast)
+      average  = unified.count(:average)
+      total    = captains + fast + average
+
+      errors[:captains] = "La cantidad de capitanes es #{captains}" if captains != 1
+      errors[:fast] = "La cantidad de rapidos es #{fast}" if fast != 3
+      errors[:total] = "La cantidad total de jugadores es #{total}" if total != 10
+
+      errors
+    end
+
+    def valid?
+      errors.empty?
+    end
+  end
+end

data/lib/rubygoal/game.rb

@@ -0,0 +1,179 @@
+require 'gosu'
+require 'forwardable'
+
+require 'rubygoal/coordinate'
+require 'rubygoal/field'
+require 'rubygoal/field_metrics'
+require 'rubygoal/goal'
+
+module Rubygoal
+  class Game < Gosu::Window
+    attr_reader :field, :time, :score_home, :score_away
+
+    extend Forwardable
+    def_delegators :field, :ball, :close_to_goal?
+
+    def initialize
+      super(1920, 1080, true)
+      self.caption = "Ruby Goal"
+
+      @field = Field.new(self)
+      @goal = Goal.new(self)
+
+      @state = :playing
+
+      @time = Config.game.time
+      @score_home = 0
+      @score_away = 0
+
+      @font = Gosu::Font.new(
+        self,
+        Gosu.default_font_name,
+        Config.game.default_font_size
+      )
+
+      @home_team_label = create_label_image(name_home)
+      @away_team_label = create_label_image(name_away)
+    end
+
+    def update
+      return if state == :ended
+
+      update_elapsed_time
+
+      if field.goal?
+        update_goal
+      else
+        update_remaining_time
+        field.update
+      end
+
+      end_match! if time <= 0
+    end
+
+    def draw
+      field.draw
+      draw_scoreboard
+      draw_team_labels
+      goal.draw if field.goal?
+    end
+
+    def button_down(id)
+      if id == Gosu::KbEscape
+        close
+      end
+    end
+
+    protected
+
+    attr_writer :time, :score_home, :score_away
+    attr_accessor :state, :last_time, :elapsed_time
+
+    private
+
+    attr_reader :font, :goal, :home_team_label, :away_team_label
+
+    def create_label_image(name)
+      name = truncate_label(name, Config.game.max_name_length)
+      Gosu::Image.from_text(
+        self,
+        name,
+        Gosu.default_font_name,
+        Config.game.team_label_font_size,
+        1,
+        Config.game.team_label_width,
+        :center
+      )
+    end
+
+    def truncate_label(name, limit)
+      words = name.split
+
+      left = limit
+      truncated = []
+      words.each do |word|
+        break unless left > 0
+
+        truncated << word
+        left -= word.length + 1
+      end
+
+      truncated.join(' ')[0..limit]
+    end
+
+    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_goal
+      goal.update(elapsed_time)
+      reinitialize_match if goal.celebration_done?
+    end
+
+    def reinitialize_match
+      if FieldMetrics.position_side(ball.position) == :home
+        self.score_away += 1
+      else
+        self.score_home += 1
+      end
+
+      field.reinitialize
+    end
+
+    def draw_scoreboard
+      draw_text(time_text, Config.game.time_label_position, :gray)
+      draw_text(score_home.to_s, Config.game.score_home_label_position, :white)
+      draw_text(score_away.to_s, Config.game.score_away_label_position, :white)
+    end
+
+    def draw_team_labels
+      pos = Config.game.home_team_label_position
+      home_team_label.draw_rot(pos.x, pos.y, 1, -90)
+      pos = Config.game.away_team_label_position
+      away_team_label.draw_rot(pos.x, pos.y, 1, 90)
+    end
+
+    def draw_text(text, position, color, size = 1)
+      font.draw_rel(text, position.x, position.y, 0.5, 0.5, 1, size, size, color_to_hex(color))
+    end
+
+    def time_text
+      minutes = Integer(time) / 60
+      seconds = Integer(time) % 60
+      "%d:%02d" % [minutes, seconds]
+    end
+
+    def color_to_hex(color)
+      case color
+      when :white
+        0xffffffff
+      when :gray
+        0xff6d6e70
+      end
+    end
+
+    def end_match!
+      self.state = :ended
+      write_score
+    end
+
+    def write_score
+      puts "#{name_home} #{score_home} - #{score_away} #{name_away}"
+    end
+
+    def name_home
+      field.team_names[:home]
+    end
+
+    def name_away
+      field.team_names[:away]
+    end
+  end
+end

data/lib/rubygoal/goal.rb

@@ -0,0 +1,43 @@
+require 'gosu'
+
+require 'rubygoal/config'
+
+module Rubygoal
+  class Goal
+    def initialize(game_window)
+      @goal_image = Gosu::Image.new(game_window, Config.goal.image_file, true)
+
+      @celebration_time = 0
+    end
+
+    def celebration_done?
+      !celebrating?
+    end
+
+    def draw
+      position = Config.game.goal_image_position
+      goal_image.draw(position.x, position.y, 1)
+    end
+
+    def update(elapsed_time)
+      start_celebration unless celebrating?
+      self.celebration_time -= elapsed_time
+    end
+
+    protected
+
+    attr_accessor :celebration_time
+
+    private
+
+    attr_reader :goal_image
+
+    def start_celebration
+      self.celebration_time = 3
+    end
+
+    def celebrating?
+      celebration_time > 0
+    end
+  end
+end

data/lib/rubygoal/match.rb

@@ -0,0 +1,52 @@
+module Rubygoal
+  class Match
+    class Team
+      attr_reader :score, :result, :formation
+
+      def initialize(score, result, other_formation = nil)
+        @score     = score
+        @result    = result
+        @formation = other_formation
+      end
+
+      def draw?
+        result == :draw
+      end
+
+      def winning?
+        result == :win
+      end
+
+      def losing?
+        result == :lose
+      end
+    end
+
+    attr_reader :me, :other, :time
+
+    def initialize(my_score, other_score, time, other_formation)
+      @me = Match::Team.new(
+        my_score,
+        result(my_score, other_score)
+      )
+      @other = Match::Team.new(
+        other_score,
+        result(other_score, my_score),
+        other_formation
+      )
+      @time = time
+    end
+
+    private
+
+    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,55 @@
+require 'gosu'
+
+require 'rubygoal/coordinate'
+
+module Rubygoal
+  module Moveable
+    MIN_DISTANCE = 10
+
+    attr_accessor :position, :velocity
+
+    def initialize
+      @position = Position.new(0, 0)
+      @velocity = Velocity.new(0, 0)
+      @speed = 0
+      @destination = nil
+    end
+
+    def moving?
+      velocity.nonzero?
+    end
+
+    def distance(position)
+      Gosu.distance(self.position.x, self.position.y, position.x, position.y)
+    end
+
+    def move_to(destination)
+      self.destination = destination
+
+      angle = Gosu.angle(position.x, position.y, destination.x, destination.y)
+      velocity.x = Gosu.offset_x(angle, speed)
+      velocity.y = Gosu.offset_y(angle, speed)
+    end
+
+    def update
+      return unless moving?
+
+      if destination && distance(destination) < MIN_DISTANCE
+        stop
+      else
+        position.x += velocity.x
+        position.y += velocity.y
+      end
+    end
+
+    private
+
+    attr_reader :speed
+    attr_accessor :destination
+
+    def stop
+      self.destination = nil
+      self.velocity = Velocity.new(0, 0)
+    end
+  end
+end

data/lib/rubygoal/player.rb

@@ -0,0 +1,86 @@
+require 'gosu'
+
+require 'rubygoal/coordinate'
+require 'rubygoal/moveable'
+
+module Rubygoal
+  class Player
+    include Moveable
+
+    def initialize(game_window, side)
+      super()
+
+      @image = Gosu::Image.new(game_window, image_filename(side), false)
+      @time_to_kick_again = 0
+      @field = game_window.field
+    end
+
+    def can_kick?(ball)
+      !waiting_to_kick_again? && control_ball?(ball)
+    end
+
+    def kick(ball, target)
+      strength = Config.player.kick_strength * Random.rand(error_range)
+
+      direction = Gosu.angle(position.x, position.y, target.x, target.y)
+      direction *= Random.rand(error_range)
+
+      velocity = Velocity.new(
+        Gosu.offset_x(direction, strength),
+        Gosu.offset_y(direction, strength)
+      )
+      ball.velocity = velocity
+
+      reset_waiting_to_kick!
+    end
+
+    def update
+      update_waiting_to_kick!
+      super
+    end
+
+    def draw
+      if moving?
+        angle = Gosu.angle(position.x, position.y, destination.x, destination.y)
+        angle -= 90
+      else
+        angle = 0.0
+      end
+
+      image.draw_rot(position.x, position.y, 1, angle)
+    end
+
+    protected
+
+    attr_accessor :time_to_kick_again
+
+    private
+
+    attr_reader :field, :image, :error
+
+    def waiting_to_kick_again?
+      time_to_kick_again > 0
+    end
+
+    def reset_waiting_to_kick!
+      self.time_to_kick_again = Config.player.time_to_kick_again
+    end
+
+    def update_waiting_to_kick!
+      # TODO Make it time-based rather than counting ticks
+      self.time_to_kick_again -= 1 if waiting_to_kick_again?
+    end
+
+    def control_ball?(ball)
+      distance(ball.position) < Config.player.distance_control_ball
+    end
+
+    def error_range
+      (1.0 - error) .. (1.0 + error)
+    end
+  end
+end
+
+require 'rubygoal/players/average'
+require 'rubygoal/players/fast'
+require 'rubygoal/players/captain'

data/lib/rubygoal/players/average.rb

@@ -0,0 +1,20 @@
+module Rubygoal
+  class AveragePlayer < Player
+    def initialize(*args)
+      super
+      @error = 0.10 + Random.rand(0.05)
+      @speed = 3.5
+    end
+
+    protected
+
+    def image_filename(side)
+      case side
+      when :home
+        Config.player.average_home_image_file
+      when :away
+        Config.player.average_away_image_file
+      end
+    end
+  end
+end

data/lib/rubygoal/players/captain.rb

@@ -0,0 +1,20 @@
+module Rubygoal
+  class CaptainPlayer < Player
+    def initialize(*args)
+      super
+      @error = 0.05
+      @speed = 4.5
+    end
+
+    protected
+
+    def image_filename(side)
+      case side
+      when :home
+        Config.player.captain_home_image_file
+      when :away
+        Config.player.captain_away_image_file
+      end
+    end
+  end
+end

data/lib/rubygoal/players/fast.rb

@@ -0,0 +1,20 @@
+module Rubygoal
+  class FastPlayer < Player
+    def initialize(*args)
+      super
+      @error = 0.10 + Random.rand(0.05)
+      @speed = 4
+    end
+
+    protected
+
+    def image_filename(side)
+      case side
+      when :home
+        Config.player.fast_home_image_file
+      when :away
+        Config.player.fast_away_image_file
+      end
+    end
+  end
+end