rubygoal 0.0.2 → 2.0.0

data/lib/rubygoal/coach.rb

@@ -1,11 +0,0 @@
-module Rubygoal
-  class Coach
-    def name
-      raise NotImplementedError
-    end
-
-    def formation(match)
-      raise NotImplementedError
-    end
-  end
-end

data/lib/rubygoal/coach_loader.rb

@@ -1,32 +0,0 @@
-module Rubygoal
-  module CoachLoader
-    class << self
-      def get(default)
-        file = ARGV.shift
-
-        if file && File.exists?(file)
-          load file
-
-          class_name = camelize(File.basename(file, ".rb"))
-          Rubygoal.const_get(class_name).new
-        else
-          if file
-            puts "File `#{file}` doesn't exist. Using #{default.name}."
-          end
-
-          default.new
-        end
-      end
-
-      private
-
-      def camelize(term)
-        string = term.to_s
-        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
-        string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
-        string.gsub!('/', '::')
-        string
-      end
-    end
-  end
-end

data/lib/rubygoal/coaches/coach_away.rb

@@ -1,52 +0,0 @@
-require 'rubygoal/coach'
-require 'rubygoal/formation'
-
-module Rubygoal
-  class CoachAway < Coach
-    def name
-      "Danubio"
-    end
-
-    def formation(match)
-      formation = Formation.new
-
-      if match.me.winning?
-        formation.lineup = [
-          [:average, :none, :average, :none,    :none],
-          [:fast,    :none, :none,    :average, :none],
-          [:none,    :none, :captain, :none,    :fast],
-          [:fast,    :none, :none,    :none, :average],
-          [:average, :none, :average, :none,    :none],
-        ]
-      elsif match.me.draw?
-        formation.lineup = [
-          [:average, :none, :average, :none,    :none],
-          [:fast, :none, :none,    :none,    :fast],
-          [:none,    :fast, :none,    :captain, :none],
-          [:average, :none, :none,    :none,    :average],
-          [:average, :none, :average, :none,    :none],
-        ]
-      elsif match.me.losing?
-        if match.time < 30
-          formation.lineup = [
-            [:none,    :none, :average, :none,    :none],
-            [:average, :none, :none,    :none,    :average],
-            [:average, :fast, :none,    :captain, :none],
-            [:average, :none, :fast,    :none,    :fast],
-            [:none,    :none, :average, :none,    :none],
-          ]
-        else
-          formation.lineup = [
-            [:none,    :none,    :average, :none, :none],
-            [:average, :none,    :none,    :none, :average],
-            [:fast,    :average, :none,    :fast, :none],
-            [:average, :none,    :captain, :none, :fast],
-            [:none,    :none,    :average, :none, :none],
-          ]
-        end
-      end
-
-      formation
-    end
-  end
-end

data/lib/rubygoal/coaches/coach_home.rb

@@ -1,28 +0,0 @@
-require 'rubygoal/coach'
-require 'rubygoal/formation'
-
-module Rubygoal
-  class CoachHome < Coach
-    def name
-      "Wanderers"
-    end
-
-    def formation(match)
-      formation = Formation.new
-
-      if match.me.winning?
-        formation.defenders = [:average, :average, :average, :captain, :average]
-        formation.midfielders = [:average, :none, :fast, :none, :average]
-        formation.attackers = [:none, :fast, :none, :fast, :none]
-      elsif match.time < 20
-        formation.defenders = [:none, :fast, :average, :average, :none]
-        formation.midfielders = [:average, :average, :captain, :none, :average]
-        formation.attackers = [:fast, :none, :none, :fast, :average]
-      else
-        formation.lineup = match.other.formation.lineup
-      end
-
-      formation
-    end
-  end
-end

data/lib/rubygoal/coaches/template.rb

