basketball 0.0.1

data/lib/basketball/drafting/engine.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class Engine
+      class AlreadyPickedError < StandardError; end
+      class DupeEventError < StandardError; end
+      class EventOutOfOrderError < StandardError; end
+      class UnknownPlayerError < StandardError; end
+      class UnknownTeamError < StandardError; end
+      class EndOfDraftError < StandardError; end
+
+      DEFAULT_ROUNDS = 12
+
+      private_constant :DEFAULT_ROUNDS
+
+      attr_reader :events, :rounds
+
+      def initialize(players: [], teams: [], events: [], rounds: DEFAULT_ROUNDS)
+        @players_by_id = players.to_h { |p| [p.id, p] }
+        @teams_by_id   = teams.to_h { |t| [t.id, t] }
+        @events        = []
+        @rounds        = rounds.to_i
+
+        # Each one will be validated for correctness.
+        events.each { |e| play!(e) }
+
+        freeze
+      end
+
+      def rosters
+        events_by_team = teams.to_h { |t| [t, []] }
+
+        events.each do |event|
+          events_by_team.fetch(event.team) << event
+        end
+
+        events_by_team.map do |team, events|
+          Roster.new(team:, events:)
+        end
+      end
+
+      def to_s
+        events.join("\n")
+      end
+
+      def teams
+        teams_by_id.values
+      end
+
+      def players
+        players_by_id.values
+      end
+
+      def total_picks
+        rounds * teams.length
+      end
+
+      def current_round
+        return if done?
+
+        (current_pick / teams.length.to_f).ceil
+      end
+
+      def current_round_pick
+        return if done?
+
+        mod = current_pick % teams.length
+
+        mod.positive? ? mod : teams.length
+      end
+
+      def current_team
+        return if done?
+
+        teams[current_round_pick - 1]
+      end
+
+      def current_pick
+        return if done?
+
+        internal_current_pick
+      end
+
+      def remaining_picks
+        total_picks - internal_current_pick + 1
+      end
+
+      def done?
+        internal_current_pick > total_picks
+      end
+
+      def not_done?
+        !done?
+      end
+
+      def sim!(times = nil)
+        counter = 0
+
+        until done? || (times && counter >= times)
+          team = current_team
+
+          player = team.pick(
+            undrafted_players:,
+            drafted_players: drafted_players(team),
+            round: current_round
+          )
+
+          event = SimEvent.new(
+            id: SecureRandom.uuid,
+            team:,
+            player:,
+            pick: current_pick,
+            round: current_round,
+            round_pick: current_round_pick
+          )
+
+          play!(event)
+
+          yield(event) if block_given?
+
+          counter += 1
+        end
+
+        self
+      end
+
+      def pick!(player)
+        return nil if done?
+
+        event = PickEvent.new(
+          id: SecureRandom.uuid,
+          team: current_team,
+          player:,
+          pick: current_pick,
+          round: current_round,
+          round_pick: current_round_pick
+        )
+
+        play!(event)
+      end
+
+      def undrafted_players
+        players - drafted_players
+      end
+
+      private
+
+      attr_reader :players_by_id, :teams_by_id
+
+      def internal_current_pick
+        events.length + 1
+      end
+
+      def drafted_players(team = nil)
+        events.each_with_object([]) do |e, memo|
+          next unless team.nil? || e.team == team
+
+          memo << e.player
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def play!(event)
+        raise AlreadyPickedError, "#{player} was already picked" if drafted_players.include?(event.player)
+        raise DupeEventError,     "#{event} is a dupe"                if events.include?(event)
+        raise EventOutOfOrder,    "#{event} team cant pick right now" if event.team != current_team
+        raise EventOutOfOrder,    "#{event} has wrong pick"           if event.pick != current_pick
+        raise EventOutOfOrder,    "#{event} has wrong round"          if event.round != current_round
+        raise EventOutOfOrder,    "#{event} has wrong round_pick" if event.round_pick != current_round_pick
+        raise UnknownTeamError,   "#{team} doesnt exist"                   unless teams.include?(event.team)
+        raise UnknownPlayerError, "#{player} doesnt exist"                 unless players.include?(event.player)
+        raise EndOfDraftError,    "#{total_picks} pick limit reached"      if events.length > total_picks + 1
+
+        events << event
+
+        event
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/basketball/drafting/engine_serializer.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class EngineSerializer
+      EVENT_CLASSES = {
+        'PickEvent' => PickEvent,
+        'SimEvent' => SimEvent
+      }.freeze
+
+      private_constant :EVENT_CLASSES
+
+      def deserialize(string)
+        json        = JSON.parse(string, symbolize_names: true)
+        teams       = deserialize_teams(json)
+        players     = deserialize_players(json)
+        events = deserialize_events(json, players, teams)
+
+        engine_opts = {
+          players:,
+          teams:,
+          events:
+        }
+
+        engine_opts[:rounds] = json.dig(:engine, :rounds) if json.dig(:engine, :rounds)
+
+        Engine.new(**engine_opts)
+      end
+
+      def serialize(engine)
+        {
+          info: serialize_info(engine),
+          engine: serialize_engine(engine),
+          rosters: serialize_rosters(engine)
+        }.to_json
+      end
+
+      private
+
+      def serialize_engine(engine)
+        {
+          rounds: engine.rounds,
+          teams: serialize_teams(engine),
+          players: serialize_players(engine),
+          events: serialize_events(engine.events)
+        }
+      end
+
+      def serialize_info(engine)
+        {
+          total_picks: engine.total_picks,
+          current_round: engine.current_round,
+          current_round_pick: engine.current_round_pick,
+          current_team: engine.current_team&.id,
+          current_pick: engine.current_pick,
+          remaining_picks: engine.remaining_picks,
+          done: engine.done?,
+          undrafted_players: engine.undrafted_players.map(&:id)
+        }
+      end
+
+      def serialize_rosters(engine)
+        engine.rosters.to_h do |roster|
+          [
+            roster.id,
+            {
+              events: roster.events.map(&:id),
+              players: roster.events.map { |event| event.player.id }
+            }
+          ]
+        end
+      end
+
+      def serialize_teams(engine)
+        engine.teams.to_h do |team|
+          [
+            team.id,
+            {
+              name: team.name,
+              front_office: {
+                fuzz: team.front_office.fuzz,
+                depth: team.front_office.depth,
+                prioritized_positions: team.front_office.prioritized_positions
+              }
+            }
+          ]
+        end
+      end
+
+      def serialize_players(engine)
+        engine.players.to_h do |player|
+          [
+            player.id,
+            {
+              first_name: player.first_name,
+              last_name: player.last_name,
+              overall: player.overall,
+              position: player.position.value
+            }
+          ]
+        end
+      end
+
+      def serialize_events(events)
+        events.map do |event|
+          {
+            type: event.class.name.split('::').last,
+            id: event.id,
+            player: event.player.id,
+            team: event.team.id,
+            pick: event.pick,
+            round: event.round,
+            round_pick: event.round_pick
+          }
+        end
+      end
+
+      def deserialize_teams(json)
+        (json.dig(:engine, :teams) || []).map do |id, team_hash|
+          team_opts = {
+            id:,
+            name: team_hash[:name]
+          }
+
+          if team_hash.key?(:front_office)
+            front_office_hash = team_hash[:front_office] || {}
+
+            prioritized_positions = (front_office_hash[:prioritized_positions] || []).map do |v|
+              Position.new(v)
+            end
+
+            front_office_opts = {
+              prioritized_positions:,
+              fuzz: front_office_hash[:fuzz],
+              depth: front_office_hash[:depth]
+            }
+
+            team_opts[:front_office] = FrontOffice.new(**front_office_opts)
+          end
+
+          Team.new(**team_opts)
+        end
+      end
+
+      def deserialize_players(json)
+        (json.dig(:engine, :players) || []).map do |id, player_hash|
+          player_opts = player_hash.merge(
+            id:,
+            position: Position.new(player_hash[:position])
+          )
+
+          Player.new(**player_opts)
+        end
+      end
+
+      def deserialize_events(json, players, teams)
+        (json.dig(:engine, :events) || []).map do |event_hash|
+          event_opts = event_hash.slice(:id, :pick, :round, :round_pick).merge(
+            player: players.find { |p| p.id == event_hash[:player] },
+            team: teams.find { |t| t.id == event_hash[:team] }
+          )
+
+          class_constant = EVENT_CLASSES.fetch(event_hash[:type])
+
+          class_constant.new(**event_opts)
+        end
+      end
+    end
+  end
+end

