basketball 0.0.8 → 0.0.9

data/lib/basketball/org/player.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Base class describing a player.
+    # A consumer application should extend these specific to their specific sports traits.
+    class Player < Entity
+      attr_reader :overall, :position
+
+      def initialize(id:, overall: 0, position: nil)
+        super(id)
+
+        raise ArgumentError, 'position is required' unless position
+
+        @overall  = overall
+        @position = position
+
+        freeze
+      end
+
+      def to_s
+        "[#{super}] (#{position}) #{overall}".strip
+      end
+    end
+  end
+end

data/lib/basketball/{draft → org}/position.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Basketball
-  module Draft
+  module Org
+    # Describes a player position.
     class Position < ValueObject
       extend Forwardable
 
@@ -17,7 +18,7 @@ module Basketball
       FRONT_COURT_VALUES = %w[PF C].to_set.freeze
       ALL_VALUES         = (BACK_COURT_VALUES.to_a + FRONT_COURT_VALUES.to_a).to_set.freeze
 
-      attr_reader_value :code
+      value_reader :code
 
       def_delegators :code, :to_s
 

data/lib/basketball/org/team.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Org
+    # Base class describing a team.  A team here is bare metal and is just described by an ID
+    # and a collection of Player objects.
+    class Team < Entity
+      attr_reader :players
+
+      def initialize(id:, players: [])
+        super(id)
+
+        @players = []
+
+        players.each { |p| sign!(p) }
+
+        freeze
+      end
+
+      def to_s
+        ([super.to_s] + players.map(&:to_s)).join("\n")
+      end
+
+      def signed?(player)
+        players.include?(player)
+      end
+
+      def sign!(player)
+        raise ArgumentError, 'player is required' unless player
+        raise PlayerAlreadySignedError, "#{player} already signed by #{self}" if signed?(player)
+
+        players << player
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/org.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'org/player'
+require_relative 'org/position'
+require_relative 'org/team'
+require_relative 'org/league'
+
+module Basketball
+  module Org
+    class PlayerAlreadySignedError < StandardError; end
+  end
+end

data/lib/basketball/season/arena.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # A very, very, very basic starting point for a "semi-randomized" game simulator.
+    class Arena
+      RANDOM             = :random
+      TOP_ONE            = :top_one
+      TOP_TWO            = :top_two
+      TOP_THREE          = :top_three
+      TOP_SIX            = :top_six
+      MAX_HOME_ADVANTAGE = 5
+
+      STRATEGY_FREQUENCIES = {
+        RANDOM => 10,
+        TOP_ONE => 5,
+        TOP_TWO => 10,
+        TOP_THREE => 20,
+        TOP_SIX => 30
+      }.freeze
+
+      private_constant :STRATEGY_FREQUENCIES,
+                       :RANDOM,
+                       :TOP_ONE,
+                       :TOP_TWO,
+                       :TOP_SIX,
+                       :MAX_HOME_ADVANTAGE
+
+      def initialize
+        @lotto = STRATEGY_FREQUENCIES.inject([]) do |memo, (name, frequency)|
+          memo + ([name] * frequency)
+        end.shuffle
+
+        freeze
+      end
+
+      def play(matchup)
+        scores        = generate_scores
+        winning_score = scores.max
+        losing_score  = scores.min
+        strategy      = pick_strategy
+
+        if home_wins?(matchup, strategy)
+          Result.new(
+            game: matchup.game,
+            home_score: winning_score,
+            away_score: losing_score
+          )
+        else
+          Result.new(
+            game: matchup.game,
+            home_score: losing_score,
+            away_score: winning_score
+          )
+        end
+      end
+
+      private
+
+      attr_reader :lotto
+
+      def pick_strategy
+        lotto.sample
+      end
+
+      def home_wins?(game, strategy)
+        send("#{strategy}_strategy", game)
+      end
+
+      def top_player_sum(players, amount)
+        players.sort_by(&:overall).reverse.take(amount).sum(&:overall)
+      end
+
+      def generate_scores
+        scores = [
+          rand(70..120),
+          rand(70..120)
+        ]
+
+        # No ties
+        scores[0] += 1 if scores[0] == scores[1]
+
+        scores
+      end
+
+      def random_strategy(_game)
+        # 60% chance home wins
+        (([0] * 6) + ([1] * 4)).sample.zero?
+      end
+
+      def random_home_advantage
+        rand(0..MAX_HOME_ADVANTAGE)
+      end
+
+      def top_one_strategy(matchup)
+        top_player_sum(matchup.home_players, 1) + random_home_advantage >= top_player_sum(matchup.away_players, 1)
+      end
+
+      def top_two_strategy(matchup)
+        top_player_sum(matchup.home_players, 2) + random_home_advantage >= top_player_sum(matchup.away_players, 2)
+      end
+
+      def top_three_strategy(matchup)
+        top_player_sum(matchup.home_players, 3) + random_home_advantage >= top_player_sum(matchup.away_players, 3)
+      end
+
+      def top_six_strategy(matchup)
+        top_player_sum(matchup.home_players, 6) + random_home_advantage >= top_player_sum(matchup.away_players, 6)
+      end
+    end
+  end
+end

data/lib/basketball/season/calendar.rb

@@ -2,28 +2,34 @@
 
 module Basketball
   module Season
-    class Calendar < ValueObject
-      class TeamAlreadyBookedError < StandardError; end
-      class InvalidGameOrderError < StandardError; end
+    # Sets boundaries for preseason and regular season play.  Add games as long as they are
+    # within the correct dated boundaries
+    class Calendar
       class OutOfBoundsError < StandardError; end