@@ -1,198 +0,0 @@
-# RubyGoal - Fútbol para Rubistas
-#
-# Este documento contiene varias implementaciones mínimas de un entrenador de RubyGoal.#
-#
-# Esta clase debe implementar, como mínimo, los métodos `name` y `formation(match)`
-# Esta clase debe ser implementada dentro del módulo Rubygoal
-
-module Rubygoal
-  class MyCoach < Coach
-    # Indica el nombre del equipo
-    # Debe retornar un string
-    def name
-      "My team name"
-    end
-
-    # Este método debe devolver una instancia de Formation indicando como
-    # se tienen que parar los jugadores en la cancha
-    #
-    # Este método es invocado constantemente (varias veces por segundo)
-    # proporcionando información de como va el partido utilizando el
-    # parámetro match
-    def formation(match)
-      formation = Formation.new
-
-      # La clase Formation tiene varios helpers para ayudar a definir la
-      # formación del equipo
-      #
-      # La cancha se divide en una matriz de 5 por 5
-      #
-      #   ------------------------------
-      #   | N     N     N     N     N  |
-      #   |                            |
-      #   | N     N     N     N     N  |
-      # A |                            | A
-      # R | N     N     N     N     N  | R
-      # C |                            | C
-      # O | N     N     N     N     N  | O
-      #   |                            |
-      #   | N     N     N     N     N  |
-      #   ------------------------------
-      #
-      # Esto es un ejemplo que posiciona jugadores en columnas de la matriz
-      #
-      # Los tipos de jugadores válidos son :average, :fast, :captain
-      # Se usa :none para las posiciones que no se usen en la línea
-      #
-      # Restricciones:
-      # Exactamente un :captain
-      # Exactamente tres :fast
-      # Exactamente seis :average
-      #
-      # :captain -> Este jugador es el más rápido y preciso del equipo
-      # :fast -> Estos jugadores son más rápidos que los demás (aunque más lentos que
-      #          el capitán del equipo)
-      # :average -> Estos jugadores completan el equipo
-      #
-      # El arquero no hay que especificarlo, ya viene incluido por defecto
-      formation.defenders = [:none, :average, :average, :average, :none]
-      formation.midfielders = [:average, :fast, :captain, :none, :average]
-      formation.attackers = [:none, :fast, :none, :fast, :average]
-
-      # Esto produce la siguiente alineación
-      #
-      #   ------------------------------
-      #   | N     N     A     N     N  |
-      #   |                            |
-      #   | A     N     F     N     F  |
-      # A |                            | A
-      # R | A     N     C     N     N  | R
-      # C |                            | C
-      # O | A     N     N     N     F  | O
-      #   |                            |
-      #   | N     N     A     N     A  |
-      #   ------------------------------
-
-      formation
-    end
-  end
-
-  # Lo siguiente es otra implementación posible de una instancia de Coach
-
-  class AnotherCoach < Coach
-    def name
-      "Maeso FC"
-    end
-
-    # El método formation debe devolver una instancia de Formation
-    # El siguiten ejemplo muestra como controlar la posición de los jugadores
-    # de una forma más fina, usando el método `lineup`
-    #
-    def formation(match)
-      formation = Formation.new
-
-      # Por defecto el valor de formation.lineup es
-      #
-      # [
-      #   [: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],
-      # ]
-      #
-      # Este valor DEBE sobreescribirse con una formación que incluya las
-      # cantidades correctas de :average, :fast y :captain
-      #
-      # Para este tipo de estrategias es importante siempre considerar que el arco
-      # que atacas es el de la derecha.
-      #
-      # En el siguiente ejemplo, la formación 4322 puede interpretarse
-      # de la siguiente manera
-      #                |                            |
-      #      defensa   |     medio campo            | delantera
-      # [              |                            |
-      #   [  :average, | :none, :average, :none,    | :none     ],
-      #   [  :fast,    | :none, :none,    :average, | :none     ],
-      #   [  :none,    | :none, :captain, :none,    | :fast     ],
-      #   [  :fast,    | :none, :none,    :average, | :average  ],
-      #   [  :average, | :none, :average, :none,    | :none     ],
-      # ]              |                            |
-      #                |                            |
-      #
-      # Usando `lineup`, la línea mas defensiva son los primeros elementos de
-      # cada uno de los arrays (:average, :fast, :none, :fast, :average)
-      #
-      # La segunda línea (entre la defensa y los mediocampistas) no tiene jugadores
-      # (son todos :none)
-      #
-      # La tercer línea, la que corresponde a los mediocampistas, son el tercer
-      # elemento de cada array (:average, :none, :captain, :none, :average)
-      #
-      # La cuarta línea está ubicada entre los mediocampistas y delanteros
-      # (:none, :average, :none, :average, :none)
-      #
-      # Los últimos elementos de los arrays corresponden a la línea de
-      # delanteros (:none, :none, :fast, :average, :none)
-      formation.lineup = [
-        [:average, :none, :average, :none,    :none],
-        [:fast,    :none, :none,    :average, :none],
-        [:none,    :none, :captain, :none,    :fast],
-        [:fast,    :none, :none,    :average, :average],
-        [:average, :none, :average, :none,    :none],
-      ]
-
-      formation
-    end
-  end
-
-  # Otra implementación posible de una instancia de Coach
-
-  # Gran parte de la gracia de este juego está en hacer cambios en la formación
-  # a medida que va transcurriendo el partido
-  #
-  # La instancia de `match` que recibe el método `formation` contiene información
-  # sobre el partido y el rival de turno
-  #
-  # Veamos un ejemplo
-
-  class MyCoach < Coach
-    def name
-      "Villa Pancha"
-    end
-
-    def formation(match)
-      formation = Formation.new
-
-      # El método `me` trae información sobre mi equipo en el partido
-      #
-      # me.winning? indica si estoy ganando
-      # me.losing? y me.draw? son análogos al anterior :)
-      # me.score me indica la cantidad exacta de goles que marcó mi equipo
-      if match.me.winning?
-        formation.defenders = [:average, :average, :average, :captain, :average]
-        formation.midfielders = [:average, :none, :fast, :none, :average]
-        formation.attackers = [:none, :fast, :none, :fast, :none]
-        #
-        # El método `time` indica cuanto tiempo (segundos) le queda al partido.
-        # Devuelve un número entre 120 y 0 (120 cuando comienza el partido)
-      elsif match.time < 10
-        formation.defenders = [:none, :average, :average, :average, :none]
-        formation.midfielders = [:average, :average, :captain, :none, :average]
-        formation.attackers = [:fast, :fast, :none, :fast, :average]
-      else
-        #
-        # El método `other` devuelve información básica del rival. Tiene los mismos
-        # métodos que `me`.
-        #
-        # En particular, se puede acceder a la formación definida por el equipo
-        # contrario. En la siguiente linea, a modo de ejemplo, se estableció
-        # una táctica `espejo` con respecto al rival (posiciono mis jugadores en forma
-        # simétrica)
-        formation.lineup = match.other.formation.lineup
-      end
-
-      formation
-    end
-  end
-end

