acpc_poker_types 5.0.3 → 6.0.0

data/lib/acpc_poker_types/player_group.rb

@@ -0,0 +1,62 @@
+require 'delegate'
+
+require 'acpc_poker_types/poker_action'
+require 'acpc_poker_types/hand_player'
+
+# Model to parse and manage information from a given match state string.
+module AcpcPokerTypes
+
+class PlayerGroup < DelegateClass(Array)
+  attr_reader :players
+
+  def initialize(all_hands, stacks, blinds)
+    @players = all_hands.length.times.map do |i|
+      HandPlayer.new all_hands[i], stacks[i], blinds[i]
+    end
+
+    super @players
+  end
+
+  def next_player_position(acting_player_position=-1)
+    (acting_player_position + 1) % length
+  end
+
+  def position_of_first_active_player(acting_player_position=0)
+    raise NoPlayerCouldHaveActed if all? { |player| player.inactive? }
+
+    # This must eventually exit because of the above assertion
+    while @players[acting_player_position].inactive?
+      acting_player_position = next_player_position(acting_player_position)
+    end
+    acting_player_position
+  end
+
+  def action_cost(acting_player_position, action, min_wager)
+    case action.to_s[0]
+    when PokerAction::CALL
+      amount_to_call acting_player_position
+    when PokerAction::RAISE
+      if action.modifier
+        action.modifier.to_i - players[acting_player_position].total_contribution
+      else
+        min_wager + amount_to_call(acting_player_position)
+      end
+    else
+      0
+    end
+  end
+
+  def amount_to_call(acting_player_position)
+    ChipStack.new(
+      [
+        (
+          map do |player|
+            player.total_contribution
+          end
+        ).max - players[acting_player_position].total_contribution,
+        @players[acting_player_position].stack
+      ].min
+    )
+  end
+end
+end

data/lib/acpc_poker_types/poker_action.rb

@@ -64,16 +64,20 @@ module AcpcPokerTypes
     attr_reader :pot_gained_chips
 
     # @param [Symbol, String] action A representation of this action.
-    # @param [Hash] context The context in which this action is being made. Recognized keys include +:modifier+,
-    #  +:pot_gained_chips+, and +:cost+.
+    # @param modifier [String] A modifier to attach to this action such as a wager size.
+    # @param cost [#to_f] The amount this action costs to the acting player.
     # @raise IllegalAction
-    def initialize(action, modifier: nil, cost: AcpcPokerTypes::ChipStack.new(0))
+    def initialize(action, modifier: nil, cost: 0)
       validate_action!(action, modifier.strip)
-      @cost = cost
+      @cost = cost.to_f
     end
 
     def ==(other_action)
-      to_s == other_action.to_s
+      0 == (self <=> other_action)
+    end
+
+    def <=>(other_action)
+      to_s <=> other_action.to_s
     end
 
     # @return [String] String representation of this action.
@@ -93,6 +97,7 @@ module AcpcPokerTypes
     end
 
     alias_method :to_acpc, :to_s
+    alias_method :to_str, :to_s
 
     # @return [Boolean] +true+ if this action has a modifier, +false+ otherwise.
     def has_modifier?
@@ -131,7 +136,9 @@ module AcpcPokerTypes
     end
 
     def validate_modifier
-      raise(IllegalModification, "Illegal modifier: #{@modifier}") unless @modifier.blank? || AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.include?(@action)
+      unless @modifier.blank? || MODIFIABLE_ACTIONS.include?(@action)
+        raise(IllegalModification, "Illegal modifier: #{@modifier}")
+      end
     end
   end
 end

data/lib/acpc_poker_types/version.rb

@@ -1,3 +1,3 @@
 module AcpcPokerTypes
-  VERSION = '5.0.3'
+  VERSION = '6.0.0'
 end

data/spec/game_definition_spec.rb

@@ -1,16 +1,35 @@
-
 # Spec helper (must include first to track code coverage with SimpleCov)
 require_relative 'support/spec_helper'
 
 require 'acpc_dealer'
-
 require 'acpc_poker_types/game_definition'
-
 require 'acpc_poker_types/chip_stack'
 
-describe AcpcPokerTypes::GameDefinition do
+include AcpcPokerTypes
+
+describe GameDefinition do
   include AcpcDealer
 
+  describe '::new' do
+    it 'creates a new game definition from a hash' do
+      x_hash = {
+        betting_type: 'limit', 
+        chip_stacks: [10] * 3,
+        number_of_players: 3,
+        blinds: [2] * 3,
+        raise_sizes: [2] * 3,
+        number_of_rounds: 4,
+        first_player_positions: [1] * 4,
+        max_number_of_wagers: [3] * 4,
+        number_of_suits: 4,
+        number_of_ranks: 13,
+        number_of_hole_cards: 2,
+        number_of_board_cards: [2] * 4
+      }
+      GameDefinition.new(x_hash).to_h.must_equal(x_hash)
+    end
+  end
+
   describe '::default_first_player_positions' do
     it 'works' do
       100.times do |number_of_rounds|

data/spec/hand_player_spec.rb