data/lib/basketball/drafting/entity.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class Entity
+      extend Forwardable
+      include Comparable
+
+      attr_reader :id
+
+      def_delegators :id, :to_s
+
+      def initialize(id)
+        raise ArgumentError, 'id is required' if id.to_s.empty?
+
+        @id = id.to_s.upcase
+      end
+
+      def <=>(other)
+        id <=> other.id
+      end
+
+      def ==(other)
+        id == other.id
+      end
+      alias eql? ==
+
+      def hash
+        id.hash
+      end
+    end
+  end
+end

data/lib/basketball/drafting/event.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class Event < Entity
+      attr_reader :pick, :round, :round_pick, :team
+
+      def initialize(id:, team:, pick:, round:, round_pick:)
+        super(id)
+
+        raise ArgumentError, 'team required' unless team
+
+        @team       = team
+        @pick       = pick.to_i
+        @round      = round.to_i
+        @round_pick = round_pick.to_i
+      end
+
+      def to_s
+        "##{pick} overall (R#{round}:P#{round_pick}) by #{team}"
+      end
+    end
+  end
+end

data/lib/basketball/drafting/front_office.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class FrontOffice
+      MAX_DEPTH     = 3
+      MAX_FUZZ      = 2
+      MAX_POSITIONS = 12
+
+      private_constant :MAX_DEPTH, :MAX_FUZZ, :MAX_POSITIONS
+
+      attr_reader :prioritized_positions, :fuzz, :depth
+
+      def initialize(prioritized_positions: [], fuzz: rand(0..MAX_FUZZ), depth: rand(0..MAX_DEPTH))
+        @fuzz                  = fuzz.to_i
+        @depth                 = depth.to_i
+        @prioritized_positions = prioritized_positions
+
+        # fill in the rest of the queue here
+        need_count = MAX_POSITIONS - @prioritized_positions.length
+
+        @prioritized_positions += random_positions_queue[0...need_count]
+
+        freeze
+      end
+
+      def to_s
+        "#{prioritized_positions.map(&:to_s).join(',')} (F:#{fuzz} D:#{depth})"
+      end
+
+      def pick(undrafted_players:, drafted_players:, round:)
+        players = []
+
+        players = adaptive_search(undrafted_players:, drafted_players:) if depth >= round
+        players = balanced_search(undrafted_players:, drafted_players:) if players.empty?
+        players = top_players(undrafted_players:)                       if players.empty?
+
+        players[0..fuzz].sample
+      end
+
+      private
+
+      def adaptive_search(undrafted_players:, drafted_players:)
+        search = PlayerSearch.new(undrafted_players)
+
+        drafted_positions = drafted_players.map(&:position)
+
+        search.query(exclude_positions: drafted_positions)
+      end
+
+      def balanced_search(undrafted_players:, drafted_players:)
+        search = PlayerSearch.new(undrafted_players)
+
+        players = []
+
+        # Try to find best pick for exact desired position.
+        # If you cant find one, then move to the next desired position until the end of the queue
+        available_prioritized_positions(drafted_players:).each do |position|
+          players = search.query(position:)
+
+          break if players.any?
+        end
+
+        players = players.any? ? players : search.query
+      end
+
+      def all_random_positions
+        Position::ALL_VALUES.to_a.shuffle.map { |v| Position.new(v) }
+      end
+
+      def random_positions_queue
+        all_random_positions + all_random_positions + [Position.random] + [Position.random]
+      end
+
+      def available_prioritized_positions(drafted_players:)
+        drafted_positions = drafted_players.map(&:position)
+        queue             = prioritized_positions.dup
+
+        drafted_positions.each do |drafted_position|
+          index = queue.index(drafted_position)
+
+          next unless index
+
+          queue.delete_at(index)
+
+          queue << drafted_position
+        end
+
+        queue
+      end
+    end
+  end
+end

