basketball 0.0.8 → 0.0.10

data/lib/basketball/season/arena.rb

@@ -0,0 +1,113 @@
+# 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
+      DEFAULT_MAX_HOME_ADVANTAGE = 5
+
+      DEFAULT_STRATEGY_FREQUENCIES = {
+        RANDOM => 10,
+        TOP_ONE => 5,
+        TOP_TWO => 10,
+        TOP_THREE => 20,
+        TOP_SIX => 30
+      }.freeze
+
+      attr_reader :lotto, :max_home_advantage
+
+      def initialize(
+        strategy_frquencies: DEFAULT_STRATEGY_FREQUENCIES,
+        max_home_advantage: DEFAULT_MAX_HOME_ADVANTAGE
+      )
+        @max_home_advantage = max_home_advantage
+        @lotto              = make_lotto(strategy_frquencies)
+
+        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
+
+      def make_lotto(strategy_frquencies)
+        strategy_frquencies.inject([]) do |memo, (name, frequency)|
+          memo + ([name] * frequency)
+        end.shuffle
+      end
+
+      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

data/lib/basketball/season/coordinator.rb

@@ -1,179 +1,237 @@
 # frozen_string_literal: true
 
-require_relative 'calendar'
-
 module Basketball
   module Season
-    # This is the service class responsible for actually picking out free dates ane pairing up teams to
-    # play each other.  This is a reasonable naive first pass at some underlying match-making algorithms
-    # but could definitely use some help with the complexity/runtime/etc.
-    class Coordinator
-      MIN_PRESEASON_GAMES_PER_TEAM = 3
-      MAX_PRESEASON_GAMES_PER_TEAM = 6
-
-      private_constant :MIN_PRESEASON_GAMES_PER_TEAM,
-                       :MAX_PRESEASON_GAMES_PER_TEAM
-
-      def schedule(year:, league:)
-        Calendar.new(year:).tap do |calendar|
-          schedule_preseason!(calendar:, league:)
-          schedule_season!(calendar:, league:)
-        end
+    # Main iterator-based object that knows how to manage a calendar and simulate games per day.
+    class Coordinator < Entity
+      extend Forwardable
+
+      class AlreadyPlayedGameError < StandardError; end
+      class GameNotCurrentError < StandardError; end
+      class OutOfBoundsError < StandardError; end
+      class PlayedGamesError < StandardError; end
+      class UnknownGameError < StandardError; end
+      class UnknownTeamError < StandardError; end
+      class UnplayedGamesError < StandardError; end
+
+      attr_reader :calendar,
+                  :current_date,
+                  :arena,
+                  :results,
+                  :league
+
+      def_delegators :calendar,
+                     :preseason_start_date,
+                     :preseason_end_date,
+                     :season_start_date,
+                     :season_end_date,
+                     :games,
+                     :exhibitions_for,
+                     :regulars_for,
+                     :games_for
+
+      def initialize(
+        calendar:,
+        current_date:,
+        results: [],
+        league: Org::League.new
+      )
+        super()
+
+        raise ArgumentError, 'calendar is required' unless calendar
+        raise ArgumentError, 'current_date is required' if current_date.to_s.empty?
+        raise ArgumentError, 'league is required' unless league
+
+        @calendar     = calendar
+        @current_date = current_date
+        @arena        = Arena.new
+        @results      = []
+        @league       = league
+
+        results.each { |result| replay!(result) }
+
+        assert_current_date
+        assert_all_past_dates_are_played
+        assert_all_future_dates_arent_played
+        assert_all_known_teams
       end
 
-      private
+      def sim_rest!(&)
+        events = []
+
+        while not_done?
+          new_events = sim!(&)
 
-      def base_matchup_count(league, team1, team2)
-        # Same Conference, Same Division
-        if league.division_for(team1) == league.division_for(team2)
-          4
-        # Same Conference, Different Division  and one of 4/10 that play 3 times
-        elsif league.conference_for(team1) == league.conference_for(team2)
-          3
-        # Different Conference
-        else
-          2
+          events += new_events
         end
+
+        events
       end
 