@@ -0,0 +1,254 @@
+
+# Spec helper (must include first to track code coverage with SimpleCov)
+require_relative 'support/spec_helper'
+
+require 'acpc_dealer'
+require 'acpc_poker_types/acpc_dealer_data/poker_match_data'
+
+require 'acpc_poker_types/hand_player'
+require 'acpc_poker_types/poker_action'
+require 'acpc_poker_types/hand'
+require 'acpc_poker_types/match_state'
+
+include AcpcPokerTypes
+
+describe HandPlayer do
+  INITIAL_CHIP_STACK = ChipStack.new 100000
+  ANTE = 100
+  HAND = Hand.from_acpc('AhKs')
+
+  def patient
+    @patient ||= HandPlayer.new HAND, INITIAL_CHIP_STACK, ANTE
+  end
+
+  describe '::new' do
+    it 'raises an exception if the player is unable to pay the ante' do
+      -> { HandPlayer.new HAND, INITIAL_CHIP_STACK, INITIAL_CHIP_STACK + 1 }.must_raise HandPlayer::UnableToPayAnte
+    end
+    it 'works' do
+      [0, 100].each do |ante|
+        @patient = HandPlayer.new HAND, INITIAL_CHIP_STACK, ante
+
+        @patient.hand.must_equal HAND
+        @patient.stack.must_equal INITIAL_CHIP_STACK - ante
+        @patient.ante.must_equal ante
+        @patient.initial_stack.must_equal INITIAL_CHIP_STACK
+      end
+    end
+  end
+  describe '#append_action!' do
+    describe 'raises an exception if it is not active' do
+      it 'if it has folded' do
+        x_actions = [['c', 'r100'], ['r200', 'c'], ['f']]
+        x_actions.each_with_index do |actions, round|
+          actions.each do |action|
+            patient.append_action! PokerAction.new(action), round
+          end
+        end
+
+        -> { patient.append_action!(PokerAction.new(PokerAction::CALL), x_actions.length - 1) }.must_raise HandPlayer::Inactive
+      end
+      it 'if it has gone all in' do
+        x_actions = [
+          [
+            PokerAction.new('c'),
+            PokerAction.new('r200')
+          ],
+          [
+            PokerAction.new('r400'),
+            PokerAction.new('c', cost: INITIAL_CHIP_STACK - ANTE)
+          ]
+        ]
+        x_actions.each_with_index do |actions, round|
+          actions.each do |action|
+            patient.append_action!(action, round)
+          end
+        end
+
+        -> { patient.append_action!(PokerAction.new(PokerAction::CALL), x_actions.length - 1) }.must_raise HandPlayer::Inactive
+      end
+    end
+    it 'works' do
+      x_actions = [['c', 'r100'], ['r200', 'c'], ['f']]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action! PokerAction.new(action), round
+        end
+      end
+
+      patient.actions.must_equal x_actions
+    end
+  end
+  describe '#folded?' do
+    it 'works' do
+      x_actions = [['c', 'r100'], ['r200', 'c']]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action!(PokerAction.new(action), round).folded?.must_equal false
+        end
+      end
+
+      patient.append_action!(PokerAction.new(PokerAction::FOLD), x_actions.length - 1).folded?.must_equal true
+    end
+  end
+  describe '#all_in?' do
+    it 'works' do
+      x_actions = [
+        [
+          PokerAction.new('c'),
+          PokerAction.new('r200')
+        ],
+        [
+          PokerAction.new('r400')
+        ]
+      ]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action!(action, round).all_in?.must_equal false
+        end
+      end
+
+      patient.append_action!(PokerAction.new('c', cost: INITIAL_CHIP_STACK)).all_in?.must_equal true
+    end
+  end
+  describe '#inactive?' do
+    it 'is true if it has gone all in' do
+      x_actions = [
+        [
+          PokerAction.new('c'),
+          PokerAction.new('r200')
+        ],
+        [
+          PokerAction.new('r400')
+        ]
+      ]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action!(action, round).inactive?.must_equal false
+        end
+      end
+
+      patient.append_action!(PokerAction.new('c', cost: INITIAL_CHIP_STACK - ANTE)).inactive?.must_equal true
+    end
+    it 'is true if it has folded' do
+      x_actions = [
+        [
+          PokerAction.new('c'),
+          PokerAction.new('r200')
+        ],
+        [
+          PokerAction.new('r400')
+        ]
+      ]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action!(action, round).inactive?.must_equal false
+        end
+      end
+
+      patient.append_action!(PokerAction.new(PokerAction::FOLD)).inactive?.must_equal true
+    end
+  end
+  describe '#contributions' do
+    it 'works' do
+      x_actions = [
+        [
+          PokerAction.new('c', cost: 100),
+          PokerAction.new('r200', cost: 100)
+        ],
+        [
+          PokerAction.new('r400', cost: 200),
+          PokerAction.new('c', cost: 0)
+        ]
+      ]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action!(action, round)
+        end
+      end
+
+      patient.contributions.must_equal(
+        x_actions.map do |actions|
+          actions.inject(0) { |sum, action| sum += action.cost }
+        end.unshift(ANTE)
+      )
+    end
+  end
+  describe '#total_contribution' do
+    it 'works' do
+      x_actions = [
+        [
+          PokerAction.new('c', cost: 100),
+          PokerAction.new('r200', cost: 100)
+        ],
+        [
+          PokerAction.new('r400', cost: 200),
+          PokerAction.new('c', cost: 0)
+        ]
+      ]
+      x_actions.each_with_index do |actions, round|
+        actions.each do |action|
+          patient.append_action!(action, round)
+        end
+      end
+
+      patient.total_contribution.must_equal(
+        ANTE + x_actions.flatten.inject(0) { |sum, action| sum += action.cost }
+      )
+    end
+  end
+
+  describe '#legal_actions' do
+    it 'works with fold' do
+      patient.legal_actions(0, amount_to_call: 100).sort.must_equal [
+        PokerAction.new(PokerAction::CALL),
+        PokerAction.new(PokerAction::RAISE, cost: INITIAL_CHIP_STACK - (ANTE + 100)),
+        PokerAction.new(PokerAction::FOLD)
+      ].sort
+      patient.append_action!(PokerAction.new('c', cost: 100))
+        .legal_actions(0, amount_to_call: 200).sort.must_equal [
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::RAISE, cost: INITIAL_CHIP_STACK - (ANTE + 200)),
+          PokerAction.new(PokerAction::FOLD)
+        ].sort
+      patient.append_action!(PokerAction.new('f'))
+        .legal_actions(0).empty?.must_equal true
+    end
+    it 'works with all in' do
+      patient.legal_actions(0).sort.must_equal [
+        PokerAction.new(PokerAction::CHECK),
+        PokerAction.new(PokerAction::BET, cost: INITIAL_CHIP_STACK - ANTE),
+      ].sort
+      patient.append_action!(PokerAction.new('c', cost: 100))
+        .legal_actions(0).sort.must_equal [
+          PokerAction.new(PokerAction::CHECK),
+          PokerAction.new(PokerAction::BET, cost: INITIAL_CHIP_STACK - (ANTE + 100)),
+        ].sort
+      patient.append_action!(PokerAction.new('c', cost: INITIAL_CHIP_STACK - (ANTE + 100)))
+        .legal_actions(0).empty?.must_equal true
+    end
+    it 'works when an opponent is all in' do
+      patient.append_action!(PokerAction.new('c', cost: 100))
+        .legal_actions(0).sort.must_equal [
+          PokerAction.new(PokerAction::CHECK),
+          PokerAction.new(PokerAction::RAISE, cost: INITIAL_CHIP_STACK - (ANTE + 100))
+        ].sort
+      patient.legal_actions(0, amount_to_call: INITIAL_CHIP_STACK - (ANTE + 100))
+        .sort.must_equal [
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::FOLD)
+        ].sort
+    end
+    it 'works when no more raises are allowed' do
+      patient.append_action!(PokerAction.new('c', cost: 100))
+        .legal_actions(0, wager_illegal: true).sort.must_equal [
+          PokerAction.new(PokerAction::CHECK)
+        ].sort
+      patient.legal_actions(0, amount_to_call: INITIAL_CHIP_STACK - (ANTE + 100))
+        .sort.must_equal [
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::FOLD)
+        ].sort
+    end
+  end
+end

