acpc_poker_types 5.0.3 → 6.0.0

data/lib/acpc_poker_types/game_definition.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 require 'acpc_poker_types/chip_stack'
 require 'acpc_poker_types/suit'
 require 'acpc_poker_types/rank'
@@ -28,9 +26,6 @@ module AcpcPokerTypes
     #     number_of_board_cards == [0, 3, 1, 1]
     attr_reader :number_of_board_cards
 
-    # @return [Array] The minimum wager in each round.
-    attr_reader :min_wagers
-
     # @return [Array] The position relative to the dealer that is first to act
     #     in each round, indexed from 0.
     # @example The usual Texas hold'em sequence would look like this:
@@ -99,14 +94,6 @@ module AcpcPokerTypes
       :@number_of_board_cards => 'numBoardCards'
     }
 
-    ALL_PLAYER_ALL_ROUND_DEFS = [
-      DEFINITIONS[:@number_of_players],
-      DEFINITIONS[:@number_of_rounds],
-      DEFINITIONS[:@number_of_suits],
-      DEFINITIONS[:@number_of_ranks],
-      DEFINITIONS[:@number_of_hole_cards]
-    ]
-
     def self.default_first_player_positions(number_of_rounds)
       number_of_rounds.to_i.times.inject([]) do |list, i|
         list << 0
@@ -128,6 +115,12 @@ module AcpcPokerTypes
       end
     end
 
+    # @param [Array] array The array to flatten into a single element.
+    # @return +array+ if +array+ has more than one element, the single element in +array+ otherwise.
+    def self.flatten_if_single_element_array(array)
+      if 1 == array.length then array[0] else array end
+    end
+
     # Checks if the given line is a comment beginning with '#' or ';', or empty.
     #
     # @param [String] line
