basketball 0.0.10 → 0.0.11

data/lib/basketball/season/coordinator.rb

@@ -21,10 +21,10 @@ module Basketball
                   :league
 
       def_delegators :calendar,
-                     :preseason_start_date,
-                     :preseason_end_date,
-                     :season_start_date,
-                     :season_end_date,
+                     :exhibition_start_date,
+                     :exhibition_end_date,
+                     :regular_start_date,
+                     :regular_end_date,
                      :games,
                      :exhibitions_for,
                      :regulars_for,
@@ -69,13 +69,13 @@ module Basketball
       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}"
+        if current_date < exhibition_start_date
+          raise OutOfBoundsError, "current date #{current_date} should be on or after #{exhibition_start_date}"
         end
 
-        return unless current_date > season_end_date
+        return unless current_date > regular_end_date
 
-        raise OutOfBoundsError, "current date #{current_date} should be on or after #{preseason_start_date}"
+        raise OutOfBoundsError, "current date #{current_date} should be on or after #{exhibition_start_date}"
       end
 
       def sim!
@@ -103,11 +103,11 @@ module Basketball
       end
 
       def total_days
-        (season_end_date - preseason_start_date).to_i
+        (regular_end_date - exhibition_start_date).to_i
       end
 
       def days_left
-        (season_end_date - current_date).to_i
+        (regular_end_date - current_date).to_i
       end
 
       def total_exhibitions
@@ -131,7 +131,7 @@ module Basketball
       end
 
       def done?
-        current_date == season_end_date && games.length == results.length
+        current_date == regular_end_date && games.length == results.length
       end
 
       def not_done?
@@ -153,6 +153,14 @@ module Basketball
         end
       end
 
+      def regular_results
+        results.select { |result| result.game.is_a?(Regular) }
+      end
+
+      def exhibition_results
+        results.select { |result| result.game.is_a?(Exhibition) }
+      end
+
       private
 
       attr_writer :arena
@@ -170,7 +178,7 @@ module Basketball
       end
 
       def increment_current_date!
-        return self if current_date >= season_end_date
+        return self if current_date >= regular_end_date
 
         @current_date = current_date + 1
 
@@ -184,9 +192,9 @@ module Basketball
       end
 
       def assert_known_teams(game)
-        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" if league.not_registered?(game.home_opponent)
+        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" unless league.team?(game.home_opponent)
 
-        return unless league.not_registered?(game.away_opponent)
+        return if league.team?(game.away_opponent)
 
         raise UnknownTeamError, "unknown opponent: #{game.away_opponent}"
       end

data/lib/basketball/season/detail.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Describes a result from the perspective of a team.
+    class Detail < ValueObject
+      value_reader :date,
+                   :home,
+                   :opponent_score,
+                   :opponent,
+                   :score
+
+      alias home? home
+
+      def initialize(date:, home:, opponent:, opponent_score:, score:)
+        super()
+
+        raise ArgumentError,  'date is required'           unless date
+        raise ArgumentError,  'opponent is required'       unless opponent
+        raise ArgumentError,  'score is required'          unless score
+        raise ArgumentError,  'opponent_score is required' unless opponent_score
+        raise ArgumentError,  'home is required'           if home.nil?
+        raise CannotTieError, 'scores cannot be equal'     if score == opponent_score
+
+        @date           = date
+        @opponent       = opponent
+        @score          = score
+        @opponent_score = opponent_score
+        @home           = home
+
+        freeze
+      end
+
+      def win?
+        score > opponent_score
+      end
+
+      def loss?
+        score < opponent_score
+      end
+
+      def to_s
+        "[#{date}] #{win? ? 'Win' : 'Loss'} #{home? ? 'vs' : 'at'} #{opponent} (#{score}-#{opponent_score})"
+      end
+    end
+  end
+end

data/lib/basketball/season/exhibition.rb

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

data/lib/basketball/season/opponent.rb

@@ -5,6 +5,12 @@ module Basketball
     # Represents a team without a roster.  Equal to a team by identity.
     # A team's roster will not be known until the last minute (when it is game time).
     class Opponent < Entity
+      class << self
+        def from(team)
+          new(id: team.id)
+        end
+      end
+
       def initialize(id:)
         super(id)
 