data/spec/match_state_spec.rb

@@ -1,53 +1,44 @@
-
-# Spec helper (must include first to track code coverage with SimpleCov)
-require File.expand_path('../support/spec_helper', __FILE__)
+require_relative 'support/spec_helper'
 
 require 'acpc_dealer'
 
-require "acpc_poker_types/match_state"
-require "acpc_poker_types/poker_action"
-require "acpc_poker_types/rank"
-require "acpc_poker_types/suit"
-require "acpc_poker_types/hand"
-require "acpc_poker_types/card"
-require 'acpc_poker_types/acpc_dealer_data/poker_match_data'
-
-describe AcpcPokerTypes::MatchState do
-  describe '#parse' do
-    describe 'raises an exception if ' do
-      describe 'the raw matchstate string' do
-        it 'is empty' do
-          test_match_state_initialization_error ""
-        end
-
-        it 'is not in the proper format' do
-          test_match_state_initialization_error "hello world"
-        end
-
-        it 'does not contain a position' do
-          test_match_state_initialization_error AcpcPokerTypes::MatchState::LABEL + "::0::AhKd"
-        end
-
-        it 'does not contain a hand number' do
-          test_match_state_initialization_error AcpcPokerTypes::MatchState::LABEL + ":0:::AsKc"
-        end
-
-        it 'does not contain cards' do
-          test_match_state_initialization_error AcpcPokerTypes::MatchState::LABEL + ":0:0::"
-        end
+require_relative "../lib/acpc_poker_types/match_state"
+require_relative "../lib/acpc_poker_types/poker_action"
+require_relative "../lib/acpc_poker_types/rank"
+require_relative "../lib/acpc_poker_types/suit"
+require_relative "../lib/acpc_poker_types/hand"
+require_relative "../lib/acpc_poker_types/card"
+require_relative "../lib/acpc_poker_types/game_definition"
+
+module MapWithIndex
+  refine Array do
+    def map_with_index
+      i = 0
+      map do |elem|
+        result = yield elem, i
+        i += 1
+        result
       end
     end
+  end
+end
+using MapWithIndex
+
+include AcpcPokerTypes
+
+describe MatchState do
+  describe '#parse' do
     it "parses every possible limit action" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":1:1:"
+      partial_match_state = MatchState::LABEL + ":1:1:"
       hole_cards = arbitrary_hole_card_hand
-      AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |action|
+      PokerAction::CANONICAL_ACTIONS.each do |action|
         match_state = partial_match_state + action + ":" + hole_cards.to_acpc
         patient = test_match_state_success match_state
         patient.last_action.to_s.must_equal action
       end
     end
     it "parses every possible hole card hand" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::"