-      # rubocop:disable Metrics/AbcSize
-      # This method derives the plan for which a schedule can be generated from.
-      def matchup_plan(league)
-        matchups    = {}
-        game_counts = league.teams.to_h { |t| [t, 0] }
-        teams       = game_counts.keys
-
-        (0...teams.length).each do |i|
-          team1 = teams[i]
-
-          (i + 1...teams.length).each do |j|
-            team2              = teams[j]
-            key                = [team1, team2].sort
-            count              = base_matchup_count(league, team1, team2)
-            matchups[key]      = count
-            game_counts[team1] += count
-            game_counts[team2] += count
-          end
+      def assert_current_date
+        if current_date < preseason_start_date
+          raise OutOfBoundsError, "current date #{current_date} should be on or after #{preseason_start_date}"
         end
 
-        # Each team will play 6 games against conference opponents in other divisions.
-        # The fours hash will be that plan.
-        find_fours(league).each do |team, opponents|
-          next if game_counts[team] == 82
+        return unless current_date > season_end_date
+
+        raise OutOfBoundsError, "current date #{current_date} should be on or after #{preseason_start_date}"
+      end
 
-          opponents.each do |opponent|
-            next if game_counts[team] == 82
-            next if game_counts[opponent] == 82
+      def sim!
+        return [] if done?
 
-            game_counts[team] += 1
-            game_counts[opponent] += 1
+        events = []
+        games  = games_for(date: current_date)
 
-            key = [team, opponent].sort
+        games.each do |game|
+          home_players = opponent_team(game.home_opponent).players
+          away_players = opponent_team(game.away_opponent).players
+          matchup      = Matchup.new(game:, home_players:, away_players:)
+          event        = arena.play(matchup)
 
-            matchups[key] += 1
-          end
+          play!(event)
+
+          yield(event) if block_given?
+
+          events << event
         end
 
-        matchups
-      end
-      # rubocop:enable Metrics/AbcSize
+        increment_current_date!
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      # I am not liking this algorithm implementation at all but it will seemingly produce a valid
-      # result about 1 out of every 1000 cycles. I have yet to spot the assignment pattern to make
-      # this way more deterministic.
-      def find_fours(league)
-        balanced     = false
-        count        = 0
-        four_tracker = {}
+        events
+      end
 
-        until balanced
-          # Let's not completely thrash our CPUs in case this algorithm hits an infinite loop.
-          # Instead, lets hard-fail against a hard boundary.
-          raise ArgumentError, 'we spent too much CPU time and didnt resolve fours' if count > 100_000
+      def total_days
+        (season_end_date - preseason_start_date).to_i
+      end
 
-          four_tracker = league.teams.to_h { |team| [team, []] }
+      def days_left
+        (season_end_date - current_date).to_i
+      end
 
-          league.teams.each do |team|
-            opponents = league.cross_division_opponents_for(team).shuffle
+      def total_exhibitions
+        exhibitions_for.length
+      end
 
-            opponents.each do |opponent|
-              if four_tracker[team].length < 6 && four_tracker[opponent].length < 6
-                four_tracker[opponent] << team
-                four_tracker[team] << opponent
-              end
-            end
-          end
+      def exhibitions_left
+        total_exhibitions - exhibition_result_events.length
+      end
 
-          good = true
+      def total_regulars
+        regulars_for.length
+      end
 
-          # trip-wire: if one team isnt balanced then we are not balanced
-          four_tracker.each { |_k, v| good = false if v.length < 6 }
+      def regulars_left
+        total_regulars - regular_result_events.length
+      end
 
-          balanced = good
+      def current_games
+        games_for(date: current_date) - results.map(&:game)
+      end
 
-          count += 1
-        end
+      def done?
+        current_date == season_end_date && games.length == results.length
+      end
 
-        four_tracker
+      def not_done?
+        !done?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def schedule_season!(calendar:, league:)
-        matchups = matchup_plan(league)
+      def add!(game)
+        assert_today_or_in_future(game)
+        assert_known_teams(game)
 
-        matchups.each do |(team1, team2), count|
-          candidates = calendar.available_season_matchup_dates(team1, team2)
-          dates      = candidates.sample(count)
-          games      = balanced_games(dates, team1, team2)
+        calendar.add!(game)
 
