basketball 0.0.8 → 0.0.10

data/lib/basketball/app/room_repository.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Basketball
+  module App
+    # Can load and save Room objects to JSON files.
+    class RoomRepository < DocumentRepository
+      PICK_EVENT = 'Pick'
+      SKIP_EVENT = 'Skip'
+
+      private_constant :PICK_EVENT, :SKIP_EVENT
+
+      private
+
+      def from_h(hash)
+        front_offices = deserialize_front_offices(hash[:front_offices])
+        players       = deserialize_players(hash[:players])
+        events        = deserialize_events(hash[:events], players:, front_offices:)
+
+        Draft::Room.new(
+          rounds: hash[:rounds],
+          front_offices:,
+          players:,
+          events:
+        )
+      end
+
+      def to_h(room)
+        {
+          rounds: room.rounds,
+          front_offices: room.front_offices.map { |fo| serialize_front_office(fo) },
+          players: room.players.map { |p| serialize_player(p) },
+          events: serialize_events(room.events)
+        }
+      end
+
+      # Serialization
+
+      def serialize_player(player)
+        {
+          id: player.id,
+          overall: player.overall,
+          position: player.position&.code
+        }
+      end
+
+      def serialize_front_office(front_office)
+        {
+          id: front_office.id,
+          risk_level: front_office.risk_level
+        }
+      end
+
+      def serialize_events(events)
+        events.map do |event|
+          case event
+          when Draft::Pick
+            serialize_pick(event)
+          when Draft::Skip
+            serialize_skip(event)
+          end
+        end
+      end
+
+      def serialize_pick(event)
+        {
+          type: PICK_EVENT,
+          front_office: event.front_office.id,
+          pick: event.pick,
+          round: event.round,
+          round_pick: event.round_pick,
+          auto: event.auto,
+          player: event.player.id
+        }
+      end
+
+      def serialize_skip(event)
+        {
+          type: SKIP_EVENT,
+          front_office: event.front_office.id,
+          pick: event.pick,
+          round: event.round,
+          round_pick: event.round_pick
+        }
+      end
+
+      # Deserialization
+
+      def deserialize_player(player_hash)
+        Org::Player.new(
+          id: player_hash[:id],
+          overall: player_hash[:overall],
+          position: Org::Position.new(player_hash[:position])
+        )
+      end
+
+      def deserialize_front_office(hash)
+        Draft::FrontOffice.new(
+          id: hash[:id],
+          risk_level: hash[:risk_level]
+        )
+      end
+
+      def deserialize_front_offices(hashes)
+        (hashes || []).map { |fo| deserialize_front_office(fo) }
+      end
+
+      def deserialize_players(hashes)
+        (hashes || []).map { |hash| deserialize_player(hash) }
+      end
+
+      def deserialize_pick(hash, players:, front_office:)
+        player_id = hash[:player]
+        player    = players.find { |p| p.id == player_id }
+
+        Draft::Pick.new(
+          front_office:,
+          pick: hash[:pick],
+          round: hash[:round],
+          round_pick: hash[:round_pick],
+          player:,
+          auto: hash[:auto]
+        )
+      end
+
+      def deserialize_skip(hash, front_office:)
+        Draft::Skip.new(
+          front_office:,
+          pick: hash[:pick],
+          round: hash[:round],
+          round_pick: hash[:round_pick]
+        )
+      end
+
+      def deserialize_events(hashes, players:, front_offices:)
+        (hashes || []).map do |hash|
+          front_office_id = hash[:front_office]
+          front_office    = front_offices.find { |fo| fo.id == front_office_id }
+
+          case hash[:type]
+          when PICK_EVENT
+            deserialize_pick(hash, players:, front_office:)
+          when SKIP_EVENT
+            deserialize_skip(hash, front_office:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/basketball/app.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Stores
+require_relative 'app/file_store'
+require_relative 'app/in_memory_store'
+
+# Serialization
+require_relative 'app/league_serializable'
+
+# Repositories / Common
+require_relative 'app/document_repository'
+
+# Repositories / Implementations
+require_relative 'app/coordinator_repository'
+require_relative 'app/league_repository'
+require_relative 'app/room_repository'
+
+# Controllers
+require_relative 'app/coordinator_cli'
+require_relative 'app/room_cli'

data/lib/basketball/draft/assessment.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Basketball
+  module Draft
+    # An assessment is given to a front office when it needs the front office to make a pick.
+    # This is essentially just a data-transfer object to get information to a front office to make a pick.
+    class Assessment
+      attr_reader :drafted_players,
+                  :pick,
+                  :round_pick,
+                  :round,
+                  :undrafted_players
+
+      def initialize(
+        drafted_players:,
+        pick:,
+        round_pick:,
+        round:,
+        undrafted_players:
+      )
+        @drafted_players   = drafted_players
+        @pick              = pick
+        @round             = round
+        @round_pick        = round_pick
+        @undrafted_players = undrafted_players
+
+        freeze
+      end
+    end
+  end
+end

data/lib/basketball/draft/event.rb

@@ -2,8 +2,9 @@
 
 module Basketball
   module Draft
+    # Describes what all Room events have to have to be considered an "event".
     class Event < ValueObject
-      attr_reader_value :pick, :round, :round_pick, :front_office
+      value_reader :pick, :round, :round_pick, :front_office
 
       def initialize(front_office:, pick:, round:, round_pick:)
         super()
@@ -17,7 +18,7 @@ module Basketball
       end
 
       def to_s
-        "##{pick} overall (R#{round}:P#{round_pick}) by #{front_office}"
+        "[##{pick} R:#{round} P:#{round_pick}] #{front_office}"
       end
     end
   end

data/lib/basketball/draft/front_office.rb

@@ -2,22 +2,34 @@
 
 module Basketball
   module Draft
+    # A team will send their front office to a draft room to make draft selections.
     class FrontOffice < Entity
-      MAX_DEPTH     = 3
-      MAX_FUZZ      = 2
+      # The higher the number the more the front office will make more top-player-based decisions
+      # over position-based decisions.
+      DEFAULT_MAX_STAR_LEVEL = 5
+
+      # Riskier front offices may choose to not draft the top player.  The higher the number the more
+      # they will not select the top player available.
+      DEFAULT_MAX_RISK_LEVEL = 5
+
       MAX_POSITIONS = 12
 
-      private_constant :MAX_DEPTH, :MAX_FUZZ, :MAX_POSITIONS
+      private_constant :DEFAULT_MAX_STAR_LEVEL, :DEFAULT_MAX_RISK_LEVEL, :MAX_POSITIONS
 
-      attr_reader :prioritized_positions, :fuzz, :depth, :name
+      attr_reader :prioritized_positions, :risk_level, :star_level, :scout
 
-      def initialize(id:, name: '', prioritized_positions: [], fuzz: rand(0..MAX_FUZZ), depth: rand(0..MAX_DEPTH))
+      def initialize(
+        id:,
+        prioritized_positions: [],
+        risk_level: rand(0..DEFAULT_MAX_RISK_LEVEL),
+        star_level: rand(0..DEFAULT_MAX_STAR_LEVEL)
+      )
         super(id)
 
-        @name                  = name
-        @fuzz                  = fuzz.to_i
-        @depth                 = depth.to_i
+        @risk_level            = risk_level.to_i
+        @star_level            = star_level.to_i
         @prioritized_positions = prioritized_positions
+        @scout                 = Scout.new
 
         # fill in the rest of the queue here
         need_count = MAX_POSITIONS - @prioritized_positions.length
@@ -27,51 +39,46 @@ module Basketball
         freeze
       end
 
-      def pick(undrafted_player_search:, drafted_players:, round:)
+      def pick(assessment)
         players = []
+        players = adaptive_search(assessment) if star_level >= assessment.round
+        players = balanced_search(assessment) if players.empty?
+        players = top_players(assessment)     if players.empty?
 
-        players = adaptive_search(undrafted_player_search:, drafted_players:) if depth >= round
-        players = balanced_search(undrafted_player_search:, drafted_players:) if players.empty?
-        players = top_players(undrafted_player_search:)                       if players.empty?
-
-        players[0..fuzz].sample
-      end
-
-      def to_s
-        "[#{super}] #{name}"
+        players[0..risk_level].sample
       end
 
       private
 
-      def adaptive_search(undrafted_player_search:, drafted_players:)
-        drafted_positions = drafted_players.map(&:position)
+      def adaptive_search(assessment)
+        drafted_positions = assessment.drafted_players.map(&:position)
 
-        undrafted_player_search.query(exclude_positions: drafted_positions)
+        scout.top_for(players: assessment.undrafted_players, exclude_positions: drafted_positions)
       end
 
-      def balanced_search(undrafted_player_search:, drafted_players:)
+      def balanced_search(assessment)
         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 = undrafted_player_search.query(position:)
+        available_prioritized_positions(assessment.drafted_players).each do |position|
+          players = scout.top_for(players: assessment.undrafted_players, position:)
 
           break if players.any?
         end
 
-        players = players.any? ? players : undrafted_player_search.query
+        players = players.any? ? players : scout.top_for
       end
 
       def all_random_positions
-        Position::ALL_VALUES.to_a.shuffle.map { |v| Position.new(v) }
+        Org::Position::ALL_VALUES.to_a.shuffle.map { |v| Org::Position.new(v) }
       end
 
       def random_positions_queue
-        all_random_positions + all_random_positions + [Position.random] + [Position.random]
+        all_random_positions + all_random_positions + [Org::Position.random] + [Org::Position.random]
       end
 
-      def available_prioritized_positions(drafted_players:)
+      def available_prioritized_positions(drafted_players)
         drafted_positions = drafted_players.map(&:position)
         queue             = prioritized_positions.dup
 

data/lib/basketball/draft/{pick_event.rb → pick.rb}

@@ -1,25 +1,32 @@
 # frozen_string_literal: true
 
-require_relative 'event'
-
 module Basketball
   module Draft
-    class PickEvent < Event
-      attr_reader_value :player
+    # Room event where a player is selected.
+    class Pick < Event
+      value_reader :player, :auto
 
-      def initialize(front_office:, player:, pick:, round:, round_pick:)
+      def initialize(front_office:, player:, pick:, round:, round_pick:, auto: false)
         super(front_office:, pick:, round:, round_pick:)
 
         raise ArgumentError, 'player required' unless player
 
         @player = player
+        @auto   = auto
 
         freeze
       end
 
       def to_s
-        "#{player} picked #{super}"
+        "#{super} #{auto ? 'auto-' : ''}picked #{player}"
+      end
+
+      def ==(other)
+        super &&
+          player == other.player &&
+          auto == other.auto
       end
+      alias eql? ==
     end
   end
 end