+      partial_match_state = MatchState::LABEL + ":2:2::"
       for_every_hand do |hand|
         match_state = partial_match_state + hand.to_acpc + '|'
 
@@ -55,85 +46,85 @@ describe AcpcPokerTypes::MatchState do
       end
     end
     it "parses opponent hole card hands in a two player game where the user is not the dealer" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":0:2::"
+      partial_match_state = MatchState::LABEL + ":0:2::"
       for_every_hand do |hand|
         match_state = partial_match_state + arbitrary_hole_card_hand.to_acpc + '|' + hand.to_acpc
 
         patient = test_match_state_success match_state
 
-        (patient.list_of_opponents_hole_cards.map do |opponent_hand|
+        (patient.opponent_hands.map do |opponent_hand|
           opponent_hand.to_acpc
         end).must_equal [hand.to_acpc]
       end
     end
     it "parses opponent hole card hands in a two player game where the user is the dealer" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":1:2::"
+      partial_match_state = MatchState::LABEL + ":1:2::"
       for_every_hand do |hand|
         match_state = partial_match_state + hand.to_acpc + '|' + arbitrary_hole_card_hand.to_acpc
 
         patient = test_match_state_success match_state
 
-        (patient.list_of_opponents_hole_cards.map do |opponent_hand|
+        (patient.opponent_hands.map do |opponent_hand|
            opponent_hand.to_acpc
         end).must_equal [hand.to_acpc]
       end
     end
     it 'parses board cards properly for the flop' do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
+      partial_match_state = MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
 
-      board_cards = '/AhKdQc'
-      flop_match_state = partial_match_state + board_cards
+      community_cards = '/AhKdQc'
+      flop_match_state = partial_match_state + community_cards
 
-      patient = AcpcPokerTypes::MatchState.parse flop_match_state
+      patient = MatchState.parse flop_match_state
 
-      patient.board_cards.to_acpc.must_equal board_cards
+      patient.community_cards.to_acpc.must_equal community_cards
     end
     it 'parses board cards properly for the turn' do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
-      board_cards = '/AhKdQc/Jd'
-      turn_match_state = partial_match_state + board_cards
+      partial_match_state = MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
+      community_cards = '/AhKdQc/Jd'
+      turn_match_state = partial_match_state + community_cards
 
-      patient = AcpcPokerTypes::MatchState.parse turn_match_state
+      patient = MatchState.parse turn_match_state
 
-      patient.board_cards.to_acpc.must_equal board_cards
+      patient.community_cards.to_acpc.must_equal community_cards
     end
     it 'parses board cards properly for the river' do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
-      board_cards = '/AhKdQc/Jd/Th'
-      river_match_state = partial_match_state + board_cards
+      partial_match_state = MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
+      community_cards = '/AhKdQc/Jd/Th'
+      river_match_state = partial_match_state + community_cards
 
-      patient = AcpcPokerTypes::MatchState.parse river_match_state
+      patient = MatchState.parse river_match_state
 
-      patient.board_cards.to_acpc.must_equal board_cards
+      patient.community_cards.to_acpc.must_equal community_cards
     end
     it "parses a valid two player final match state" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":20:22:"
-      all_actions = AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.to_a.join ''
+      partial_match_state = MatchState::LABEL + ":20:22:"
+      all_actions = PokerAction::CANONICAL_ACTIONS.to_a.join ''
       betting = all_actions
       number_of_rounds = 100
       (number_of_rounds-1).times do
         betting += "/#{all_actions}"
       end
-      board_cards = arbitrary_roll_out number_of_rounds
+      community_cards = arbitrary_roll_out number_of_rounds
       hands = arbitrary_hole_card_hand.to_acpc + "|" + arbitrary_hole_card_hand.to_acpc
 
-      match_state = partial_match_state + betting + ":" + hands + board_cards
+      match_state = partial_match_state + betting + ":" + hands + community_cards
 
       test_match_state_success match_state
     end
     it "parses a valid three player final match state" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":20:22:"
-      all_actions = AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.to_a.join ''
+      partial_match_state = MatchState::LABEL + ":20:22:"
+      all_actions = PokerAction::CANONICAL_ACTIONS.to_a.join ''
       betting = all_actions
       number_of_rounds = 100
       (number_of_rounds-1).times do
         betting += "/#{all_actions}"
       end
-      board_cards = arbitrary_roll_out number_of_rounds
+      community_cards = arbitrary_roll_out number_of_rounds
       hands = arbitrary_hole_card_hand.to_s + "|" +
         arbitrary_hole_card_hand.to_s + "|" + arbitrary_hole_card_hand.to_s
 
-      match_state = partial_match_state + betting + ":" + hands + board_cards
+      match_state = partial_match_state + betting + ":" + hands + community_cards
 
       test_match_state_success match_state
     end
@@ -141,7 +132,7 @@ describe AcpcPokerTypes::MatchState do
 
   describe '#round' do
     it "properly reports the current round number" do
-      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":0:0:"
+      partial_match_state = MatchState::LABEL + ":0:0:"
       betting = ""
       hand = arbitrary_hole_card_hand
       100.times do |i|
@@ -166,7 +157,7 @@ describe AcpcPokerTypes::MatchState do
         end
         hands.push arbitrary_hole_card_hand.to_acpc
       end
-      match_state = AcpcPokerTypes::MatchState::LABEL + ':1:1::' + hands.join('|')
+      match_state = MatchState::LABEL + ':1:1::' + hands.join('|')
 
       patient = test_match_state_success match_state
       patient.number_of_players.must_equal expected_number_of_players
@@ -175,39 +166,39 @@ describe AcpcPokerTypes::MatchState do
 
   describe '#last_action, #round_in_which_last_action_taken, and #first_state_of_first_round' do
     it 'returns +nil+ if no previous action exists, or true in the case of #first_state_of_first_round' do
-      initial_match_state = "#{AcpcPokerTypes::MatchState::LABEL}:1:1::#{arbitrary_hole_card_hand}"
-      patient = AcpcPokerTypes::MatchState.parse initial_match_state
+      initial_match_state = "#{MatchState::LABEL}:1:1::#{arbitrary_hole_card_hand}"
+      patient = MatchState.parse initial_match_state
       patient.last_action.must_be_nil
       patient.round_in_which_last_action_taken.must_be_nil
       patient.first_state_of_first_round?.must_equal true
     end
     it 'works properly if a previous action exists' do
-      AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |first_action|
-        AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |second_action|
-          AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |third_action|
-            partial_match_state = "#{AcpcPokerTypes::MatchState::LABEL}:1:1:"
+      PokerAction::CANONICAL_ACTIONS.each do |first_action|
+        PokerAction::CANONICAL_ACTIONS.each do |second_action|
+          PokerAction::CANONICAL_ACTIONS.each do |third_action|
+            partial_match_state = "#{MatchState::LABEL}:1:1:"
 
             partial_match_state += first_action
             match_state = "#{partial_match_state}:#{arbitrary_hole_card_hand}"
 
-            patient = AcpcPokerTypes::MatchState.parse match_state
-            patient.last_action.must_equal AcpcPokerTypes::PokerAction.new(first_action)
+            patient = MatchState.parse match_state
+            patient.last_action.must_equal PokerAction.new(first_action)
             patient.round_in_which_last_action_taken.must_equal 0
             patient.first_state_of_first_round?.must_equal false
 
             partial_match_state += "#{second_action}/"
             match_state = "#{partial_match_state}:#{arbitrary_hole_card_hand}"
 
-            patient = AcpcPokerTypes::MatchState.parse match_state
-            patient.last_action.must_equal AcpcPokerTypes::PokerAction.new(second_action)
+            patient = MatchState.parse match_state
+            patient.last_action.must_equal PokerAction.new(second_action)
             patient.round_in_which_last_action_taken.must_equal 0
             patient.first_state_of_first_round?.must_equal false
 
             partial_match_state += third_action
             match_state = "#{partial_match_state}:#{arbitrary_hole_card_hand}"
 
-            patient = AcpcPokerTypes::MatchState.parse match_state
-            patient.last_action.must_equal AcpcPokerTypes::PokerAction.new(third_action)
+            patient = MatchState.parse match_state
+            patient.last_action.must_equal PokerAction.new(third_action)
             patient.round_in_which_last_action_taken.must_equal 1
             patient.first_state_of_first_round?.must_equal false
           end
@@ -215,84 +206,636 @@ describe AcpcPokerTypes::MatchState do
       end
     end
   end
-end
-describe "#receive_matchstate_string" do
-  it 'receives matchstate strings properly' do
-    @connection = mock 'Socket'
-    MatchLog.all.each do |log_description|
-      match = AcpcPokerTypes::AcpcDealerData::PokerMatchData.parse_files(
-        log_description.actions_file_path,
-        log_description.results_file_path,
-        log_description.player_names,
-        AcpcDealer::DEALER_DIRECTORY,
-        20
+  describe "#receive_matchstate_string" do
+    it 'receives matchstate strings properly' do
+      @connection = mock 'Socket'
+      MatchLog.all.each do |log_description|
+        match = AcpcDealerData::PokerMatchData.parse_files(
+          log_description.actions_file_path,
+          log_description.results_file_path,
+          log_description.player_names,
+          AcpcDealer::DEALER_DIRECTORY,
+          20
+        )
+        match.for_every_seat! do |seat|
+          match.for_every_hand! do
+            match.for_every_turn! do
+              @connection.expects(:gets).returns(match.current_hand.current_match_state.to_s)
+
+              MatchState.receive(@connection).must_equal match.current_hand.current_match_state
+            end
+          end
+        end
+      end
+    end
+  end
+  describe '#betting_sequence' do
+    it 'works' do
+      MatchState.parse(
+        "#{MatchState::LABEL}:0:0:crcc/ccc/rrfc:AhKs|"
+      ).betting_sequence.must_equal [
+        [
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::RAISE),
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::CALL)
+        ],
+        [
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::CALL),
+          PokerAction.new(PokerAction::CALL)
+        ],
+        [
+          PokerAction.new(PokerAction::RAISE),
+          PokerAction.new(PokerAction::RAISE),
+          PokerAction.new(PokerAction::FOLD),
+          PokerAction.new(PokerAction::CALL)
+        ]
+      ]
+    end
+  end
+  describe '#players_at_hand_start' do
+    it 'returns HandPlayers with states set at the beginning of the hand' do
+      stacks = [100, 200, 150]
+      blinds = [0, 10, 5]
+      num_players = 3
+      (0..num_players-1).each do |position|
+        hands = num_players.times.map { Hand.new }
+
+        hands[position] = arbitrary_hole_card_hand
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+"#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc:#{hand_string}"
+
+        MatchState.new(
+          match_state
+        ).players_at_hand_start(
+          stacks,
+          blinds
+        ).each_with_index do |player, pos|
+          player.initial_stack.must_equal stacks[pos]
+          player.ante.must_equal blinds[pos]
+          player.hand.must_equal hands[pos]
+        end
+      end
+    end
+  end
+  describe '#every_action' do
+    it 'yields every action, plus the round number, and the acting player position relative to the dealer' do
+      wager_size = 10
+      x_game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2, 2],
+        chip_stacks: [100, 200, 150],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*4,
+        number_of_ranks: 3
       )
