basketball 0.0.7 → 0.0.9

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # 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,
+                  :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) }
+
+        freeze
+      end
+
+      def add!(game)
+        assert_in_bounds(game)
+        assert_free_date(game)
+
+        @games << game
+
+        self
+      end
+
+      def exhibitions_for(date: nil, opponent: nil)
+        games_for(date:, opponent:).select { |game| game.is_a?(Exhibition) }
+      end
+
+      def regulars_for(date: nil, opponent: nil)
+        games_for(date:, opponent:).select { |game| game.is_a?(Regular) }
+      end
+
+      def games_for(date: nil, opponent: nil)
+        games.select do |game|
+          (date.nil? || game.date == date) && (opponent.nil? || game.for?(opponent))
+        end
+      end
+
+      private
+
+      def assert_free_date(game)
+        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, opponent: game.away_opponent).any?
+
+        raise TeamAlreadyBookedError, "#{game.away_opponent} already playing on #{game.date}"
+      end
+
+      def assert_in_bounds(game)
+        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
+      end
+    end
+  end
+end

data/lib/basketball/season/coordinator.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Main iterator-based object that knows how to manage a calendar and simulate games per day.
+    class Coordinator
+      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,
+                  :id
+
+      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
+
+      def sim_rest!(&)
+        events = []
+
+        while not_done?
+          new_events = sim!(&)
+
+          events += new_events
+        end
+
+        events
+      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
+
+        return unless current_date > season_end_date
+
+        raise OutOfBoundsError, "current date #{current_date} should be on or after #{preseason_start_date}"
+      end
+
+      def sim!
+        return [] if done?
+
+        events = []
+        games  = games_for(date: current_date)
+
+        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)
+
+          play!(event)
+
+          yield(event) if block_given?
+
+          events << event
+        end
+
+        increment_current_date!
+
+        events
+      end
+
+      def total_days
+        (season_end_date - preseason_start_date).to_i
+      end
+
+      def days_left
+        (season_end_date - current_date).to_i
+      end
+
+      def total_exhibitions
+        exhibitions_for.length
+      end
+
+      def exhibitions_left
+        total_exhibitions - exhibition_result_events.length
+      end
+
+      def total_regulars
+        regulars_for.length
+      end
+
+      def regulars_left
+        total_regulars - regular_result_events.length
+      end
+
+      def current_games
+        games_for(date: current_date) - results.map(&:game)
+      end
+
+      def done?
+        current_date == season_end_date && games.length == results.length
+      end
+
+      def not_done?
+        !done?
+      end
+
+      def add!(game)
+        assert_today_or_in_future(game)
+        assert_known_teams(game)
+
+        calendar.add!(game)
+
+        self
+      end
+
+      def result_for(game)
+        results.find do |result|
+          result.game == game
+        end
+      end
+
+      private
+
+      attr_writer :id, :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
+
+      def regular_result_events
+        results.select { |e| e.game.is_a?(Regular) }
+      end
+
+      def increment_current_date!
+        return self if current_date >= season_end_date
+
+        @current_date = current_date + 1
+
+        self
+      end
+
+      def assert_today_or_in_future(game)
+        return unless game.date <= current_date
+
+        raise OutOfBoundsError, "#{game.date} is on or before the current date (#{current_date})"
+      end
+
+      def assert_known_teams(game)
+        raise UnknownTeamError, "unknown opponent: #{game.home_opponent}" if league.not_registered?(game.home_opponent)
+
+        return unless league.not_registered?(game.away_opponent)
+
+        raise UnknownTeamError, "unknown opponent: #{game.away_opponent}"
+      end
+
+      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
+end

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

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 module Basketball
-  module Scheduling
-    class PreseasonGame < Game
+  module Season
+    # An exhibition game.
+    class Exhibition < Game
       def to_s
         "#{super} (preseason)"
       end