data/lib/rubygoal/config.rb

@@ -1,64 +0,0 @@
-require 'rubygoal/config_definitions'
-require 'rubygoal/coordinate'
-
-module Rubygoal
-  module Config
-    field.width                   = 1392
-    field.height                  = 934
-    field.offset                  = Position.new(262, 114)
-    field.goal_height             = 275
-    field.close_to_goal_distance  = 275
-    field.background_image_file   = File.dirname(__FILE__) + '/../../media/background.png'
-
-    team.initial_player_positions = [
-                                      [50, 466],
-                                      [236, 106],
-                                      [236, 286],
-                                      [236, 646],
-                                      [236, 826],
-                                      [436, 106],
-                                      [436, 286],
-                                      [436, 646],
-                                      [436, 826],
-                                      [616, 436],
-                                      [616, 496]
-                                    ]
-    team.average_players_count    = 7
-    team.fast_players_count       = 3
-    team.captain_players_count    = 1
-
-
-    ball.width                    = 20
-    ball.height                   = 20
-    ball.image_file               = File.dirname(__FILE__) + '/../../media/ball.png'
-
-
-    player.time_to_kick_again     = 60
-    player.distance_control_ball  = 30
-    player.kick_strength          = 20
-
-
-    player.captain_home_image_file  = File.dirname(__FILE__) + '/../../media/captain_home.png'
-    player.captain_away_image_file  = File.dirname(__FILE__) + '/../../media/captain_away.png'
-    player.fast_home_image_file     = File.dirname(__FILE__) + '/../../media/fast_home.png'
-    player.fast_away_image_file     = File.dirname(__FILE__) + '/../../media/fast_away.png'
-    player.average_home_image_file  = File.dirname(__FILE__) + '/../../media/average_home.png'
-    player.average_away_image_file  = File.dirname(__FILE__) + '/../../media/average_away.png'
-
-
-    goal.image_file               = File.dirname(__FILE__) + '/../../media/goal.png'
-
-
-    game.time                      = 120
-    game.goal_image_position       = Position.new(596, 466)
-    game.time_label_position       = Position.new(870, 68)
-    game.score_home_label_position = Position.new(1150, 68)
-    game.score_away_label_position = Position.new(1220, 68)
-    game.max_name_length           = 20
-    game.default_font_size         = 48
-    game.team_label_font_size      = 64
-    game.team_label_width          = 669
-    game.home_team_label_position  = Position.new(105, 580)
-    game.away_team_label_position  = Position.new(1815, 580)
-  end
-end