data/lib/basketball/drafting/pick_event.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class PickEvent < Event
+      attr_reader :player
+
+      def initialize(id:, team:, player:, pick:, round:, round_pick:)
+        super(id:, team:, pick:, round:, round_pick:)
+
+        raise ArgumentError, 'player required' unless player
+
+        @player = player
+
+        freeze
+      end
+
+      def to_s
+        "#{player} picked #{super}"
+      end
+    end
+  end
+end

data/lib/basketball/drafting/player.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class Player < Entity
+      STAR_THRESHOLD         = 75
+      OVERALL_STAR_INDICATOR = '⭐'
+
+      private_constant :STAR_THRESHOLD, :OVERALL_STAR_INDICATOR
+
+      attr_reader :first_name, :last_name, :position, :overall
+
+      def initialize(id:, position:, first_name: '', last_name: '', overall: 0)
+        super(id)
+
+        raise ArgumentError, 'position is required' unless position
+
+        @first_name = first_name.to_s
+        @last_name  = last_name.to_s
+        @position   = position
+        @overall    = overall.to_i
+
+        freeze
+      end
+
+      def full_name
+        "#{first_name.strip} #{last_name.strip}".strip
+      end
+
+      def to_s
+        "[#{super}] #{full_name} (#{position}) #{overall} #{star_indicators.join(', ')}".strip
+      end
+
+      private
+
+      def star_indicators
+        [].tap do |indicators|
+          indicators << OVERALL_STAR_INDICATOR if overall >= STAR_THRESHOLD
+        end
+      end
+    end
+  end
+end

