acpc_poker_types 0.0.10 → 1.0.0

data/lib/acpc_poker_types/acpc_dealer_data/log_file.rb

@@ -0,0 +1,5 @@
+# Wrapper class to enable mocking log files in tests
+module AcpcPokerTypes::AcpcDealerData
+  class  LogFile < File
+  end
+end

data/lib/acpc_poker_types/acpc_dealer_data/match_definition.rb

@@ -0,0 +1,54 @@
+
+require 'set'
+
+require 'acpc_poker_types/game_definition'
+
+require 'dmorrill10-utils/class'
+
+module AcpcPokerTypes::AcpcDealerData
+  class MatchDefinition
+
+    exceptions :unable_to_parse, :incorrect_number_of_player_names
+
+    attr_reader :name, :game_def, :number_of_hands, :random_seed, :player_names
+
+    def self.parse(acpc_log_string, player_names, game_def_directory)
+      if acpc_log_string.strip.match(
+        '^\s*#\s*name/game/hands/seed\s+(\S+)\s+(\S+)\s+(\d+)\s+(\d+)\s*$'
+      )
+        name = $1
+        game_def = AcpcPokerTypes::GameDefinition.parse_file(
+          File.join(game_def_directory, File.basename($2))
+        )
+        number_of_hands = $3
+        random_seed = $4
+
+        new(name, game_def, number_of_hands, random_seed, player_names)
+      else
+        nil
+      end
+    end
+
+    def initialize(name, game_def, number_of_hands, random_seed, player_names)
+      if game_def.number_of_players != player_names.length
+        raise IncorrectNumberOfPlayerNames, "number of players: #{game_def.number_of_players}, number of names: #{player_names.length}"
+      end
+
+      @name = name.to_s
+      @game_def = game_def
+      @number_of_hands = number_of_hands.to_i
+      @random_seed = random_seed.to_i
+      @player_names = player_names
+    end
+
+    def ==(other)
+      (
+        @name == other.name &&
+        Set.new(@game_def.to_a) == Set.new(other.game_def.to_a) &&
+        @number_of_hands == other.number_of_hands &&
+        @random_seed == other.random_seed &&
+        @player_names == other.player_names
+      )
+    end
+  end
+end

data/lib/acpc_poker_types/acpc_dealer_data/poker_match_data.rb