-          games.each { |game| calendar.add!(game) }
-        end
+        self
       end
 
-      def balanced_games(dates, team1, team2)
-        dates.map.with_index(1) do |date, index|
-          if index.even?
-            SeasonGame.new(date:, home_team: team1, away_team: team2)
-          else
-            SeasonGame.new(date:, home_team: team2, away_team: team1)
-          end
+      def result_for(game)
+        results.find do |result|
+          result.game == game
         end
       end
 
-      def schedule_preseason!(calendar:, league:)
-        league.teams.each do |team|
-          current_games = calendar.preseason_games_for(team:)
-          count         = current_games.length
+      private
+
+      attr_writer :arena
+
+      def opponent_team(opponent)
+        league.teams.find { |t| t == opponent }
+      end
+
+      def exhibition_result_events
+        results.select { |e| e.game.is_a?(Exhibition) }
+      end
 
-          next if count >= MIN_PRESEASON_GAMES_PER_TEAM
+      def regular_result_events
+        results.select { |e| e.game.is_a?(Regular) }
+      end
 
-          other_teams = (league.teams - [team]).shuffle
+      def increment_current_date!
+        return self if current_date >= season_end_date
 
-          other_teams.each do |other_team|
-            break if count > MIN_PRESEASON_GAMES_PER_TEAM
-            next  if calendar.preseason_games_for(team: other_team).length >= MAX_PRESEASON_GAMES_PER_TEAM
+        @current_date = current_date + 1
 
-            candidates = calendar.available_preseason_matchup_dates(team, other_team)
+        self
+      end
 
-            next if candidates.empty?
+      def assert_today_or_in_future(game)
+        return unless game.date <= current_date
 
-            date = candidates.sample
-            game = random_preseason_game(date, team, other_team)
+        raise OutOfBoundsError, "#{game.date} is on or before the current date (#{current_date})"
+      end
 
-            calendar.add!(game)
+      def assert_known_teams(game)
+        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" if league.not_registered?(game.home_opponent)
 
-            count += 1
-          end
-        end
+        return unless league.not_registered?(game.away_opponent)
+
+        raise UnknownTeamError, "unknown opponent: #{game.away_opponent}"
       end
 
-      def random_preseason_game(date, team1, team2)
-        if rand(1..2) == 1
-          PreseasonGame.new(date:, home_team: team1, away_team: team2)
-        else
-          PreseasonGame.new(date:, home_team: team2, away_team: team1)
+      def assert_all_past_dates_are_played
+        games_that_should_be_played = games.select { |game| game.date < current_date }
+
+        games_played   = results.map(&:game)
+        unplayed_games = games_that_should_be_played - games_played
+
+        return if unplayed_games.empty?
+
+        raise UnplayedGamesError, "#{unplayed_games.length} game(s) not played before #{current_date}"
+      end
+
+      def assert_all_future_dates_arent_played
+        games_that_shouldnt_be_played = results.select do |result|
+          result.date > current_date
         end
+
+        count = games_that_shouldnt_be_played.length
+
+        return unless games_that_shouldnt_be_played.any?
+
+        raise PlayedGamesError, "#{count} game(s) played after #{current_date}"
+      end
+
+      def play!(result)
+        raise GameNotCurrentError, "#{result} is not for #{current_date}" if result.date != current_date
+
+        replay!(result)
+      end
+
+      def replay!(result)
+        raise AlreadyPlayedGameError, "#{result.game} already played!" if result_for(result.game)
+
+        raise UnknownGameError, "game not added: #{result.game}" unless games.include?(result.game)
+
+        results << result
+
+        result
+      end
+
+      def assert_all_known_teams
+        calendar.games.each { |game| assert_known_teams(game) }
       end
     end
   end

data/lib/basketball/season/{preseason_game.rb → exhibition.rb}

@@ -2,7 +2,8 @@
 
 module Basketball
   module Season
-    class PreseasonGame < Game
+    # An exhibition game.
+    class Exhibition < Game
       def to_s
         "#{super} (preseason)"
       end