data/lib/basketball/season/record.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Represents a team within a Standings object. Each Record is comprised of Detail instances
+    # which are the game results in the perspective of a single Team.
+    class Record < Entity
+      class DetailAlreadyAddedError < StandardError; end
+      class OpponentNotFoundError < StandardError; end
+
+      def initialize(id:)
+        super(id)
+
+        @details_by_date = {}
+
+        details.each { |detail| add!(detail) }
+
+        freeze
+      end
+
+      def accept!(result)
+        if result.home_opponent == self
+          detail = Detail.new(
+            date: result.date,
+            opponent: result.away_opponent,
+            score: result.home_score,
+            opponent_score: result.away_score,
+            home: true
+          )
+
+          add!(detail)
+        elsif result.away_opponent == self
+          detail = Detail.new(
+            date: result.date,
+            opponent: result.home_opponent,
+            score: result.away_score,
+            opponent_score: result.home_score,
+            home: false
+          )
+
+          add!(detail)
+        else
+          raise OpponentNotFoundError, "#{result} has no opponent for #{self}"
+        end
+      end
+
+      def detail_for(date)
+        details_by_date[date]
+      end
+
+      def details
+        details_by_date.values
+      end
+
+      def win_percentage
+        (win_count.to_f / game_count).round(3)
+      end
+
+      def game_count
+        details.length
+      end
+
+      def win_count
+        details.count(&:win?)
+      end
+
+      def loss_count
+        details.count(&:loss?)
+      end
+
+      def to_s
+        "[#{super}] #{win_count}-#{loss_count} (#{win_percentage})"
+      end
+
+      def <=>(other)
+        [win_count, win_percentage] <=> [other.win_count, other.win_percentage]
+      end
+
+      private
+
+      attr_reader :details_by_date
+
+      def add!(detail)
+        raise DetailAlreadyAddedError, "#{detail} already added for date" if detail_for(detail.date)
+
+        details_by_date[detail.date] = detail
+
+        self
+      end
+    end
+  end
+end

data/lib/basketball/season/scheduler.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # This is the service class responsible for actually picking out free dates and 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 Scheduler
+      class BadConferencesSizeError < StandardError; end
+      class BadDivisionsSizeError < StandardError; end
+      class BadTeamsSizeError < StandardError; end
+
+      MIN_PRESEASON_GAMES_PER_TEAM = 3
+      MAX_PRESEASON_GAMES_PER_TEAM = 6
+      CONFERENCES_SIZE             = 2
+      DIVISIONS_SIZE               = 3
+      TEAMS_SIZE                   = 5
+
+      private_constant :MIN_PRESEASON_GAMES_PER_TEAM,
+                       :MAX_PRESEASON_GAMES_PER_TEAM,
+                       :CONFERENCES_SIZE,
+                       :DIVISIONS_SIZE,
+                       :TEAMS_SIZE
+
+      def schedule(league:, year: Time.now.year)
+        assert_properly_sized_league(league)
+
+        Calendar.new(**make_dates(year)).tap do |calendar|
+          schedule_exhibition!(calendar:, league:)
+          schedule_season!(calendar:, league:)
+        end
+      end
+
+      private
+
+      def make_dates(year)
+        {
+          exhibition_start_date: Date.new(year, 9, 30),
+          exhibition_end_date: Date.new(year, 10, 14),
+          regular_start_date: Date.new(year, 10, 18),
+          regular_end_date: Date.new(year + 1, 4, 29)
+        }
+      end
+
+      def assert_properly_sized_league(league)
+        if league.conferences.length != CONFERENCES_SIZE
+          raise BadConferencesSizeError, "there has to be #{CONFERENCES_SIZE} conferences"
+        end
+
+        league.conferences.each do |conference|
+          if conference.divisions.length != DIVISIONS_SIZE
+            raise BadDivisionsSizeError, "#{conference.id} should have exactly #{DIVISIONS_SIZE} divisions"
+          end
+
+          conference.divisions.each do |division|
+            if division.teams.length != TEAMS_SIZE
+              raise BadTeamsSizeError, "#{division.id} should have exactly #{TEAMS_SIZE} teams"
+            end
+          end
+        end
+      end
+
+      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
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # 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
+        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
+
+          opponents.each do |opponent|
+            next if game_counts[team] == 82
+            next if game_counts[opponent] == 82
+
+            game_counts[team] += 1
+            game_counts[opponent] += 1
+
+            key = [team, opponent].sort
+
+            matchups[key] += 1
+          end
+        end
+
+        matchups
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # 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 = {}
+
+        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
+
+          four_tracker = league.teams.to_h { |team| [team, []] }
+
+          league.teams.each do |team|
+            opponents = league.cross_division_opponents_for(team).shuffle
+
+            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
+
+          good = true
+
+          # trip-wire: if one team isnt balanced then we are not balanced
+          four_tracker.each { |_k, v| good = false if v.length < 6 }
+
+          balanced = good
+
+          count += 1
+        end
+
+        four_tracker
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def schedule_season!(calendar:, league:)
+        matchups = matchup_plan(league)
+
+        matchups.each do |(team1, team2), count|
+          candidates = calendar.available_regular_matchup_dates(team1, team2)
+          dates      = candidates.sample(count)
+          games      = balanced_games(dates, team1, team2)
+
+          games.each { |game| calendar.add!(game) }
+        end
+      end
+
+      def balanced_games(dates, team1, team2)
+        dates.map.with_index(1) do |date, index|
+          home_opponent, away_opponent =
+            if index.even?
+              [Opponent.from(team1), Opponent.from(team2)]
+            else
+              [Opponent.from(team2), Opponent.from(team1)]
+            end
+
+          Regular.new(date:, home_opponent:, away_opponent:)
+        end
+      end
+
+      def schedule_exhibition!(calendar:, league:)
+        league.teams.each do |team|
+          current_games = calendar.exhibitions_for(opponent: team)
+          count         = current_games.length
+
+          next if count >= MIN_PRESEASON_GAMES_PER_TEAM
+
+          other_teams = (league.teams - [team]).shuffle
+
+          other_teams.each do |other_team|
+            break if count > MIN_PRESEASON_GAMES_PER_TEAM
+            next  if calendar.exhibitions_for(opponent: other_team).length >= MAX_PRESEASON_GAMES_PER_TEAM
+
+            candidates = calendar.available_exhibition_matchup_dates(team, other_team)
+
+            next if candidates.empty?
+
+            date = candidates.sample
+            game = random_exhibition_game(date, team, other_team)
+
+            calendar.add!(game)
+
+            count += 1
+          end
+        end
+      end
+
+      def random_exhibition_game(date, team1, team2)
+        home_opponent, away_opponent =
+          if rand(1..2) == 1
+            [Opponent.from(team1), Opponent.from(team2)]
+          else
+            [Opponent.from(team2), Opponent.from(team1)]
+          end
+
+        Exhibition.new(date:, home_opponent:, away_opponent:)
+      end
+    end
+  end
+end