data/lib/basketball/season/game.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Base class describing what all games have in common.
+    class Game < ValueObject
+      value_reader :date, :home_opponent, :away_opponent
+
+      def initialize(date:, home_opponent:, away_opponent:)
+        super()
+
+        raise ArgumentError, 'date is required'             unless date
+        raise ArgumentError, 'home_opponent is required'    unless home_opponent
+        raise ArgumentError, 'away_opponent is required'    unless away_opponent
+        raise ArgumentError, 'teams cannot play themselves' if home_opponent == away_opponent
+
+        @date          = date
+        @home_opponent = home_opponent
+        @away_opponent = away_opponent
+
+        freeze
+      end
+
+      def for?(team)
+        teams.include?(team)
+      end
+
+      def teams
+        [home_opponent, away_opponent]
+      end
+
+      def to_s
+        "#{date} - #{away_opponent} at #{home_opponent}"
+      end
+    end
+  end
+end

data/lib/basketball/season/matchup.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # A Matchup is a late materialization of a game.  While a game is a skeleton for a future
+    # matchup, it does not materialize until game time (rosters could change right up until game time).
+    class Matchup
+      class PlayersOnBothTeamsError < StandardError; end
+
+      attr_reader :game, :home_players, :away_players
+
+      def initialize(game:, home_players: [], away_players: [])
+        raise ArgumentError, 'game is required' unless game
+
+        @game         = game
+        @home_players = home_players.uniq
+        @away_players = away_players.uniq
+
+        if home_players.intersect?(away_players)
+          raise PlayersOnBothTeamsError, 'players cannot be on both home and away team'
+        end
+
+        freeze
+      end
+    end
+  end
+end

data/lib/basketball/season/opponent.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # 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
+      def initialize(id:)
+        super(id)
+
+        freeze
+      end
+    end
+  end
+end

data/lib/basketball/season/regular.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # A regular season game.
+    class Regular < Game
+    end
+  end
+end

data/lib/basketball/season/result.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Season
+    # Base class describing the end result of a game.  This should/could be sub-classed to include
+    # more sport-specific information.
+    class Result
+      extend Forwardable
+
+      class CannotTieError < StandardError; end
+
+      attr_reader :game, :home_score, :away_score
+
+      def_delegators :game, :date, :home_opponent, :away_opponent, :teams
+
+      def initialize(game:, home_score:, away_score:)
+        raise ArgumentError, 'game is required' unless game
+        raise CannotTieError, "#{game} ended in a tie" if home_score == away_score
+
+        @game       = game
+        @home_score = home_score.to_i
+        @away_score = away_score.to_i
+      end
+
+      def to_s
+        "#{game.date} - #{away_opponent} (#{away_score}) at #{home_opponent} (#{home_score})"
+      end
+
+      def ==(other)
+        game == other.game &&
+          home_score == other.home_score &&
+          away_score == other.away_score
+      end
+      alias eql? ==
+    end
+  end
+end

data/lib/basketball/season.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Common
+require_relative 'season/arena'
+require_relative 'season/calendar'
+require_relative 'season/result'
+require_relative 'season/game'
+require_relative 'season/matchup'
+require_relative 'season/opponent'
+
+# Game Subclasses
+require_relative 'season/exhibition'
+require_relative 'season/regular'
+
+# Specific
+require_relative 'season/coordinator'

data/lib/basketball/value_object.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module Basketball
+  # A Value Object is something that has no specific identity, instead its identity is the sum of
+  # the attribute values. Changing one will change the entire object's identity.
+  # Comes with a very simple DSL for specifying properties along with base equality and sorting methods.
   class ValueObject
     include Comparable
 
@@ -23,7 +26,7 @@ module Basketball
         @value_keys ||= []
       end
 
-      def attr_reader_value(*keys)
+      def value_reader(*keys)
         keys.each { |k| value_keys << k.to_sym }
 
         attr_reader(*keys)

data/lib/basketball/version.rb

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

data/lib/basketball.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
-require 'faker'
+require 'date'
 require 'fileutils'
 require 'forwardable'
 require 'json'
-require 'securerandom'
 require 'slop'
 
-# Top-level
+# Generic
 require_relative 'basketball/entity'
 require_relative 'basketball/value_object'
 
-# Submodules
-require_relative 'basketball/drafting'
-require_relative 'basketball/scheduling'
+# Dependent on Generic
+require_relative 'basketball/org'
+
+# Dependent on Org
+require_relative 'basketball/draft'
+require_relative 'basketball/season'
+
+# Dependent on All
+require_relative 'basketball/app'