data/lib/basketball/drafting/player_search.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class PlayerSearch
+      attr_reader :players
+
+      def initialize(players = [])
+        @players = players
+      end
+
+      def query(position: nil, exclude_positions: [])
+        filtered_players = players
+
+        if position
+          filtered_players = filtered_players.select do |player|
+            player.position == position
+          end
+        end
+
+        if exclude_positions.any?
+          filtered_players = filtered_players.reject do |player|
+            exclude_positions.include?(player.position)
+          end
+        end
+
+        filtered_players.sort_by(&:overall).reverse
+      end
+    end
+  end
+end

data/lib/basketball/drafting/position.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class Position
+      extend Forwardable
+
+      class << self
+        def random
+          new(ALL_VALUES.to_a.sample)
+        end
+      end
+
+      class InvalidPositionError < StandardError; end
+
+      BACK_COURT_VALUES  = %w[PG SG SF].to_set.freeze
+      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
+
+      def_delegators :value, :to_s
+
+      def initialize(value)
+        @value = value.to_s.upcase
+
+        raise InvalidPositionError, "Unknown position value: #{@value}" unless ALL_VALUES.include?(@value)
+
+        freeze
+      end
+
+      def ==(other)
+        value == other.value
+      end
+      alias eql? ==
+
+      def hash
+        value.hash
+      end
+    end
+  end
+end

data/lib/basketball/drafting/roster.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class Roster
+      extend Forwardable
+
+      class WrongTeamEventError < StandardError; end
+
+      attr_reader :team, :events
+
+      def_delegators :team, :id
+
+      def initialize(team:, events: [])
+        raise ArgumentError, 'team is required' unless team
+
+        other_teams_pick_event_ids = events.reject { |e| e.team == team }.map(&:id)
+
+        if other_teams_pick_event_ids.any?
+          raise WrongTeamEventError,
+                "Event(s): #{other_teams_pick_event_ids.join(',')} has wrong team"
+        end
+
+        @team   = team
+        @events = events
+      end
+
+      def players
+        events.map(&:player)
+      end
+
+      def to_s
+        ([team.to_s] + players.map(&:to_s)).join("\n")
+      end
+    end
+  end
+end

data/lib/basketball/drafting/sim_event.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Drafting
+    class SimEvent < Event
+      attr_reader :player
+
+      def initialize(id:, team:, player:, pick:, round:, round_pick:)
+        super(id:, team:, pick:, round:, round_pick:)
+
+        raise ArgumentError, 'player required' unless player
+
+        @player = player
+
+        freeze
+      end
+
+      def to_s
+        "#{player} auto-picked #{super}"
+      end
+    end
+  end
+end