-      match.for_every_seat! do |seat|
-        match.for_every_hand! do
-          match.for_every_turn! do
-            @connection.expects(:gets).returns(match.current_hand.current_match_state.to_s)
 
-            AcpcPokerTypes::MatchState.receive(@connection).must_equal match.current_hand.current_match_state
+      (0..x_game_def.number_of_players-1).each do |position|
+        x_actions = [
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: 5),
+            round: 0,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::RAISE, cost: wager_size + 10),
+            round: 0,
+            acting_player_position: 0
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 0,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 0,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 1,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 1,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 1,
+            acting_player_position: 0
+          },
+          {
+            action: PokerAction.new(PokerAction::BET, cost: wager_size),
+            round: 2,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::RAISE, cost: 2 * wager_size),
+            round: 2,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::FOLD),
+            round: 2,
+            acting_player_position: 0
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 2,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 3,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::BET, cost: wager_size),
+            round: 3,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 3,
+            acting_player_position: 1
+          }
+        ]
+        hands = x_game_def.number_of_players.times.map { Hand.new }
+
+        hands[position] = arbitrary_hole_card_hand
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+"#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc/crc:#{hand_string}"
+
+        MatchState.new(match_state).every_action(x_game_def) do |action, round, acting_player_position|
+          x_yields = x_actions.shift
+
+          action.must_equal x_yields[:action]
+          round.must_equal x_yields[:round]
+          acting_player_position.must_equal x_yields[:acting_player_position]
+        end
+      end
+    end
+  end
+  describe '#players' do
+    it 'return proper player states' do
+      wager_size = 10
+      x_game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2],
+        chip_stacks: [100, 200, 150],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*3,
+        number_of_ranks: 3
+      )
+      x_actions = [
+        [
+          [
+            PokerAction.new(PokerAction::RAISE, cost: wager_size + 10),
+          ],
+          [
+            PokerAction.new(PokerAction::CHECK)
+          ],
+          [
+            PokerAction.new(PokerAction::FOLD)
+          ]
+        ],
+        [
+          [
+            PokerAction.new(PokerAction::CALL, cost: wager_size)
+          ],
+          [
+            PokerAction.new(PokerAction::CHECK)
+          ],
+          [
+            PokerAction.new(PokerAction::BET, cost: wager_size),
+            PokerAction.new(PokerAction::CALL, cost: wager_size)
+          ]
+        ],
+        [
+          [
+            PokerAction.new(PokerAction::CALL, cost: 5),
+            PokerAction.new(PokerAction::CALL, cost: wager_size)
+          ],
+          [
+            PokerAction.new(PokerAction::CHECK)
+          ],
+          [
+            PokerAction.new(PokerAction::RAISE, cost: 2 * wager_size)
+          ]
+        ]
+      ]
+      x_contributions = x_actions.map_with_index do |actions_per_player, i|
+        actions_per_player.map do |actions_per_round|
+          actions_per_round.inject(0) { |sum, action| sum += action.cost }
+        end.unshift(x_game_def.blinds[i])
+      end
+      x_winnings = [0, 0, x_contributions.flatten.inject(:+)]
+      x_stacks = x_game_def.chip_stacks.map_with_index do |chip_stack, i|
+        chip_stack - x_contributions[i].inject(:+) + x_winnings[i]
+      end
+      (0..x_game_def.number_of_players-1).each do |position|
+        hands = x_game_def.number_of_players.times.map do |i|
+          Hand.from_acpc "Ac#{i+2}h"
+        end
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc:#{hand_string}"
+
+        MatchState.new(
+          match_state
+        ).players(x_game_def).each_with_index do |player, pos|
+          player.initial_stack.must_equal x_game_def.chip_stacks[pos]
+          player.ante.must_equal x_game_def.blinds[pos]
+          player.hand.must_equal hands[pos]
+          player.actions.must_equal x_actions[pos]
+          player.contributions.must_equal x_contributions[pos]
+          player.winnings.must_equal x_winnings[pos]
+          player.stack.must_equal x_stacks[pos]
+        end
+      end
+    end
+    describe 'distributes chips properly' do
+      it 'when there is a showdown and one winner' do
+        wager_size = 10
+        x_game_def = GameDefinition.new(
+          first_player_positions: [3, 2, 2, 2],
+          chip_stacks: [100, 200, 150],
+          blinds: [0, 10, 5],
+          raise_sizes: [wager_size]*4,
+          number_of_ranks: 3
+        )
+        x_total_contributions = [5 * 10, 5 * 10, 5 * 10]
+        x_winnings = [0, 0, x_total_contributions.inject(:+)]
+        x_stacks = x_game_def.chip_stacks.map_with_index do |chip_stack, i|
+          chip_stack - x_total_contributions[i] + x_winnings[i]
+        end
+
+        (0..x_game_def.number_of_players-1).each do |position|
+          hands = x_game_def.number_of_players.times.map do |i|
+            Hand.from_acpc "Ac#{i+2}h"
+          end
+
+          hand_string = hands.inject('') do |hand_string, hand|
+            hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+          end[0..-2]
+
+          match_state =
+            "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrcc/crcc:#{hand_string}"
+
+          MatchState.new(match_state).players(x_game_def).each_with_index do |player, i|
+            player.winnings.must_equal x_winnings[i]
+            player.stack.must_equal x_stacks[i]
+            player.total_contribution.must_equal x_total_contributions[i]
+          end
+        end
+      end
+      it 'when there is a tie' do
+        wager_size = 10
+        x_game_def = GameDefinition.new(
+          first_player_positions: [3, 2, 2, 2],
+          chip_stacks: [100, 200, 150],
+          blinds: [0, 10, 5],
+          raise_sizes: [wager_size]*4,
+          number_of_ranks: 3
+        )
+        x_total_contributions = [2 * 10, 5 * 10, 5 * 10]
+        x_winnings = [0, x_total_contributions.inject(:+)/2.0, x_total_contributions.inject(:+)/2.0]
+        x_stacks = x_game_def.chip_stacks.map_with_index do |chip_stack, i|
+          chip_stack - x_total_contributions[i] + x_winnings[i]
+        end
+
+        (0..x_game_def.number_of_players-1).each do |position|
+          hands = x_game_def.number_of_players.times.map do |i|
+            Hand.from_acpc "Ac2#{['s', 'h', 'd', 'c'][i%4]}"
+          end
+
+          hand_string = hands.inject('') do |hand_string, hand|
+            hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+          end[0..-2]
+
+          match_state =
+            "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc/crc:#{hand_string}"
+
+          MatchState.new(match_state).players(x_game_def).each_with_index do |player, i|
+            player.winnings.must_equal x_winnings[i]
+            player.stack.must_equal x_stacks[i]
+            player.total_contribution.must_equal x_total_contributions[i]
+          end
+        end
+      end
+      it 'when all other players have folded' do
+        wager_size = 10
+        x_game_def = GameDefinition.new(
+          first_player_positions: [3, 2, 2, 2],
+          chip_stacks: [100, 200, 150],
+          blinds: [0, 10, 5],
+          raise_sizes: [wager_size]*4,
+          number_of_ranks: 3
+        )
+        x_total_contributions = [2 * 10, 3 * 10, 4 * 10]
+        x_winnings = [0, 0, x_total_contributions.inject(:+)]
+        x_stacks = x_game_def.chip_stacks.map_with_index do |chip_stack, i|
+          chip_stack - x_total_contributions[i] + x_winnings[i]
+        end
+
+        (0..x_game_def.number_of_players-1).each do |position|
+          hands = x_game_def.number_of_players.times.map { Hand.new }
+
+          hands[position] = arbitrary_hole_card_hand
+
+          hand_string = hands.inject('') do |hand_string, hand|
+            hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+          end[0..-2]
+
+          match_state =
+            "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrff:#{hand_string}"
+
+          MatchState.new(match_state).players(x_game_def).each_with_index do |player, i|
+            player.winnings.must_equal x_winnings[i]
+            player.stack.must_equal x_stacks[i]
+            player.total_contribution.must_equal x_total_contributions[i]
           end
         end
       end
     end
