acpc_poker_types 7.3.3 → 7.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9c6ac3927127814c7558bd788b5c025fe28633b
-  data.tar.gz: 4bce90a27299ff90392ac3def2e356ad685e7ba3
+  metadata.gz: e6d8abfb13245c11549049475c1580e317e5f7c9
+  data.tar.gz: fa482033db1d70882e3412f5a2a18ddd9e7616ca
 SHA512:
-  metadata.gz: ef396eb1cdf961db5a9f8df1b83e6094f74187f1fdb281b6d6d763d4accf4b184f6585022aa4efcdf708bd58ae10515c8719922e0a0b945b4e06fa149a658ad2
-  data.tar.gz: 4e99f766d5bc4ab88cdc7bf458f4a0921172ce06d16356542a24dcc076d17f9e2fdfd704bafcf0e5156b4677b98b91915a47ae604065ba0b31b851f7e5a20b61
+  metadata.gz: 4c8f50a9f133902e258aa222184177e1085bae0920925ec47eac2bd9571fb400c485c54942c727334421f3f1897d2dbd8e9cdd48234a235e650a6a0f91da8ccf
+  data.tar.gz: 2932fe75d0878488e32ec8a2795ff2240957932b5b33c88a8390e84e1854c757e365afb25782375d8fef61ff2cf676dd98e9d619fdfad3a616370c046c9a6203

data/acpc_poker_types.gemspec

@@ -23,7 +23,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'minitest', '~> 5.0.6'
   s.add_development_dependency 'mocha', '~> 0.13'
   s.add_development_dependency 'awesome_print', '~> 1.0'
-  s.add_development_dependency 'pry-rescue', '~> 1.0'
   s.add_development_dependency 'simplecov', '~> 0.7'
-  s.add_development_dependency 'method_profiler'
 end

data/lib/acpc_poker_types/hand_player.rb

@@ -22,7 +22,7 @@ class HandPlayer
 
   # @return [Hand] This player's hole cards or nil if this player is not
   # holding cards.
-  attr_reader :hand
+  attr_accessor :hand
 
   # @return [Array<PokerAction>] The actions this player has taken
   attr_reader :actions
@@ -42,6 +42,14 @@ class HandPlayer
     @winnings = ChipStack.new 0
   end
 
+  def ==(other_player)
+    @hand == other_player.hand &&
+    @initial_stack == other_player.initial_stack &&
+    @ante == other_player.ante &&
+    @actions == other_player.actions &&
+    @winnings == other_player.winnings
+  end
+
   def stack
     @initial_stack + balance
   end

data/lib/acpc_poker_types/match_state.rb

@@ -95,9 +95,11 @@ class MatchState < DelegateClass(String)
 
   # @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:]*)/
+  def initialize(raw_match_state, previous_state = nil, game_def = nil)
+    if (
+      %r{#{LABEL}:(\d+):(\d+):([^:]*):([^#{COMMUNITY_CARD_SEPARATOR}\s]+)#{COMMUNITY_CARD_SEPARATOR}*([^\s:]*)}.match(
+        raw_match_state
+      )
     )
       @position_relative_to_dealer = $1.to_i
       @hand_number = $2.to_i
@@ -105,7 +107,47 @@ class MatchState < DelegateClass(String)
       @hands_string = $4
       @community_cards_string = $5
     end
-    @min_wager_by = nil
+    @str = nil
+    @all_hands = nil
+    @community_cards = nil
+    @round = nil
+    @hand = nil
+    @opponent_hands = nil
+    @first_state_of_first_round = nil
+    @first_state_of_round = nil
+    @last_action = nil
+    @number_of_actions_this_round = nil
+    @number_of_actions_this_hand = nil
+    @round_in_which_last_action_taken = nil
+    @number_of_players = nil
+    @betting_sequence = nil
+    @hand_ended = nil
+    @opponents_cards_visible = nil
+    @pot = nil
+    @legal_actions = nil
+    if (
+      previous_state.nil? ||
+      game_def.nil? ||
+      last_action.nil? ||
+      previous_state.number_of_actions_this_hand != number_of_actions_this_hand - 1
+    )
+      @precise_betting_sequence = nil
+      @next_to_act = nil
+      @players = nil
+      @player_acting_sequence = nil
+      @min_wager_by = nil
+    else # Only process the one new action, bootstrapping from the given last state
+      @precise_betting_sequence = previous_state.betting_sequence(game_def).map { |per_round| per_round.dup }
+      @next_to_act = previous_state.next_to_act(game_def)
+      @players = previous_state.players(game_def).dup
+      @players.each_with_index { |player, i| player.hand = all_hands[i] }
+      @player_acting_sequence = previous_state.player_acting_sequence(game_def).map { |per_round| per_round.dup }
+      @min_wager_by = previous_state.min_wager_by(game_def)
+
+      process_action!(last_action, round_in_which_last_action_taken)
+      init_new_round!(game_def, round) if round != previous_state.round
+      distribute_chips!(game_def) if hand_ended?(game_def)
+    end
 
     super to_s
   end