@@ -136,7 +129,7 @@ module AcpcPokerTypes
       line.nil? || line.match(/^\s*[#;]/) || line.empty?
     end
 
-    # Checks a given line frcom a game definition file for a game
+    # Checks a given line from a game definition file for a game
     # definition name and returns the given default value unless there is a match.
     #
     # @param [String, #match] line A line from a game definition file.
@@ -146,12 +139,11 @@ module AcpcPokerTypes
     #     referred to by +definition_name+, +nil+ otherwise.
     def self.check_game_def_line_for_definition(line, definition_name)
       if line.match(/^\s*#{definition_name}\s*=\s*([\d\s]+)/i)
-        value = $1.chomp.split(/\s+/).map{ |elem| elem.to_i }
-        if ALL_PLAYER_ALL_ROUND_DEFS.include? definition_name
-          value.shift
-        else
-          value
+        values = $1.chomp.split(/\s+/)
+        (0..values.length-1).each do |i|
+          values[i] = values[i].to_i
         end
+        flatten_if_single_element_array values
       end
     end
 
@@ -174,7 +166,12 @@ module AcpcPokerTypes
 
     def initialize(definitions)
       initialize_members!
-      parse_definitions! definitions
+
+      if definitions.is_a?(Hash)
+        assign_definitions! definitions
+      else
+        parse_definitions! definitions
+      end
 
       @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks(@number_of_players) if @chip_stacks.empty?
 
@@ -191,29 +188,38 @@ module AcpcPokerTypes
 
     alias_method :to_str, :to_s
 
+    def to_h
+      @hash ||= DEFINITIONS.keys.inject({betting_type: @betting_type}) do |h, instance_variable_symbol|
+        h[instance_variable_symbol[1..-1].to_sym] = instance_variable_get(instance_variable_symbol)
+        h
+      end
+    end
+
     def to_a
-      list_of_lines = []
-      list_of_lines << BETTING_TYPES[@betting_type] if @betting_type
-      list_of_lines << "stack = #{@chip_stacks.join(' ')}" unless @chip_stacks.empty?
-      list_of_lines << "numPlayers = #{@number_of_players}" if @number_of_players
-      list_of_lines << "blind = #{@blinds.join(' ')}" unless @blinds.empty?
-      list_of_lines << "raiseSize = #{min_wagers.join(' ')}" unless min_wagers.empty?
-      list_of_lines << "numRounds = #{@number_of_rounds}" if @number_of_rounds
-      list_of_lines << "firstPlayer = #{(@first_player_positions.map{|p| p + 1}).join(' ')}" unless @first_player_positions.empty?
-      list_of_lines << "maxRaises = #{@max_number_of_wagers.join(' ')}" unless @max_number_of_wagers.empty?
-      list_of_lines << "numSuits = #{@number_of_suits}" if @number_of_suits
-      list_of_lines << "numRanks = #{@number_of_ranks}" if @number_of_ranks
-      list_of_lines << "numHoleCards = #{@number_of_hole_cards}" if @number_of_hole_cards
-      list_of_lines << "numBoardCards = #{@number_of_board_cards.join(' ')}" unless @number_of_board_cards.empty?
-      list_of_lines
+      @array ||= -> do
+        list_of_lines = []
+        list_of_lines << BETTING_TYPES[@betting_type] if @betting_type
+        list_of_lines << "stack = #{@chip_stacks.join(' ')}" unless @chip_stacks.empty?
+        list_of_lines << "numPlayers = #{@number_of_players}" if @number_of_players
+        list_of_lines << "blind = #{@blinds.join(' ')}" unless @blinds.empty?
+        list_of_lines << "raiseSize = #{min_wagers.join(' ')}" unless min_wagers.empty?
+        list_of_lines << "numRounds = #{@number_of_rounds}" if @number_of_rounds
+        list_of_lines << "firstPlayer = #{(@first_player_positions.map{|p| p + 1}).join(' ')}" unless @first_player_positions.empty?
+        list_of_lines << "maxRaises = #{@max_number_of_wagers.join(' ')}" unless @max_number_of_wagers.empty?
+        list_of_lines << "numSuits = #{@number_of_suits}" if @number_of_suits
+        list_of_lines << "numRanks = #{@number_of_ranks}" if @number_of_ranks
+        list_of_lines << "numHoleCards = #{@number_of_hole_cards}" if @number_of_hole_cards
+        list_of_lines << "numBoardCards = #{@number_of_board_cards.join(' ')}" unless @number_of_board_cards.empty?
+        list_of_lines
+      end.call
     end
 
     def ==(other_game_definition)
-      Set.new(to_a) == Set.new(other_game_definition.to_a)
+      to_h == other_game_definition.to_h
     end
 
     def min_wagers
-      if @raise_sizes
+      @min_wagers ||= if @raise_sizes
         @raise_sizes
       else
         @number_of_rounds.times.map { |i| @blinds.max }
@@ -251,6 +257,12 @@ module AcpcPokerTypes
       end
     end
 
+    def assign_definitions!(definitions)
+      definitions.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
     def parse_definitions!(definitions)
       definitions.each do |line|
         break if line.match(/\bend\s*gamedef\b/i)
@@ -308,7 +320,7 @@ module AcpcPokerTypes
         unless Seat.in_bounds?(@first_player_positions[i], @number_of_players)
           raise(
             ParseError,
-            "Invalid first player #{@first_player_positions[i]} on round #{i+1}"
+            "Invalid first player #{@first_player_positions[i]} on round #{i+1} for #{@number_of_players} players"
           )
         end
       end
@@ -333,6 +345,11 @@ module AcpcPokerTypes
     end
 
     def adjust_definitions_if_necessary!
+      if @number_of_players < @chip_stacks.length
+        @number_of_players = @chip_stacks.length
+      elsif @number_of_players < @blinds.length
+        @number_of_players = @blinds.length
+      end
       @number_of_players.times do |i|
         @blinds << 0 unless @blinds.length > i
         @chip_stacks << DEFAULT_CHIP_STACK unless @chip_stacks.length > i

data/lib/acpc_poker_types/hand_player.rb

@@ -0,0 +1,119 @@
+require 'acpc_poker_types/chip_stack'
+require 'acpc_poker_types/hand'
+
+require 'contextual_exceptions'
+using ContextualExceptions::ClassRefinement
+
+module AcpcPokerTypes
+
+# Class to model a player during a hand from information in a +MatchState+
+class HandPlayer
+  exceptions :unable_to_pay_ante, :inactive
+
+  # @return [AcpcPokerTypes::ChipStack] This player's chip stack at the beginning of the
+  # hand before paying their ante.
+  attr_reader :initial_stack
+
+  # @return [AcpcPokerTypes::ChipStack] The ante this player paid at the beginning of
+  # the hand.
+  attr_reader :ante
+
+  # @return [Hand] This player's hole cards or nil if this player is not
+  # holding cards.
+  attr_reader :hand
+
+  # @return [Array<PokerAction>] The actions this player has taken
+  attr_reader :actions
+
+  attr_accessor :winnings
+
+  # @param hand [Hand]
+  # @param initial_chip_stack [#to_i]
+  # @param ante [#to_i]
+  def initialize(hand, initial_stack, ante)
+    raise UnableToPayAnte if ante > initial_stack
+
+    @hand = hand
+    @initial_stack = ChipStack.new initial_stack
+    @ante = ChipStack.new ante
+    @actions = [[]]
+    @winnings = ChipStack.new 0
+  end
+
+  def stack
+    @initial_stack + balance
+  end
+
+  def balance
+    @winnings - total_contribution
+  end
+
+  def contributions
+    @actions.map do |actions_per_round|
+      actions_per_round.inject(0) { |sum, action| sum += action.cost }
+    end.unshift @ante
+  end
+
+  def total_contribution
+    @ante + @actions.flatten.inject(0) { |sum, action| sum += action.cost }
+  end
+
+  # @param amount_to_call [#to_r] The amount to call for this player
+  # @param wager_illegal [Boolean]
+  # @return [Array<PokerAction>] The list of legal actions for this player. If a wager is legal,
+  # the largest possible wager will be returned in the list.
+  def legal_actions(
+    round,
+    amount_to_call: ChipStack.new(0),
+    wager_illegal: false
+  )
+    l_actions = []
+    return l_actions if inactive?
+
+    if amount_to_call.to_r > 0
+      l_actions << PokerAction.new(PokerAction::CALL) << PokerAction.new(PokerAction::FOLD)
+    else
+      l_actions << PokerAction.new(PokerAction::CHECK)
+    end
+    if !wager_illegal && stack > amount_to_call.to_r
+      l_actions << if contributions[round] > 0 || amount_to_call.to_r > 0
+        PokerAction.new(PokerAction::RAISE, cost: stack - amount_to_call.to_r)
+      else
+        PokerAction.new(PokerAction::BET, cost: stack - amount_to_call.to_r)
+      end
+    end
+
+    l_actions
+  end
+
+  # @param round [Integer] The round in which the largest wager by size is desired.
+  # defaults to +nil+.
+  # @return [ChipStack] The largest wager by size this player has made.
+  # Checks only in the specified +round+ or over the entire hand if round is +nil+.
+  def largest_wager_by(round=nil)
+    # @todo
+  end
+
+  def append_action!(action, round = @actions.length - 1)
+    raise Inactive if inactive?
+
+    @actions[round] ||= []
+    @actions[round] << action
+
+    self
+  end
+
+  def inactive?
+    folded? || all_in?
+  end
+
+  def all_in?
+    stack <= 0
+  end
+
+  def folded?
+    @actions.flatten.last == PokerAction::FOLD
+  end
+end
+
+end

data/lib/acpc_poker_types/match_state.rb

@@ -3,263 +3,382 @@ require 'acpc_poker_types/hand'
 require 'acpc_poker_types/rank'
 require 'acpc_poker_types/suit'
 require 'acpc_poker_types/poker_action'
+require 'acpc_poker_types/hand_player'
+require 'acpc_poker_types/player_group'
 
-require 'contextual_exceptions'
-using ContextualExceptions::ClassRefinement
+module AcpcPokerTypes
+module Indices
+  refine Array do
+    def inject_with_index(init)
+      i = 0
+      inject(init) do |accum, elem|
+        yield accum, elem, i if block_given?
+        i += 1
+        accum
+      end
+    end
+    def indices(elem_to_find=nil)
+      if elem_to_find
+        indices { |elem| elem == elem_to_find }
+      else
+        inject_with_index([]) do |array, elem, i|
+          array << i if yield elem
+          array
+        end
+      end
+    end
+  end
+end
+end
+using AcpcPokerTypes::Indices
 
-# Model to parse and manage information from a given match state string.
 module AcpcPokerTypes
-  class MatchState
-    exceptions :incomplete_match_state
 
-    # @return [Integer] The position relative to the dealer of the player that
-    #     received the match state string, indexed from 0, modulo the
-    #     number of players.
-    # @example The player immediately to the left of the dealer has
-    #     +position_relative_to_dealer+ == 0
-    # @example The dealer has
-    #     +position_relative_to_dealer+ == <number of players> - 1
-    attr_reader :position_relative_to_dealer
+# Model to parse and manage information from a given match state string.
+class MatchState
+  # @return [Integer] The position relative to the dealer of the player that
+  #     received the match state string, indexed from 0, modulo the
+  #     number of players.
+  # @example The player immediately to the left of the dealer has
+  #     +position_relative_to_dealer+ == 0
+  # @example The dealer has
+  #     +position_relative_to_dealer+ == <number of players> - 1
+  attr_reader :position_relative_to_dealer
 
-    # @return [Integer] The hand number.
-    attr_reader :hand_number
+  # @return [Integer] The hand number.
+  attr_reader :hand_number
 
-    # @return [Array<Array<AcpcPokerTypes::PokerAction>>] The sequence of betting actions.
-    attr_reader :betting_sequence
+  # @return [String] The ACPC string created by the given betting sequence.
+  attr_reader :betting_sequence_string
 
-    # @return [Array<AcpcPokerTypes::Hand>] The list of visible hole card sets for each player.
-    attr_reader :list_of_hole_card_hands
+  # @todo Move this @return [Array<Hand>] The list of visible hole card sets for each player.
 
-    # @return [AcpcPokerTypes::BoardCards] All visible community cards on the board.
-    attr_reader :board_cards
+  attr_reader :hands_string
 
-    # @return [Array<Integer>] The list of first seats for each round.
-    attr_reader :first_seat_in_each_round
+  # @todo Move this @return [BoardCards] All visible community cards on the board.
 
-    # @return [String] Label for match state strings.
-    LABEL = 'MATCHSTATE'
+  attr_reader :community_cards_string
 
-    class << self; alias_method(:parse, :new) end
+  # @return [String] Label for match state strings.
+  LABEL = 'MATCHSTATE'
 
-    # Receives a match state string from the given +connection+.
-    # @param [#gets] connection The connection from which a match state string should be received.
-    # @return [MatchState] The match state string that was received from the +connection+ or +nil+ if none could be received.
-    def self.receive(connection)
-      AcpcPokerTypes::MatchState.parse connection.gets
-    end
+  COMMUNITY_CARD_SEPARATOR = '/'
+  BETTING_SEQUENCE_SEPARATOR = COMMUNITY_CARD_SEPARATOR
+  HAND_SEPARATOR = '|'
+
+  class << self; alias_method(:parse, :new) end
+
+  # Receives a match state string from the given +connection+.
+  # @param [#gets] connection The connection from which a match state string should be received.
+  # @return [MatchState] The match state string that was received from the +connection+ or +nil+ if none could be received.
+  def self.receive(connection)
+    MatchState.parse connection.gets
+  end
 
-    # Builds a match state string from its given component parts.
-    #
-    # @param [#to_s] position_relative_to_dealer The position relative to the dealer.
-    # @param [#to_s] hand_number The hand number.
-    # @param [#to_s] betting_sequence The betting sequence.
-    # @param [#to_s] all_hole_cards All the hole cards visible.
-    # @param [#to_acpc, #empty?] board_cards All the community cards on the board.
-    # @return [String] The constructed match state string.
-    def self.build_match_state_string(
-      position_relative_to_dealer,
-      hand_number,
-      betting_sequence,
-      all_hole_cards,
-      board_cards
+  # Builds a match state string from its given component parts.
+  #
+  # @param [#to_s] position_relative_to_dealer The position relative to the dealer.
+  # @param [#to_s] hand_number The hand number.
+  # @param [#to_s] betting_sequence The betting sequence.
+  # @param [#to_s] all_hole_cards All the hole cards visible.
+  # @param [#to_s, #empty?] board_cards All the community cards on the board.
+  # @return [String] The constructed match state string.
+  def self.build_match_state_string(
+    position_relative_to_dealer,
+    hand_number,
+    betting_sequence,
+    all_hole_cards,
+    board_cards
+  )
+    string = "#{LABEL}:#{position_relative_to_dealer}:#{hand_number}:#{betting_sequence}:#{all_hole_cards}"
+    string << "/#{board_cards.to_s}" if board_cards && !board_cards.empty?
+    string
+  end
+
+  # @param [String] raw_match_state A raw match state string to be parsed.
+  # @raise IncompleteMatchState
+  def initialize(raw_match_state)
+    if raw_match_state.match(
+/#{LABEL}:(\d+):(\d+):([^:]*):([^#{COMMUNITY_CARD_SEPARATOR}]+)#{COMMUNITY_CARD_SEPARATOR}*([^\s:]*)/
     )
-      string = "#{LABEL}:#{position_relative_to_dealer}:#{hand_number}:#{betting_sequence}:#{all_hole_cards}"
-      string << board_cards.to_acpc if board_cards && !board_cards.empty?
-      string
+      @position_relative_to_dealer = $1.to_i
+      @hand_number = $2.to_i
+      @betting_sequence_string = $3
+      @hands_string = $4
+      @community_cards_string = $5
     end
+  end
 
-    # Checks if the given line is a comment beginning with '#' or ';', or empty.
-    #
-    # @param [String] line
-    # @return [Boolean] True if +line+ is a comment or empty, false otherwise.
-    def self.line_is_comment_or_empty?(line)
-      line.nil? || line.match(/^\s*[#;]/) || line.empty?
-    end
+  # @return [String] The MatchState in raw text form.
+  def to_str
+    @str ||= MatchState.build_match_state_string(
+      @position_relative_to_dealer,
+      @hand_number,
+      @betting_sequence_string,
+      @hands_string,
+      @community_cards_string
+    )
+  end
 
-    # @param [String] raw_match_state A raw match state string to be parsed.
-    # @raise IncompleteMatchState
-    def initialize(raw_match_state)
-      raise IncompleteMatchState, raw_match_state if AcpcPokerTypes::MatchState.line_is_comment_or_empty? raw_match_state
-
-      if raw_match_state.match(
-        /#{LABEL}:(\d+):(\d+):([\d#{AcpcPokerTypes::PokerAction::CONCATONATED_ACTIONS}\/]*):([|#{AcpcPokerTypes::Card::CONCATONATED_CARDS}]+)\/*([\/#{AcpcPokerTypes::Card::CONCATONATED_CARDS}]*)/)
-        @position_relative_to_dealer = $1.to_i
-        @hand_number = $2.to_i
-        @betting_sequence = parse_betting_sequence $3
-        @list_of_hole_card_hands = parse_list_of_hole_card_hands $4
-        @board_cards = parse_board_cards $5
-      end
+  # @see to_str
+  alias_method :to_s, :to_str
 
-      raise IncompleteMatchState, raw_match_state if incomplete_match_state?
-    end
+  # @param [MatchState] another_match_state A match state string to compare against this one.
+  # @return [Boolean] +true+ if this match state string is equivalent to +another_match_state+, +false+ otherwise.
+  def ==(another_match_state)
+    another_match_state.to_s == to_s
+  end
 
-    # @return [String] The AcpcPokerTypes::MatchState in raw text form.
-    def to_str
-      AcpcPokerTypes::MatchState.build_match_state_string(
-        @position_relative_to_dealer,
-        @hand_number, betting_sequence_string,
-        hole_card_strings,
-        @board_cards
-      )
-    end
+  def all_hands
+    @all_hands ||= -> do
+      lcl_hole_card_hands = all_string_hands(@hands_string).map do |string_hand|
+        Hand.from_acpc string_hand
+      end
+      while lcl_hole_card_hands.length < number_of_players
+        lcl_hole_card_hands.push Hand.new
+      end
+      lcl_hole_card_hands
+    end.call
+  end
 
-    # @see to_str
-    alias_method :to_s, :to_str
+  # @return [Array<Array<PokerAction>>] The sequence of betting actions.
+  def betting_sequence
+    @betting_sequence ||= if @betting_sequence_string.empty?
+      [[]]
+    else
+      lcl_betting_sequence = @betting_sequence_string.split(
+        BETTING_SEQUENCE_SEPARATOR
+      ).map do |betting_string_per_round|
+        actions_from_acpc_characters(betting_string_per_round).map do |action|
+          PokerAction.new(action)
+        end
+      end
 
-    # @param [AcpcPokerTypes::MatchState] another_match_state A match state string to compare against this one.
-    # @return [Boolean] +true+ if this match state string is equivalent to +another_match_state+, +false+ otherwise.
-    def ==(another_match_state)
-      another_match_state.to_s == to_s
+      # Adjust the number of rounds if the last action was the last action in the round
+      lcl_betting_sequence << [] if first_state_of_round?
+      lcl_betting_sequence
     end
+  end
 
-    # @return [Integer] The number of players in this match.
-    def number_of_players() @list_of_hole_card_hands.length end
-
-    # @param [Array<Array<AcpcPokerTypes::PokerAction>>] betting_sequence The betting sequence from which the last action should be retrieved.
-    # @return [AcpcPokerTypes::PokerAction] The last action taken.
-    # @raise NoActionsHaveBeenTaken if no actions have been taken.
-    def last_action(betting_sequence=@betting_sequence)
-      if betting_sequence.nil? || betting_sequence.empty?
-        nil
-      elsif betting_sequence.last.last
-        betting_sequence.last.last
-      else
-        last_action(betting_sequence.reject{ |elem| elem.equal?(betting_sequence.last) })
+  def community_cards
+    @community_cards ||= -> do
+      lcl_community_cards = BoardCards.new(
+        all_sets_of_community_cards(@community_cards_string).map do |cards_in_round|
+          Card.cards(cards_in_round)
+        end
+      )
+      if lcl_community_cards.round < @community_cards_string.count(COMMUNITY_CARD_SEPARATOR)
+        lcl_community_cards.next_round!
       end
-    end
+      lcl_community_cards
+    end.call
+  end
 
-    # @return [AcpcPokerTypes::Hand] The user's hole cards.
-    # @example An ace of diamonds and a 4 of clubs is represented as
-    #     'Ad4c'
-    def users_hole_cards
-      @list_of_hole_card_hands[@position_relative_to_dealer]
-    end
+  # @return [Integer] The zero indexed current round number.
+  def round
+    @round ||= @betting_sequence_string.count BETTING_SEQUENCE_SEPARATOR
+  end
 
-    # @return [Array] The list of opponent hole cards that are visible.
-    # @example If there are two opponents, one with AhKs and the other with QdJc, then
-    #     list_of_opponents_hole_cards == [AhKs:AcpcPokerTypes::Hand, QdJc:AcpcPokerTypes::Hand]
-    def list_of_opponents_hole_cards
-      local_list_of_hole_card_hands = @list_of_hole_card_hands.dup
-      local_list_of_hole_card_hands.delete_at @position_relative_to_dealer
-      local_list_of_hole_card_hands
-    end
+  # @return [Hand] The user's hand.
+  # @example An ace of diamonds and a 4 of clubs is represented as
+  #     'Ad4c'
+  def hand
+    @hand ||= all_hands[@position_relative_to_dealer]
+  end
 
-    # @return [Integer] The zero indexed current round number.
-    def round
-      @betting_sequence.length - 1
-    end
+  # @return [Array] The list of opponent hole card hands.
+  # @example If there are two opponents, one with AhKs and the other with QdJc, then
+  #     list_of_opponents_hole_cards == [AhKs:Hand, QdJc:Hand]
+  def opponent_hands
+    @opponent_hands ||= -> do
+      hands = all_hands.dup
+      hands.delete_at @position_relative_to_dealer
+      hands
+    end.call
+  end
 
-    # @return [Integer] The number of actions in the current round.
-    def number_of_actions_this_round() @betting_sequence[round].length end
+  # @return [Boolean] Reports whether or not it is the first state of the first round.
+  def first_state_of_first_round?
+    @first_state_of_first_round ||= @betting_sequence_string.empty?
+  end
 
-    # @return [Integer] The number of actions in the current hand.
-    def number_of_actions_this_hand
-      @betting_sequence.inject(0) do |sum, sequence_per_round|
-        sum += sequence_per_round.length
-      end
-    end
+  def first_state_of_round?
+    @first_state_of_round ||= @betting_sequence_string[-1] == BETTING_SEQUENCE_SEPARATOR
+  end
 
-    # @param [Array<Action>] betting_sequence=@betting_sequence The sequence of
-    #  actions to link into an ACPC string.
-    # @return [String] The ACPC string created by the given betting sequence,
-    #  +betting_sequence+.
-    def betting_sequence_string(betting_sequence=@betting_sequence)
-      (round + 1).times.inject('') do |string, i|
-        string << (betting_sequence[i].map { |action| action.to_s }).join('')
-        string << '/' unless i == round
-        string
-      end
-    end
+  # @return [Integer] The number of players in this match.
+  def number_of_players
+    @number_of_players ||= @hands_string.count(HAND_SEPARATOR) + 1
+  end
 
-    # @return [Boolean] Reports whether or not it is the first state of the first round.
-    def first_state_of_first_round?
-      (0 == number_of_actions_this_hand)
+  # @return [PokerAction] The last action taken.
+  def last_action
+    @last_action ||= if @betting_sequence_string.match(
+      /([^#{BETTING_SEQUENCE_SEPARATOR}])#{BETTING_SEQUENCE_SEPARATOR}*$/
+    )
+      PokerAction.new($1)
+    else
+      nil
     end
+  end
+
+  # @return [Integer] The number of actions in the current round.
+  def number_of_actions_this_round
+    @number_of_actions_this_round ||= betting_sequence[round].length
+  end
 
-    def player_position_relative_to_self
-      number_of_players - 1
+  # @return [Integer] The number of actions in the current hand.
+  def number_of_actions_this_hand
+    @number_of_actions_this_hand ||= betting_sequence.inject(0) do |sum, sequence_per_round|
+      sum += sequence_per_round.length
     end
+  end
 
-    def round_in_which_last_action_taken
-      unless number_of_actions_this_hand > 0
-        nil
+  def round_in_which_last_action_taken
+    @round_in_which_last_action_taken ||= if first_state_of_first_round?
+      nil
+    else
+      if @betting_sequence_string[-1] == BETTING_SEQUENCE_SEPARATOR
+        round - 1
       else
-        if number_of_actions_this_round < 1
-          round - 1
-        else
-          round
-        end
+        round
       end
     end
+  end
+
+  # @param stacks [Array<#to_f>]
+  # @param blinds [Array<#to_f>]
+  # @return [PlayerGroup] The state of the players in this hand at the
+  # when the hand began.
+  def players_at_hand_start(stacks, blinds)
+    PlayerGroup.new all_hands, stacks, blinds
+  end
 
-    private
-
-    def validate_first_seats(list_of_first_seats)
-      begin
-        raise UnknownFirstSeat, round unless round < list_of_first_seats.length
-        all_seats_are_occupied = ((problem_seat = list_of_first_seats.max) < number_of_players) && ((problem_seat = list_of_first_seats.min.abs)-1 < number_of_players)
-        raise FirstSeatIsUnoccupied, problem_seat unless all_seats_are_occupied
-      rescue UnknownFirstSeat => e
-        raise e
-      rescue FirstSeatIsUnoccupied => e
-        raise e
-      rescue => e
-        raise UnknownFirstSeat, e.message
+  # @param game_def [GameDefinition]
+  # @return [PlayerGroup] The current state of the players.
+  def every_action(game_def)
+    @players = players_at_hand_start game_def.chip_stacks, game_def.blinds
+
+    last_round = -1
+    acting_player_position = nil
+    @player_acting_sequence = []
+    every_action_token do |action, round|
+      if round != last_round
+        acting_player_position = game_def.first_player_positions[round]
+        @player_acting_sequence << []
+        last_round = round
       end
-      list_of_first_seats
-    end
 
-    def list_of_actions_from_acpc_characters(betting_sequence)
-      betting_sequence.scan(/[#{AcpcPokerTypes::PokerAction::CONCATONATED_ACTIONS}]\d*/)
-    end
+      acting_player_position = @players.position_of_first_active_player(
+        acting_player_position
+      )
 
-    def incomplete_match_state?
-      !(@position_relative_to_dealer and @hand_number and
-        @list_of_hole_card_hands) || @list_of_hole_card_hands.empty?
-    end
+      @player_acting_sequence.last << acting_player_position
 
-    def parse_list_of_hole_card_hands(string_of_hole_cards)
-      list_of_hole_card_hands = every_set_of_cards(string_of_hole_cards, '\|').map do |string_hand|
-        AcpcPokerTypes::Hand.from_acpc string_hand
-      end
-      while list_of_hole_card_hands.length < (string_of_hole_cards.count('|') + 1)
-        list_of_hole_card_hands.push AcpcPokerTypes::Hand.new
-      end
-      list_of_hole_card_hands
+      cost = @players.action_cost(
+        acting_player_position,
+        action,
+        game_def.min_wagers[round]
+      )
+
+      @players[acting_player_position].append_action!(
+        if cost > 0
+          action = PokerAction.new(action.to_s, cost: cost)
+        else
+          action
+        end,
+        round
+      )
+
+      yield action, round, acting_player_position, @players if block_given?
+
+      acting_player_position = @players.next_player_position(
+        acting_player_position
+      )
     end
 
-    def parse_betting_sequence(string_betting_sequence)
-      return [[]] if string_betting_sequence.empty?
+    distribute_chips!(game_def) if hand_ended?(game_def)
+
+    @players
+  end
+
+  def players(game_def)
+    @players ||= every_action(game_def)
+  end
+
+  def player_acting_sequence(game_def)
+    every_action(game_def) unless @player_acting_sequence
+
+    @player_acting_sequence
+  end
 
-      betting_sequence = string_betting_sequence.split(/\//).map do |betting_string_per_round|
-        list_of_actions_in_a_particular_round = list_of_actions_from_acpc_characters(
-          betting_string_per_round
-        ).map do |action|
-          AcpcPokerTypes::PokerAction.new(action)
+  # @return [Boolean] +true+ if the hand has ended, +false+ otherwise.
+  def hand_ended?(game_def)
+    @hand_ended ||= reached_showdown? || players(game_def).count { |player| player.inactive? } >= number_of_players - 1
+  end
+
+  def reached_showdown?
+    opponents_cards_visible?
+  end
+
+  def opponents_cards_visible?
+    @opponents_cards_visible ||= all_hands.count { |h| !h.empty? } > 1 # At least one opponent hand visible
+  end
+
+  def pot(game_def)
+    @pot ||= players(game_def).map { |player| player.contributions }.flatten.inject(:+)
+  end
+
+  private
+
+  # Distribute chips to all winning players
+  def distribute_chips!(game_def)
+    return self if pot(game_def) <= 0
+
+    # @todo This only works for Doyle's game where there are no side-pots.
+    if 1 == players(game_def).count { |player| !player.folded? }
+      players(game_def).select { |player| !player.folded? }.first.winnings = pot(game_def)
+    else
+      hand_strengths = players(game_def).map do |player|
+        if player.folded?
+          -1
+        else
+          PileOfCards.new(community_cards.flatten + player.hand).to_poker_hand_strength
         end
       end
+      winning_players = hand_strengths.indices(hand_strengths.max)
+      amount_each_player_wins = pot(game_def)/winning_players.length.to_r
 
-      # Adjust the number of rounds if the last action was the last action in the round
-      betting_sequence << [] if string_betting_sequence.match(/\/$/)
-      betting_sequence
+      winning_players.each do |player_index|
+        @players[player_index].winnings = amount_each_player_wins
+      end
     end
 
-    def parse_board_cards(string_board_cards)
-      board_cards = AcpcPokerTypes::BoardCards.new(
-        every_set_of_cards(string_board_cards, '\/').map do |cards_in_round|
-          AcpcPokerTypes::Card.cards(cards_in_round)
-        end
-      )
-      board_cards.next_round! if board_cards.round < string_board_cards.count('/')
-      board_cards
-    end
+    self
+  end
 
-    def every_set_of_cards(string_of_card_sets, divider)
-      string_of_card_sets.split(/#{divider}/)
+  def every_action_token
+    betting_sequence.each_with_index do |actions_per_round, round|
+      actions_per_round.each do |action|
+        yield action, round if block_given?
+      end
     end
+  end
 
-    def hole_card_strings
-      (@list_of_hole_card_hands.map { |hand| hand.to_acpc }).join '|'
-    end
+  def all_string_hands(string_of_card_sets)
+    all_sets_of_cards(string_of_card_sets, HAND_SEPARATOR)
+  end
+
+  def all_sets_of_community_cards(string_of_card_sets)
+    all_sets_of_cards(string_of_card_sets, COMMUNITY_CARD_SEPARATOR)
+  end
+
+  def all_sets_of_cards(string_of_card_sets, divider)
+    string_of_card_sets.split(divider)
+  end
+
+  def actions_from_acpc_characters(action_sequence)
+    action_sequence.scan(/[^#{BETTING_SEQUENCE_SEPARATOR}\d]\d*/)
   end
+end
 end