+    describe '#pot' do
+      it 'works without side pots' do
+        wager_size = 10
+        x_game_def = GameDefinition.new(
+          first_player_positions: [3, 2, 2, 2],
+          chip_stacks: [100, 200, 150],
+          blinds: [0, 10, 5],
+          raise_sizes: [wager_size]*4,
+          number_of_ranks: 3
+        )
+        x_total_contributions = [2 * 10, 5 * 10, 5 * 10]
+
+        (0..x_game_def.number_of_players-1).each do |position|
+          hands = x_game_def.number_of_players.times.map do |i|
+            Hand.from_acpc "Ac2#{['s', 'h', 'd', 'c'][i%4]}"
+          end
+
+          hand_string = hands.inject('') do |hand_string, hand|
+            hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+          end[0..-2]
+
+          match_state =
+            "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc/crc:#{hand_string}"
+
+          MatchState.new(match_state).pot(x_game_def).must_equal x_total_contributions.inject(:+)
+        end
+      end
+    end
+  end
+  describe '#every_action' do
+    it 'yields every action, plus the round number, and the acting player position relative to the dealer' do
+      wager_size = 10
+      x_game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2, 2],
+        chip_stacks: [100, 200, 150],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*4,
+        number_of_ranks: 3
+      )
+
+      (0..x_game_def.number_of_players-1).each do |position|
+        x_actions = [
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: 5),
+            round: 0,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::RAISE, cost: wager_size + 10),
+            round: 0,
+            acting_player_position: 0
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 0,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 0,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 1,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 1,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 1,
+            acting_player_position: 0
+          },
+          {
+            action: PokerAction.new(PokerAction::BET, cost: wager_size),
+            round: 2,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::RAISE, cost: 2 * wager_size),
+            round: 2,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::FOLD),
+            round: 2,
+            acting_player_position: 0
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 2,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::CHECK),
+            round: 3,
+            acting_player_position: 1
+          },
+          {
+            action: PokerAction.new(PokerAction::BET, cost: wager_size),
+            round: 3,
+            acting_player_position: 2
+          },
+          {
+            action: PokerAction.new(PokerAction::CALL, cost: wager_size),
+            round: 3,
+            acting_player_position: 1
+          }
+        ]
+        hands = x_game_def.number_of_players.times.map { Hand.new }
+
+        hands[position] = arbitrary_hole_card_hand
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+      "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc/crc:#{hand_string}"
+
+        MatchState.new(match_state).player_acting_sequence(x_game_def).must_equal(
+          [[2, 0, 1, 2], [1, 2, 0], [1, 2, 0, 1], [1, 2, 1]]
+        )
+      end
+    end
+  end
+  describe 'hand_ended?' do
+    it 'works when there is a showdown' do
+      wager_size = 10
+      x_game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2, 2],
+        chip_stacks: [100, 200, 150],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*4,
+        number_of_ranks: 3
+      )
+
+      (0..x_game_def.number_of_players-1).each do |position|
+        hands = x_game_def.number_of_players.times.map do |i|
+          Hand.from_acpc "Ac#{i+2}h"
+        end
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc/crc:#{hand_string}"
+
+        MatchState.new(match_state).hand_ended?(x_game_def).must_equal true
+      end
+    end
+    it 'works when there is not a showdown' do
+      wager_size = 10
+      x_game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2, 2],
+        chip_stacks: [100, 200, 150],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*4,
+        number_of_ranks: 3
+      )
+
+      (0..x_game_def.number_of_players-1).each do |position|
+        hands = x_game_def.number_of_players.times.map { Hand.new }
+
+        hands[position] = arbitrary_hole_card_hand
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrfc/cr:#{hand_string}"
+
+        MatchState.new(match_state).hand_ended?(x_game_def).must_equal false
+      end
+    end
+    it 'works when all other players have folded' do
+      wager_size = 10
+      x_game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2, 2],
+        chip_stacks: [100, 200, 150],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*4,
+        number_of_ranks: 3
+      )
+
+      (0..x_game_def.number_of_players-1).each do |position|
+        hands = x_game_def.number_of_players.times.map { Hand.new }
+
+        hands[position] = arbitrary_hole_card_hand
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        match_state =
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrff:#{hand_string}"
+
+        MatchState.new(match_state).hand_ended?(x_game_def).must_equal true
+      end
+    end
   end
 end
 
 def for_every_card