@@ -0,0 +1,393 @@
+
+require 'acpc_poker_types/player'
+
+require 'celluloid/autostart'
+
+require 'dmorrill10-utils/class'
+
+require 'acpc_poker_types/acpc_dealer_data/action_messages'
+require 'acpc_poker_types/acpc_dealer_data/hand_data'
+require 'acpc_poker_types/acpc_dealer_data/hand_results'
+require 'acpc_poker_types/acpc_dealer_data/match_definition'
+
+module AcpcPokerTypes::AcpcDealerData
+  class PokerMatchData
+
+    exceptions :match_definitions_do_not_match, :final_scores_do_not_match, :player_data_inconsistent
+
+    attr_accessor(
+      # @returns [Array<Numeric>] Chip distribution at the end of the match
+      :chip_distribution,
+      # @returns [MatchDefinition] Game definition and match parameters
+      :match_def,
+      # @returns [Integer] Zero-index turn number within the hand
+      :hand_number,
+      # @returns [ AcpcPokerTypes::AcpcDealerData::HandData] Data from each hand
+      :data,
+      # @returns [Array<AcpcPokerTypes::>] AcpcPokerTypes:: information
+      :players,
+      # @returns [Integer] Seat of the active player
+      :seat
+    )
+
+    # @returns [ AcpcPokerTypes::AcpcDealerData::PokerMatchData]
+    def self.parse_files(
+      action_messages_file,
+      result_messages_file,
+      player_names,
+      dealer_directory,
+      num_hands=nil
+    )
+      parsed_action_messages = Celluloid::Future.new do
+         AcpcPokerTypes::AcpcDealerData::ActionMessages.parse_file(
+          action_messages_file,
+          player_names,
+          dealer_directory,
+          num_hands
+        )
+      end
+      parsed_hand_results = Celluloid::Future.new do
+         AcpcPokerTypes::AcpcDealerData::HandResults.parse_file(
+          result_messages_file,
+          player_names,
+          dealer_directory,
+          num_hands
+        )
+      end
+
+      new(
+        parsed_action_messages.value,
+        parsed_hand_results.value,
+        player_names,
+        dealer_directory
+      )
+    end
+
+    # @returns [ AcpcPokerTypes::AcpcDealerData::PokerMatchData]
+    def self.parse(
+      action_messages,
+      result_messages,
+      player_names,
+      dealer_directory,
+      num_hands=nil
+    )
+      parsed_action_messages = Celluloid::Future.new do
+         AcpcPokerTypes::AcpcDealerData::ActionMessages.parse(
+          action_messages,
+          player_names,
+          dealer_directory,
+          num_hands
+        )
+      end
+      parsed_hand_results = Celluloid::Future.new do
+         AcpcPokerTypes::AcpcDealerData::HandResults.parse(
+          result_messages,
+          player_names,
+          dealer_directory,
+          num_hands
+        )
+      end
+
+      new(
+        parsed_action_messages.value,
+        parsed_hand_results.value,
+        player_names,
+        dealer_directory
+      )
+    end
+
+    def initialize(
+      parsed_action_messages,
+      parsed_hand_results,
+      player_names,
+      dealer_directory
+    )
+      if (
+        parsed_action_messages.match_def.nil? ||
+        parsed_hand_results.match_def.nil? ||
+        parsed_action_messages.match_def != parsed_hand_results.match_def
+      )
+        raise MatchDefinitionsDoNotMatch
+      end
+
+      if (
+        parsed_action_messages.final_score != parsed_hand_results.final_score
+      )
+        raise FinalScoresDoNotMatch
+      end
+
+      @match_def = parsed_hand_results.match_def
+
+      if parsed_hand_results.final_score
+        set_chip_distribution! parsed_hand_results.final_score
+      end
+
+      set_data! parsed_action_messages, parsed_hand_results
+
+      # Zero-indexed seat
+      @seat = 0
+
+      initialize_players!
+    end
+
+    def for_every_seat!
+      match_def.game_def.number_of_players.times do |seat|
+        @seat = seat
+
+        initialize_players!
+
+        yield seat
+      end
+
+      self
+    end
+
+    def player(seat=@seat) @players[seat] end
+
+    def for_every_hand!
+      initialize_players!
+
+      @data.each_index do |i|
+        @hand_number = i
+
+        @players.each_with_index do |player, seat|
+          player.start_new_hand!(
+            @match_def.game_def.blinds[current_hand.data.first.state_messages[seat].position_relative_to_dealer],
+            @match_def.game_def.chip_stacks[current_hand.data.first.state_messages[seat].position_relative_to_dealer],
+            current_hand.data.first.state_messages[seat].users_hole_cards
+          )
+        end
+
+        yield @hand_number
+      end
+
+      if @chip_distribution && @chip_distribution != @players.map { |p| p.chip_balance }
+        raise AcpcPokerTypes::DataInconsistent, "chip distribution: #{@chip_distribution}, player balances: #{@players.map { |p| p.chip_balance }}"
+      end
+
+      @hand_number = nil
+      self
+    end
+
+    def for_every_turn!
+      current_hand.for_every_turn!(@seat) do |turn_number|
+        @players.each_with_index do |player, seat|
+          last_match_state = current_hand.last_match_state(seat)
+          match_state = current_hand.current_match_state(seat)
+
+          if current_hand.last_action && player.seat == current_hand.last_action.seat
+
+            player.take_action!(current_hand.last_action.action)
+          end
+
+          if (
+            player.active? &&
+            !match_state.first_state_of_first_round? &&
+            match_state.round > last_match_state.round
+          )
+            player.start_new_round!
+          end
+
+          if current_hand.final_turn?
+            player.take_winnings!(
+              current_hand.chip_distribution[seat] + @match_def.game_def.blinds[current_hand.current_match_state(seat).position_relative_to_dealer]
+            )
+          end
+        end
+
+        yield turn_number
+      end
+
+      self
+    end
+
+    def match_has_another_round?(current_round, turn_index, turns_taken)
+      new_round?(current_round, turn_index) ||
+      players_all_in?(current_round, turn_index, turns_taken)
+    end
+
+    def hand_started?
+      @hand_number &&
+      current_hand.turn_number &&
+      current_hand.turn_number > 0
+    end
+
+    def player_acting_sequence
+      sequence = [[]]
+
+      return sequence unless hand_started?
+
+      turns_taken = current_hand.data[0..current_hand.turn_number-1]
+      turns_taken.each_with_index do |turn, turn_index|
+        next unless turn.action_message
+
+        sequence[turn.action_message.state.round] << turn.action_message.seat
+        if match_has_another_round?(sequence.length - 1, turn_index, turns_taken)
+          sequence << []
+        end
+      end
+
+      sequence
+    end
+
+    def current_hand
+      if @hand_number then @data[@hand_number] else nil end
+    end
+
+    def final_hand?
+      if @hand_number then @hand_number >= @data.length - 1 else nil end
+    end
+
+    # @return [Array<ChipStack>] AcpcPokerTypes:: stacks.
+    def chip_stacks
+      @players.map { |player| player.chip_stack }
+    end
+
+    # return [Array<Integer>] Each player's current chip balance.
+    def chip_balances
+      @players.map { |player| player.chip_balance }
+    end
+
+    # return [Array<Array<Integer>>] Each player's current chip contribution organized by round.
+    def chip_contributions
+      @players.map { |player| player.chip_contributions }
+    end
+
+    def opponents
+      @players.reject { |other_player| player == other_player }
+    end
+    def active_players
+      @players.select { |player_to_collect| player_to_collect.active? }
+    end
+    def non_folded_players
+      @players.reject { |player_to_reject| player_to_reject.folded? }
+    end
+    def opponents_cards_visible?
+      return false unless current_hand
+
+      current_hand.current_match_state.list_of_hole_card_hands.reject_empty_elements.length > 1
+    end
+    def player_with_dealer_button
+      return nil unless current_hand
+
+      @players.find do |plr|
+        current_hand.current_match_state(plr.seat).position_relative_to_dealer == @players.length - 1
+      end
+    end
+    # @return [Hash<AcpcPokerTypes::, #to_i] Relation from player to the blind that player paid.
+    def player_blind_relation
+      return nil unless current_hand
+
+      @players.inject({}) do |relation, plr|
+        relation[plr] = @match_def.game_def.blinds[current_hand.current_match_state(plr.seat).position_relative_to_dealer]
+        relation
+      end
+    end
+
+    # @todo Untested
+    # @return [String] player acting sequence as a string.
+    def player_acting_sequence_string
+      (player_acting_sequence.map { |per_round| per_round.join('') }).join('/')
+    end
+    def users_turn_to_act?
+      return false unless current_hand && current_hand.next_action
+      current_hand.next_action.seat == @seat
+    end
+    def betting_sequence
+      sequence = [[]]
+
+      if (
+        @hand_number.nil? ||
+        current_hand.turn_number.nil? ||
+        current_hand.turn_number < 1
+      )
+        return sequence
+      end
+
+      turns_taken = current_hand.data[0..current_hand.turn_number-1]
+      turns_taken.each_with_index do |turn, turn_index|
+        next unless turn.action_message
+
+        sequence[turn.action_message.state.round] << turn.action_message.action
+
+        if (
+          new_round?(sequence.length - 1 , turn_index) ||
+          players_all_in?(sequence.length - 1, turn_index, turns_taken)
+        )
+          sequence << []
+        end
+      end
+
+      sequence
+    end
+    def betting_sequence_string
+      (betting_sequence.map do |per_round|
+         (per_round.map{|action| action.to_acpc}).join('')
+      end).join('/')
+    end
+    # @todo Test and implement this
+    # def min_wager
+    #   return nil unless current_hand
+
+    #   @match_def.game_def.min_wagers[current_hand.next_state.round]
+    #   ChipStack.new [@min_wager.to_i, action_with_context.amount_to_put_in_pot.to_i].max
+    # end
+
+    protected
+
+    def initialize_players!
+      @players = @match_def.player_names.length.times.map do |seat|
+        AcpcPokerTypes::Player.join_match(
+          @match_def.player_names[seat],
+          seat,
+          @match_def.game_def.chip_stacks[seat]
+        )
+      end
+
+      self
+    end
+
+    def set_chip_distribution!(final_score)
+      @chip_distribution = []
+      final_score.each do |player_name, amount|
+        begin
+          @chip_distribution[@match_def.player_names.index(player_name.to_s)] = amount
+        rescue TypeError
+          raise AcpcPokerTypes::NamesDoNotMatch
+        end
+      end
+
+      self
+    end
+
+    def set_data!(parsed_action_messages, parsed_hand_results)
+      @data = []
+      parsed_action_messages.data.zip(parsed_hand_results.data).each do |action_messages_by_hand, hand_result|
+        @data <<  AcpcPokerTypes::AcpcDealerData::HandData.new(
+          @match_def,
+          action_messages_by_hand,
+          hand_result
+        )
+      end
+
+      self
+    end
+
+    private
+
+    def players_all_in?(current_round, turn_index, turns_taken)
+      current_hand.data.length == turn_index + 2 &&
+      current_round < (@match_def.game_def.number_of_rounds - 1) &&
+      (turns_taken[0..turn_index].count do |t|
+        # @todo Use FOLD constant instead once poker action has one
+        t.action_message.action.to_acpc_character == 'f'
+      end) != @players.length - 1
+    end
+
+    def new_round?(current_round, turn_index)
+      current_hand.data.length > turn_index + 1 &&
+      current_hand.data[turn_index + 1].action_message &&
+      current_hand.data[turn_index + 1].action_message.state.round > current_round
+    end
+  end
+end