@@ -306,7 +348,10 @@ class MatchState < DelegateClass(String)
   def hand_ended?(game_def)
     return @hand_ended unless @hand_ended.nil?
 
-    @hand_ended = reached_showdown? || players(game_def).count { |player| player.folded? } >= number_of_players - 1
+    @hand_ended = (
+      reached_showdown? ||
+      players(game_def).count { |player| player.folded? } >= number_of_players - 1
+    )
   end
 
   def reached_showdown?
@@ -325,7 +370,7 @@ class MatchState < DelegateClass(String)
 
   # @return [ChipStack] Minimum wager by.
   def min_wager_by(game_def)
-    every_action(game_def) unless @min_wager_by
+    every_action(game_def) if @min_wager_by.nil?
 
     @min_wager_by
   end
@@ -333,8 +378,9 @@ class MatchState < DelegateClass(String)
   # @return [Array<PokerAction>] The legal actions for the next player to act.
   def legal_actions(game_def)
     return [] unless next_to_act(game_def)
+    return @legal_actions unless @legal_actions.nil?
 
-    players(game_def).legal_actions(
+    @legal_actions = players(game_def).legal_actions(
       next_to_act(game_def),
       round,
       game_def,
@@ -345,50 +391,68 @@ class MatchState < DelegateClass(String)
   private
 
   def walk_over_betting_sequence!(game_def)
-    last_round = -1
-
     betting_sequence.each_with_index do |actions_per_round, current_round|
-      @min_wager_by = game_def.min_wagers[current_round]
-      @next_to_act = @players.position_of_first_active_player(
-        game_def.first_player_positions[current_round]
-      )
+      init_new_round!(game_def, current_round)
+
+      walk_over_actions!(actions_per_round, current_round)
+    end
+
+    self
+  end
+
+  def init_new_round!(game_def, current_round)
+    @min_wager_by = game_def.min_wagers[current_round]
+    @next_to_act = @players.position_of_first_active_player(
+      game_def.first_player_positions[current_round]
+    )
+    while @player_acting_sequence.length <= current_round
       @player_acting_sequence << []
       @precise_betting_sequence << []
-      last_round = current_round
-
-      walk_over_actions!(actions_per_round, game_def, last_round, current_round)
     end
 
     self
   end
 
-  def walk_over_actions!(actions_per_round, game_def, last_round, current_round)
+  def walk_over_actions!(actions_per_round, current_round)
     actions_per_round.each do |action|
-      @player_acting_sequence.last << @next_to_act
-      acting_player_position = @player_acting_sequence.last.last
+      process_action!(action, current_round)
 
-      @next_to_act = @players.next_to_act(@next_to_act)
+      yield(
+        @precise_betting_sequence[current_round].last,
+        current_round,
+        @player_acting_sequence[current_round].last
+      ) if block_given?
+    end
 
-      cost = @players.action_cost(
-        acting_player_position,
-        action,
-        game_def.min_wagers[current_round]
-      )
+    self
+  end
 
-      @precise_betting_sequence.last << PokerAction.new(
-        action.to_s(
-          pot_gained_chips: @players.inject(0) { |sum, player| sum += player.contributions[current_round].to_i } > 0,
-          player_sees_wager: @players.amount_to_call(acting_player_position) > 0
-        ),
-        cost: cost
-      )
+  def process_action!(action, current_round)
+    cost = @players.action_cost(
+      @next_to_act,
+      action,
+      @min_wager_by
+    )
+
+    @precise_betting_sequence[current_round] << PokerAction.new(
+      action.to_s(
+        pot_gained_chips: @players.inject(0) { |sum, player| sum += player.contributions[current_round].to_i } > 0,
+        player_sees_wager: @players.amount_to_call(@next_to_act) > 0
+      ),
+      cost: cost
+    )
 
-      adjust_min_wager!(@precise_betting_sequence.last.last, acting_player_position)
+    adjust_min_wager!(
+      @precise_betting_sequence[current_round].last,
+      @next_to_act
+    )
 
-      @players[acting_player_position].append_action!(@precise_betting_sequence.last.last, current_round)
+    @players[@next_to_act].append_action!(
+      @precise_betting_sequence[current_round].last, current_round
+    )
 
-      yield @precise_betting_sequence.last.last, current_round, acting_player_position if block_given?
-    end
+    @player_acting_sequence[current_round] << @next_to_act
+    @next_to_act = @players.next_to_act(@next_to_act)
 
     self
   end

data/lib/acpc_poker_types/players_at_the_table.rb

@@ -43,11 +43,12 @@ class PlayersAtTheTable
     end
     @game_def = game_def
     @seat = Seat.new(seat, game_def.number_of_players)
+    @match_state = nil
   end
 
   # @param [MatchState] match_state The next match state.
   def update!(match_state)
-    @match_state = match_state
+    @match_state = MatchState.new(match_state, @match_state, @game_def)
 
     update_players!
   end

data/lib/acpc_poker_types/version.rb

@@ -1,3 +1,3 @@
 module AcpcPokerTypes
-  VERSION = '7.3.3'
+  VERSION = '7.4.0'
 end

data/spec/match_state_spec.rb

@@ -136,6 +136,145 @@ describe MatchState do
     end
   end
 
+  describe '#new allows bootstrapping from previous states' do
+    it 'eg 1' do
+      wager_size = 10
+      game_def = GameDefinition.new(
+        first_player_positions: [3, 2, 2, 2],
+        chip_stacks: [500, 450, 550],
+        blinds: [0, 10, 5],
+        raise_sizes: [wager_size]*4,
+        number_of_ranks: 3,
+        number_of_hole_cards: 1
+      )
+
+      (0..game_def.number_of_players-1).each do |position|
+        hands = [ Hand.new ]*game_def.number_of_players
+        hands[position] = arbitrary_hole_card_hand
+
+        hand_string = hands.inject('') do |hand_string, hand|
+          hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+        end[0..-2]
+
+        last_state = MatchState.new(
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rr:#{hand_string}"
+        )
+
+        patient = MatchState.new(
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrf:#{hand_string}",
+          last_state,
+          game_def
+        )
+
+        x_state = MatchState.new(
+          "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rrf:#{hand_string}"
+        )
+
+        patient.betting_sequence(game_def).must_equal x_state.betting_sequence(game_def)
+        patient.players(game_def).must_equal x_state.players(game_def)
+        patient.next_to_act(game_def).must_equal x_state.next_to_act(game_def)
+        patient.legal_actions(game_def).must_equal x_state.legal_actions(game_def)
+        patient.player_acting_sequence(game_def).must_equal x_state.player_acting_sequence(game_def)
+        patient.hand_ended?(game_def).must_equal x_state.hand_ended?(game_def)
+        patient.pot(game_def).must_equal x_state.pot(game_def)
+        patient.min_wager_by(game_def).must_equal x_state.min_wager_by(game_def)
+      end
+    end
+    it 'eg 2' do
+      wager_size = 10
+      game_def = GameDefinition.new(
+        first_player_positions: [1, 0, 0, 0],
+        number_of_hole_cards: 2,
+        number_of_suits: 4,
+        number_of_ranks: 13,
+        raise_sizes: [wager_size]*4
+      )
+
+      last_state = MatchState.new(
+        "MATCHSTATE:0:0:c:5d5c|/8dAs8s"
+      )
+
+      patient = MatchState.new(
+        "MATCHSTATE:0:0:cc/:5d5c|/8dAs8s",
+        last_state,
+        game_def
+      )
+
+      x_state = MatchState.new("MATCHSTATE:0:0:cc/:5d5c|/8dAs8s")
+
+      patient.betting_sequence(game_def).must_equal x_state.betting_sequence(game_def)
+      patient.players(game_def).must_equal x_state.players(game_def)
+      patient.next_to_act(game_def).must_equal x_state.next_to_act(game_def)
+      patient.legal_actions(game_def).must_equal x_state.legal_actions(game_def)
+      patient.player_acting_sequence(game_def).must_equal x_state.player_acting_sequence(game_def)
+      patient.hand_ended?(game_def).must_equal x_state.hand_ended?(game_def)
+      patient.pot(game_def).must_equal x_state.pot(game_def)
+      patient.min_wager_by(game_def).must_equal x_state.min_wager_by(game_def)
+    end
+    it 'eg 3' do
+      wager_size = 10
+      game_def = GameDefinition.new(
+        first_player_positions: [1, 0, 0, 0],
+        number_of_hole_cards: 2,
+        number_of_suits: 4,
+        number_of_ranks: 13,
+        raise_sizes: [wager_size]*4
+      )
+
+      last_state = MatchState.new(
+        "MATCHSTATE:0:0:cc/:5d5c|/8dAs8s"
+      )
+
+      patient = MatchState.new(
+        "MATCHSTATE:0:0:cc/c:5d5c|/8dAs8s",
+        last_state,
+        game_def
+      )
+
+      x_state = MatchState.new("MATCHSTATE:0:0:cc/c:5d5c|/8dAs8s")
+
+      patient.betting_sequence(game_def).must_equal x_state.betting_sequence(game_def)
+      patient.players(game_def).must_equal x_state.players(game_def)
+      patient.next_to_act(game_def).must_equal x_state.next_to_act(game_def)
+      patient.legal_actions(game_def).must_equal x_state.legal_actions(game_def)
+      patient.player_acting_sequence(game_def).must_equal x_state.player_acting_sequence(game_def)
+      patient.hand_ended?(game_def).must_equal x_state.hand_ended?(game_def)
+      patient.pot(game_def).must_equal x_state.pot(game_def)
+      patient.min_wager_by(game_def).must_equal x_state.min_wager_by(game_def)
+    end
+    it 'distributes chips properly' do
+      wager_size = 10
+      game_def = GameDefinition.new(
+        first_player_positions: [1, 0, 0, 0],
+        number_of_hole_cards: 2,
+        number_of_suits: 4,
+        number_of_ranks: 13,
+        raise_sizes: [wager_size]*4
+      )
+
+      last_state = MatchState.new(
+        "MATCHSTATE:0:0:cc/r:5d5c|/8dAs8s"
+      )
+
+      patient = MatchState.new(
+        "MATCHSTATE:0:0:cc/rf:5d5c|2h3s/8dAs8s",
+        last_state,
+        game_def
+      )
+
+      x_state = MatchState.new("MATCHSTATE:0:0:cc/rf:5d5c|2h3s/8dAs8s")
+
+      patient.betting_sequence(game_def).must_equal x_state.betting_sequence(game_def)
+      patient.players(game_def).must_equal x_state.players(game_def)
+      patient.next_to_act(game_def).must_equal x_state.next_to_act(game_def)
+      patient.legal_actions(game_def).must_equal x_state.legal_actions(game_def)
+      patient.player_acting_sequence(game_def).must_equal x_state.player_acting_sequence(game_def)
+      patient.hand_ended?(game_def).must_equal x_state.hand_ended?(game_def)
+      patient.pot(game_def).must_equal x_state.pot(game_def)
+      patient.min_wager_by(game_def).must_equal x_state.min_wager_by(game_def)
+    end
+  end
+
   describe '#round' do
     it "properly reports the current round number" do
       partial_match_state = MatchState::LABEL + ":0:0:"
@@ -300,41 +439,103 @@ describe MatchState do
         )
       end
     end
-    it 'works with a game definition and provides more a precise result' do
-      MatchState.parse(
-        "#{MatchState::LABEL}:0:0:ccr20cc/r50fr100c/cc/cc:AhKs||"
-      ).betting_sequence(
-        GameDefinition.new(
+    describe 'works with a game definition to provide a more precise result' do
+      it 'eg 1' do
+        MatchState.parse(
+          "#{MatchState::LABEL}:0:0:ccr20cc/r50fr100c/cc/cc:AhKs||"
+        ).betting_sequence(
+          GameDefinition.new(
+            first_player_positions: [3, 2, 2, 2],
+            chip_stacks: [200, 200, 200],
+            blinds: [10, 0, 5],
+            raise_sizes: [10]*4,
+            number_of_ranks: 3
+          )
+        ).must_equal [
+          [
+            PokerAction.new(PokerAction::CALL),
+            PokerAction.new(PokerAction::CHECK),
+            PokerAction.new("#{PokerAction::RAISE}20"),
+            PokerAction.new(PokerAction::CALL),
+            PokerAction.new(PokerAction::CALL)
+          ],
+          [
+            PokerAction.new("#{PokerAction::BET}50"),
+            PokerAction.new(PokerAction::FOLD),
+            PokerAction.new("#{PokerAction::RAISE}100"),
+            PokerAction.new(PokerAction::CALL)
+
+          ],
+          [
+            PokerAction.new(PokerAction::CHECK),
+            PokerAction.new(PokerAction::CHECK)
+          ],
+          [
+            PokerAction.new(PokerAction::CHECK),
+            PokerAction.new(PokerAction::CHECK)
+          ]
+        ]
+      end
+      it 'eg 2' do
+        wager_size = 10
+        game_def = GameDefinition.new(
           first_player_positions: [3, 2, 2, 2],
-          chip_stacks: [200, 200, 200],
-          blinds: [10, 0, 5],
-          raise_sizes: [10]*4,
-          number_of_ranks: 3
+          chip_stacks: [500, 450, 550],
+          blinds: [0, 10, 5],
+          raise_sizes: [wager_size]*4,
+          number_of_ranks: 3,
+          number_of_hole_cards: 1
         )
-      ).must_equal [
-        [
-          PokerAction.new(PokerAction::CALL),
-          PokerAction.new(PokerAction::CHECK),
-          PokerAction.new("#{PokerAction::RAISE}20"),
-          PokerAction.new(PokerAction::CALL),
-          PokerAction.new(PokerAction::CALL)
-        ],
-        [
-          PokerAction.new("#{PokerAction::BET}50"),
-          PokerAction.new(PokerAction::FOLD),
-          PokerAction.new("#{PokerAction::RAISE}100"),
-          PokerAction.new(PokerAction::CALL)
 
-        ],
-        [
-          PokerAction.new(PokerAction::CHECK),
-          PokerAction.new(PokerAction::CHECK)
-        ],
-        [
-          PokerAction.new(PokerAction::CHECK),
-          PokerAction.new(PokerAction::CHECK)
-        ]
-      ]
+        (0..game_def.number_of_players-1).each do |position|
+          hands = [ Hand.new ]*game_def.number_of_players
+          hands[position] = arbitrary_hole_card_hand
+
+          hand_string = hands.inject('') do |hand_string, hand|
+            hand_string << "#{hand}#{MatchState::HAND_SEPARATOR}"
+          end[0..-2]
+
+          patient = MatchState.parse(
+            "#{MatchState::LABEL}:#{position}:0:crcc/ccc/rr:#{hand_string}"
+          )
+
+          patient.betting_sequence.must_equal [
+            [
+              PokerAction::CALL,
+              PokerAction::RAISE,
+              PokerAction::CALL,
+              PokerAction::CALL
+            ],
+            [
+              PokerAction::CALL,
+              PokerAction::CALL,
+              PokerAction::CALL
+            ],
+            [
+              PokerAction::RAISE,
+              PokerAction::RAISE
+            ]
+          ]
+
+          patient.betting_sequence(game_def).must_equal [
+            [
+              PokerAction::CALL,
+              PokerAction::RAISE,
+              PokerAction::CALL,
+              PokerAction::CALL
+            ],
+            [
+              PokerAction::CHECK,
+              PokerAction::CHECK,
+              PokerAction::CHECK
+            ],
+            [
+              PokerAction::BET,
+              PokerAction::RAISE
+            ]
+          ]
+        end
+      end
     end
   end
   describe '#players_at_hand_start' do