data/lib/rubygoal/config_definitions.rb

@@ -1,77 +0,0 @@
-module Rubygoal
-  module Config
-    class Field  < Struct.new(:width,
-                              :height,
-                              :offset,
-                              :goal_height,
-                              :close_to_goal_distance,
-                              :background_image_file)
-    end
-
-    class Team   < Struct.new(:initial_player_positions,
-                             :average_players_count,
-                             :fast_players_count,
-                             :captain_players_count)
-    end
-
-    class Ball   < Struct.new(:width,
-                              :height,
-                              :image_file)
-    end
-
-    class Player < Struct.new(:time_to_kick_again,
-                              :distance_control_ball,
-                              :kick_strength,
-                              :average_home_image_file,
-                              :average_away_image_file,
-                              :fast_home_image_file,
-                              :fast_away_image_file,
-                              :captain_home_image_file,
-                              :captain_away_image_file)
-    end
-
-    class Goal   < Struct.new(:image_file,
-                              :sound_file)
-    end
-
-    class Game   < Struct.new(:time,
-                              :goal_image_position,
-                              :time_label_position,
-                              :score_home_label_position,
-                              :score_away_label_position,
-                              :max_name_length,
-                              :default_font_size,
-                              :team_label_font_size,
-                              :team_label_width,
-                              :home_team_label_position,
-                              :away_team_label_position,
-                              :background_sound_file)
-    end
-
-    class << self
-      def field
-        @field ||= Field.new
-      end
-
-      def team
-        @team ||= Team.new
-      end
-
-      def ball
-        @ball ||= Ball.new
-      end
-
-      def player
-        @player ||= Player.new
-      end
-
-      def goal
-        @goal ||= Goal.new
-      end
-
-      def game
-        @game ||= Game.new
-      end
-    end
-  end
-end

data/lib/rubygoal/coordinate.rb

@@ -1,25 +0,0 @@
-require 'gosu'
-
-module Rubygoal
-  class Coordinate < Struct.new(:x, :y)
-    def distance(coordinate)
-      Gosu.distance(x, y, coordinate.x, coordinate.y)
-    end
-
-    def add(coordinate)
-      Coordinate.new(x + coordinate.x, y + coordinate.y)
-    end
-
-    def to_s
-      "(#{x}, #{y})"
-    end
-  end
-
-  class Position < Coordinate; end
-
-  class Velocity < Coordinate
-    def nonzero?
-      x != 0 && y != 0
-    end
-  end
-end

data/lib/rubygoal/field.rb

@@ -1,84 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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