-  AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
-    AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
-      yield AcpcPokerTypes::Card.from_components(rank, suit)
+  Rank::DOMAIN.map do |rank, rank_properties|
+    Suit::DOMAIN.map do |suit, suit_properties|
+      yield Card.from_components(rank, suit)
     end
   end
 end
 def for_every_hand
   for_every_card do |first_card|
     for_every_card do |second_card|
-      yield AcpcPokerTypes::Hand.draw_cards(first_card, second_card)
+      yield Hand.draw_cards(first_card, second_card)
     end
   end
 end
 def test_match_state_initialization_error(incomplete_match_state)
-  ->{AcpcPokerTypes::MatchState.parse incomplete_match_state}.must_raise(AcpcPokerTypes::MatchState::IncompleteMatchState)
+  ->{MatchState.parse incomplete_match_state}.must_raise(MatchState::IncompleteMatchState)
 end
 def test_match_state_success(match_state)
-  patient = AcpcPokerTypes::MatchState.parse match_state
+  patient = MatchState.parse match_state
   patient.to_s.must_equal match_state
   patient
 end
 def arbitrary_flop
   flop = ""
   rank = 2
-  (AcpcPokerTypes::Suit::DOMAIN.values.map { |suit| suit[:acpc_character] }).each do |suit|
-    flop += rank.to_s + suit unless AcpcPokerTypes::Suit::DOMAIN[:clubs][:acpc_character] == suit
+  (Suit::DOMAIN.values.map { |suit| suit[:acpc_character] }).each do |suit|
+    flop += rank.to_s + suit unless Suit::DOMAIN[:clubs][:acpc_character] == suit
     rank += 1
   end
   flop
 end
 
 def arbitrary_roll_out(rounds)