+      class TeamAlreadyBookedError < StandardError; end
 
       attr_reader :preseason_start_date,
                   :preseason_end_date,
                   :season_start_date,
-                  :season_end_date
-
-      attr_reader_value :year, :games
-
-      def initialize(year:, games: [])
-        super()
-
-        raise ArgumentError, 'year is required' unless year
-
-        @year                 = year
-        @preseason_start_date = Date.new(year, 9, 30)
-        @preseason_end_date   = Date.new(year, 10, 14)
-        @season_start_date    = Date.new(year, 10, 18)
-        @season_end_date      = Date.new(year + 1, 4, 29)
+                  :season_end_date,
+                  :games
+
+      def initialize(
+        preseason_start_date:,
+        preseason_end_date:,
+        season_start_date:,
+        season_end_date:,
+        games: []
+      )
+        raise ArgumentError, 'preseason_start_date is required' if preseason_start_date.to_s.empty?
+        raise ArgumentError, 'preseason_end_date is required'   if preseason_end_date.to_s.empty?
+        raise ArgumentError, 'season_start_date is required'    if season_start_date.to_s.empty?
+        raise ArgumentError, 'season_end_date is required'      if season_end_date.to_s.empty?
+
+        @preseason_start_date = preseason_start_date
+        @preseason_end_date   = preseason_end_date
+        @season_start_date    = season_start_date
+        @season_end_date      = season_end_date
         @games                = []
 
         games.each { |game| add!(game) }
@@ -40,78 +46,41 @@ module Basketball
         self
       end
 
-      def preseason_games_for(date: nil, team: nil)
-        games_for(date:, team:).select { |game| game.is_a?(PreseasonGame) }
+      def exhibitions_for(date: nil, opponent: nil)
+        games_for(date:, opponent:).select { |game| game.is_a?(Exhibition) }
       end
 
-      def season_games_for(date: nil, team: nil)
-        games_for(date:, team:).select { |game| game.is_a?(SeasonGame) }
+      def regulars_for(date: nil, opponent: nil)
+        games_for(date:, opponent:).select { |game| game.is_a?(Regular) }
       end
 
-      def games_for(date: nil, team: nil)
+      def games_for(date: nil, opponent: nil)
         games.select do |game|
-          (date.nil? || game.date == date) &&
-            (team.nil? || (game.home_team == team || game.away_team == team))
+          (date.nil? || game.date == date) && (opponent.nil? || game.for?(opponent))
         end
       end
 
-      def available_preseason_dates_for(team)
-        all_preseason_dates - preseason_games_for(team:).map(&:date)
-      end
-
-      def available_season_dates_for(team)
-        all_season_dates - season_games_for(team:).map(&:date)
-      end
-
-      def available_preseason_matchup_dates(team1, team2)
-        available_team_dates       = available_preseason_dates_for(team1)
-        available_other_team_dates = available_preseason_dates_for(team2)
-
-        available_team_dates & available_other_team_dates
-      end
-
-      def available_season_matchup_dates(team1, team2)
-        available_team_dates       = available_season_dates_for(team1)
-        available_other_team_dates = available_season_dates_for(team2)
-
-        available_team_dates & available_other_team_dates
-      end
-
-      def teams
-        games.flat_map(&:teams)
-      end
-
-      def team(id)
-        teams.find { |t| t == Team.new(id:) }
-      end
-
       private
 
-      def all_preseason_dates
-        (preseason_start_date..preseason_end_date).to_a
-      end
-
-      def all_season_dates
-        (season_start_date..season_end_date).to_a
-      end
-
       def assert_free_date(game)
-        if games_for(date: game.date, team: game.home_team).any?
-          raise TeamAlreadyBookedError, "#{game.home_team} already playing on #{game.date}"
+        if games_for(date: game.date, opponent: game.home_opponent).any?
+          raise TeamAlreadyBookedError, "#{game.home_opponent} already playing on #{game.date}"
         end
 
-        return unless games_for(date: game.date, team: game.away_team).any?
+        return unless games_for(date: game.date, opponent: game.away_opponent).any?
 
-        raise TeamAlreadyBookedError, "#{game.away_team} already playing on #{game.date}"
+        raise TeamAlreadyBookedError, "#{game.away_opponent} already playing on #{game.date}"
       end
 
       def assert_in_bounds(game)
-        if game.is_a?(PreseasonGame)
-          raise OutOfBoundsError, "#{game.date} is before preseason begins" if game.date < preseason_start_date
-          raise OutOfBoundsError, "#{game.date} is after preseason ends"    if game.date > preseason_end_date
-        elsif game.is_a?(SeasonGame)
-          raise OutOfBoundsError, "#{game.date} is before season begins" if game.date < season_start_date
-          raise OutOfBoundsError, "#{game.date} is after season ends"    if game.date > season_end_date
+        date = game.date
+
+        if game.is_a?(Exhibition)
+          raise OutOfBoundsError, "#{date} is before preseason begins" if date < preseason_start_date
+          raise OutOfBoundsError, "#{date} is after preseason ends"    if date > preseason_end_date
+        elsif game.is_a?(Regular)
+          raise OutOfBoundsError, "#{date} is before season begins" if date < season_start_date
+          raise OutOfBoundsError, "#{date} is after season ends"    if date > season_end_date
         else
           raise ArgumentError, "Dont know what this game type is: #{game.class.name}"
         end