data/lib/basketball/season/standings.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Represents a League with each team's win/loss details.
+    class Standings
+      class TeamAlreadyRegisteredError < StandardError; end
+      class TeamNotRegisteredError < StandardError; end
+
+      def initialize
+        @records_by_id = {}
+      end
+
+      def register!(team)
+        raise TeamAlreadyRegisteredError, "#{team} already registered!" if team?(team)
+
+        records_by_id[team.id] = Record.new(id: team.id)
+
+        self
+      end
+
+      def records
+        records_by_id.values
+      end
+
+      def record_for(team)
+        raise TeamNotRegisteredError, "#{team} not registered" unless team?(team)
+
+        records_by_id.fetch(team.id)
+      end
+
+      def accept!(result)
+        [
+          record_for(result.home_opponent),
+          record_for(result.away_opponent)
+        ].each do |record|
+          record.accept!(result)
+        end
+
+        self
+      end
+
+      def team?(team)
+        records_by_id.key?(team.id)
+      end
+
+      def to_s
+        records.sort.reverse.map.with_index(1) { |r, i| "##{i} #{r}" }.join("\n")
+      end
+
+      private
+
+      attr_reader :records_by_id
+    end
+  end
+end

data/lib/basketball/season.rb

@@ -12,5 +12,11 @@ require_relative 'season/opponent'
 require_relative 'season/exhibition'
 require_relative 'season/regular'
 
+# Standings
+require_relative 'season/detail'
+require_relative 'season/record'
+require_relative 'season/standings'
+
 # Specific
 require_relative 'season/coordinator'
+require_relative 'season/scheduler'

data/lib/basketball/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Basketball
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: basketball
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-01 00:00:00.000000000 Z
+date: 2023-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slop
@@ -31,8 +31,9 @@ description: "    This library is meant to serve as the domain for a basketball
 email:
 - mattruggio@icloud.com
 executables:
-- basketball-coordinator
-- basketball-room
+- basketball
+- basketball-season-coordinator
+- basketball-draft-room
 extensions: []
 extra_rdoc_files: []
 files:
@@ -48,8 +49,9 @@ files:
 - README.md
 - Rakefile
 - basketball.gemspec
-- exe/basketball-coordinator
-- exe/basketball-room
+- exe/basketball
+- exe/basketball-draft-room
+- exe/basketball-season-coordinator
 - lib/basketball.rb
 - lib/basketball/app.rb
 - lib/basketball/app/coordinator_cli.rb
@@ -71,6 +73,11 @@ files:
 - lib/basketball/draft/skip.rb
 - lib/basketball/entity.rb
 - lib/basketball/org.rb
+- lib/basketball/org/conference.rb
+- lib/basketball/org/division.rb
+- lib/basketball/org/has_divisions.rb
+- lib/basketball/org/has_players.rb
+- lib/basketball/org/has_teams.rb
 - lib/basketball/org/league.rb
 - lib/basketball/org/player.rb
 - lib/basketball/org/position.rb
@@ -79,12 +86,16 @@ files:
 - lib/basketball/season/arena.rb
 - lib/basketball/season/calendar.rb
 - lib/basketball/season/coordinator.rb
+- lib/basketball/season/detail.rb
 - lib/basketball/season/exhibition.rb
 - lib/basketball/season/game.rb
 - lib/basketball/season/matchup.rb
 - lib/basketball/season/opponent.rb
+- lib/basketball/season/record.rb
 - lib/basketball/season/regular.rb
 - lib/basketball/season/result.rb
+- lib/basketball/season/scheduler.rb
+- lib/basketball/season/standings.rb
 - lib/basketball/value_object.rb
 - lib/basketball/value_object_dsl.rb
 - lib/basketball/version.rb