-  board_cards = ""
+  community_cards = ""
   (1..rounds-1).each do |round|
-    board_cards += "/" + if round > 1
-      '2' + AcpcPokerTypes::Suit::DOMAIN[:spades][:acpc_character]
+    community_cards += "/" + if round > 1
+      '2' + Suit::DOMAIN[:spades][:acpc_character]
     else
       arbitrary_flop
     end
   end
 
-  board_cards
+  community_cards
 end
 
 # Construct an arbitrary hole card hand.
 #
-# @return [AcpcPokerTypes::Hand] An arbitrary hole card hand.
+# @return [Hand] An arbitrary hole card hand.
 def arbitrary_hole_card_hand
-  AcpcPokerTypes::Hand.from_acpc(
-    AcpcPokerTypes::Rank::DOMAIN[:two][:acpc_character] +
-    AcpcPokerTypes::Suit::DOMAIN[:spades][:acpc_character] +
-    AcpcPokerTypes::Rank::DOMAIN[:three][:acpc_character] +
-    AcpcPokerTypes::Suit::DOMAIN[:hearts][:acpc_character]
+  Hand.from_acpc(
+    Rank::DOMAIN[:two][:acpc_character] +
+    Suit::DOMAIN[:spades][:acpc_character] +
+    Rank::DOMAIN[:three][:acpc_character] +
+    Suit::DOMAIN[:hearts][:acpc_character]
   )
 end