acpc_poker_types 7.1.4 → 7.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab072498a35c8b53f0602dd0a49453b0f33ae6cd
-  data.tar.gz: 3cfc75533ff01304b4198c521e50deb79139007a
+  metadata.gz: 0f33148cb5695cca1690278ba5acc735404dc15f
+  data.tar.gz: 7007a378e311daa494788d1c5d2355b965ec00b9
 SHA512:
-  metadata.gz: 0366232bc2cab9bf7b26e5519f39163aee7ef1d81ef82b9f8f7ef0306a01e1b1aa2ccbe58a27737a2f6b4bcef762391430d12fba962c09c38e5bd293bfc6eef0
-  data.tar.gz: 1579a92a852dff1a767e8081838e6ff9814a9ea37dae4eefaa7ef3d175cf67dc94de6a5ce5680bc056ebaf53048210b3de0b84065a39be9653615eef9712fdfa
+  metadata.gz: 39b67ec1ac2532478e08cf4c26c8e51e990302b22b6c2826d428b4776ff0d6237b25463b11972044c566c108f449994cc0c447d6b4889809d7ca46ce0228c144
+  data.tar.gz: 2c2ccfc8eaba441ef3bc615005dd3f5c2d30cd69680eda6f0b071582706b6bec9be3aa572b5015e3951b2cdc2d1dd37a5f77327a1a715fb3d07511a30ca42be3

data/lib/acpc_poker_types/hand_player.rb

@@ -50,9 +50,16 @@ class HandPlayer
   end
 
   def contributions
-    @actions.map do |actions_per_round|
+    contribution_list = @actions.map do |actions_per_round|
       actions_per_round.inject(0) { |sum, action| sum += action.cost }
-    end.unshift @ante
+    end
+    if contribution_list.empty?
+      contribution_list << @ante
+    else
+      contribution_list[0] += @ante
+    end
+
+    contribution_list
   end
 
   def total_contribution
@@ -64,7 +71,7 @@ class HandPlayer
   # @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: round,
+    in_round: round,
     amount_to_call: ChipStack.new(0),
     wager_illegal: false
   )
@@ -72,12 +79,19 @@ class HandPlayer
     return l_actions if inactive?
 
     if amount_to_call.to_r > 0
-      l_actions << PokerAction.new(PokerAction::CALL, cost: amount_to_call) << PokerAction.new(PokerAction::FOLD)
+      l_actions << PokerAction.new(PokerAction::CALL, cost: amount_to_call)
+      l_actions << 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
+      l_actions << if (
+        (contributions.length > in_round) &&
+        (
+          contributions[in_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)

data/lib/acpc_poker_types/hand_player_group.rb

@@ -79,7 +79,7 @@ class HandPlayerGroup < DelegateClass(Array)
   # @return [Array<PokerAction>] The legal actions for the next player to act.
   def legal_actions(acting_player_position, round, max_num_wagers)
     @players[acting_player_position].legal_actions(
-      round: round,
+      in_round: round,
       amount_to_call: amount_to_call(acting_player_position),
       wager_illegal: num_wagers(round) >= max_num_wagers
     )

data/lib/acpc_poker_types/match_state.rb

@@ -364,7 +364,13 @@ class MatchState < DelegateClass(String)
         game_def.min_wagers[current_round]
       )
 
-      action = PokerAction.new(action.to_s, cost: cost) if cost > 0
+      action = 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
+      )
 
       adjust_min_wager!(action, acting_player_position)
 

data/lib/acpc_poker_types/poker_action.rb

@@ -78,10 +78,11 @@ class PokerAction < DelegateClass(String)
   end
 
   # @return [String] String representation of this action.
-  # @param pot_gained_chips [Boolean] Whether or not the pot had gained chips before this action. Defaults to true.
+  # @param pot_gained_chips [Boolean] Whether or not the pot had gained chips before this action.
+  # Defaults to +pot_gained_chips?+.
   # @param player_sees_wager [Boolean] Whether or not the player is reacting to a wager.
-  #   Defaults to the value of +pot_gained_chips+.
-  def to_s(pot_gained_chips: true, player_sees_wager: pot_gained_chips)
+  # Defaults to the value of +player_sees_wager?+.
+  def to_s(pot_gained_chips: pot_gained_chips?, player_sees_wager: player_sees_wager?)
     combine_action_and_modifier(
       if @action == FOLD
         @action
@@ -102,6 +103,30 @@ class PokerAction < DelegateClass(String)
 
   private
 
+  def pot_gained_chips?
+    if @action == FOLD || @action == RAISE || @action == CALL
+      true
+    elsif @action == CHECK
+      # Could be true or false, but doesn't matter for the purpose of
+      # printing a check properly
+      nil
+    else
+      false
+    end
+  end
+
+  def player_sees_wager?
+    if @action == FOLD || @action == CALL
+      true
+    elsif @action == RAISE
+      # Could be true or false, but doesn't matter for the purpose of
+      # printing a raise properly
+      nil
+    else
+      false
+    end
+  end
+
   def combine_action_and_modifier(action=@action, modifier=@modifier)
     "#{action}#{modifier}"
   end

data/lib/acpc_poker_types/version.rb

@@ -1,3 +1,3 @@
 module AcpcPokerTypes
-  VERSION = '7.1.4'
+  VERSION = '7.1.5'
 end

data/spec/hand_player_spec.rb

@@ -44,9 +44,9 @@ describe HandPlayer 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|
+        x_actions.each_with_index do |actions, in_round|
           actions.each do |action|
-            patient.append_action! PokerAction.new(action), round
+            patient.append_action! PokerAction.new(action), in_round
           end
         end
 
@@ -63,9 +63,9 @@ describe HandPlayer do
             PokerAction.new('c', cost: INITIAL_CHIP_STACK - ANTE)
           ]
         ]
-        x_actions.each_with_index do |actions, round|
+        x_actions.each_with_index do |actions, in_round|
           actions.each do |action|
-            patient.append_action!(action, round)
+            patient.append_action!(action, in_round)
           end
         end
 
@@ -74,9 +74,9 @@ describe HandPlayer do
     end
     it 'works' do
       x_actions = [['c', 'r100'], ['r200', 'c'], ['f']]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action! PokerAction.new(action), round
+          patient.append_action! PokerAction.new(action), in_round
         end
       end
 
@@ -86,9 +86,9 @@ describe HandPlayer do
   describe '#folded?' do
     it 'works' do
       x_actions = [['c', 'r100'], ['r200', 'c']]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action!(PokerAction.new(action), round).folded?.must_equal false
+          patient.append_action!(PokerAction.new(action), in_round).folded?.must_equal false
         end
       end
 
@@ -106,9 +106,9 @@ describe HandPlayer do
           PokerAction.new('r400')
         ]
       ]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action!(action, round).all_in?.must_equal false
+          patient.append_action!(action, in_round).all_in?.must_equal false
         end
       end
 
@@ -126,9 +126,9 @@ describe HandPlayer do
           PokerAction.new('r400')
         ]
       ]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action!(action, round).inactive?.must_equal false
+          patient.append_action!(action, in_round).inactive?.must_equal false
         end
       end
 
@@ -144,9 +144,9 @@ describe HandPlayer do
           PokerAction.new('r400')
         ]
       ]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action!(action, round).inactive?.must_equal false
+          patient.append_action!(action, in_round).inactive?.must_equal false
         end
       end
 
@@ -165,17 +165,18 @@ describe HandPlayer do
           PokerAction.new('c', cost: 0)
         ]
       ]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action!(action, round)
+          patient.append_action!(action, in_round)
         end
       end
 
-      patient.contributions.must_equal(
-        x_actions.map do |actions|
-          actions.inject(0) { |sum, action| sum += action.cost }
-        end.unshift(ANTE)
-      )
+      x_contributions = x_actions.map do |actions|
+        actions.inject(0) { |sum, action| sum += action.cost }
+      end
+      x_contributions[0] += ANTE
+
+      patient.contributions.must_equal(x_contributions)
     end
   end
   describe '#total_contribution' do
@@ -190,9 +191,9 @@ describe HandPlayer do
           PokerAction.new('c', cost: 0)
         ]
       ]
-      x_actions.each_with_index do |actions, round|
+      x_actions.each_with_index do |actions, in_round|
         actions.each do |action|
-          patient.append_action!(action, round)
+          patient.append_action!(action, in_round)
         end
       end
 
@@ -204,40 +205,40 @@ describe HandPlayer do
 
   describe '#legal_actions' do
     it 'works with fold' do
-      patient.legal_actions(round: 0, amount_to_call: 100).sort.must_equal [
+      patient.legal_actions(in_round: 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(round: 0, amount_to_call: 200).sort.must_equal [
+        .legal_actions(in_round: 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(round: 0).empty?.must_equal true
+        .legal_actions(in_round: 0).empty?.must_equal true
     end
     it 'works with all in' do
-      patient.legal_actions(round: 0).sort.must_equal [
+      patient.legal_actions(in_round: 0).sort.must_equal [
         PokerAction.new(PokerAction::CHECK),
-        PokerAction.new(PokerAction::BET, cost: INITIAL_CHIP_STACK - ANTE),
+        PokerAction.new(PokerAction::RAISE, cost: INITIAL_CHIP_STACK - ANTE),
       ].sort
       patient.append_action!(PokerAction.new('c', cost: 100))
-        .legal_actions(round: 0).sort.must_equal [
+        .legal_actions(in_round: 0).sort.must_equal [
           PokerAction.new(PokerAction::CHECK),
-          PokerAction.new(PokerAction::BET, cost: INITIAL_CHIP_STACK - (ANTE + 100)),
+          PokerAction.new(PokerAction::RAISE, cost: INITIAL_CHIP_STACK - (ANTE + 100)),
         ].sort
       patient.append_action!(PokerAction.new('c', cost: INITIAL_CHIP_STACK - (ANTE + 100)))
-        .legal_actions(round: 0).empty?.must_equal true
+        .legal_actions(in_round: 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(round: 0).sort.must_equal [
+        .legal_actions(in_round: 0).sort.must_equal [
           PokerAction.new(PokerAction::CHECK),
           PokerAction.new(PokerAction::RAISE, cost: INITIAL_CHIP_STACK - (ANTE + 100))
         ].sort
-      patient.legal_actions(round: 0, amount_to_call: INITIAL_CHIP_STACK - (ANTE + 100))
+      patient.legal_actions(in_round: 0, amount_to_call: INITIAL_CHIP_STACK - (ANTE + 100))
         .sort.must_equal [
           PokerAction.new(PokerAction::CALL),
           PokerAction.new(PokerAction::FOLD)
@@ -245,16 +246,16 @@ describe HandPlayer do
     end
     it 'works when no more raises are allowed' do
       patient.append_action!(PokerAction.new('c', cost: 100))
-        .legal_actions(round: 0, wager_illegal: true).must_equal [
+        .legal_actions(in_round: 0, wager_illegal: true).must_equal [
           PokerAction.new(PokerAction::CHECK)
         ]
-      patient.legal_actions(round: 0, amount_to_call: INITIAL_CHIP_STACK - (ANTE + 100))
+      patient.legal_actions(in_round: 0, amount_to_call: INITIAL_CHIP_STACK - (ANTE + 100))
         .sort.must_equal [
           PokerAction.new(PokerAction::CALL),
           PokerAction.new(PokerAction::FOLD)
         ].sort
     end
-    it 'works without round argument' do
+    it 'works without in_round argument' do
       patient.append_action!(PokerAction.new('c', cost: 100))
         .legal_actions(wager_illegal: true).must_equal [
           PokerAction.new(PokerAction::CHECK)

data/spec/match_state_spec.rb

@@ -479,9 +479,11 @@ describe MatchState do
         ]
       ]
       x_contributions = x_actions.map_with_index do |actions_per_player, i|
-        actions_per_player.map do |actions_per_round|
+        player_contribs = 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
+        player_contribs[0] += x_game_def.blinds[i]
+        player_contribs
       end
       x_winnings = [0, 0, x_contributions.flatten.inject(:+)]
       x_stacks = x_game_def.chip_stacks.map_with_index do |chip_stack, i|
@@ -897,6 +899,16 @@ describe MatchState do
         PokerAction.new(PokerAction::BET, cost: game_definition.min_wagers[1])
       ]
     end
+    it 'should work properly when a new round begins and the other players check' do
+      game_definition = GameDefinition.parse_file(AcpcDealer::GAME_DEFINITION_FILE_PATHS[2][:limit])
+
+      MatchState.parse("MATCHSTATE:1:0:cc/rrrrc/rrc/c:|2hQc/QhQsJs/2s/Kh").legal_actions(
+        game_definition
+      ).must_equal [
+        PokerAction.new(PokerAction::CHECK, cost: 0),
+        PokerAction.new(PokerAction::BET, cost: game_definition.min_wagers[3])
+      ]
+    end
   end
 end
 

data/spec/poker_action_spec.rb

@@ -64,22 +64,9 @@ describe AcpcPokerTypes::PokerAction do
     end
   end
   describe '#to_s' do
-    it "prints in the dealer's canonical representation by default" do
+    it "prints in the given format by default" do
       AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
-        AcpcPokerTypes::PokerAction.new(a).to_s.must_equal (
-          case a
-          when AcpcPokerTypes::PokerAction::BET
-            AcpcPokerTypes::PokerAction::RAISE
-          when AcpcPokerTypes::PokerAction::CALL
-            AcpcPokerTypes::PokerAction::CALL
-          when AcpcPokerTypes::PokerAction::CHECK
-            AcpcPokerTypes::PokerAction::CALL
-          when AcpcPokerTypes::PokerAction::FOLD
-            AcpcPokerTypes::PokerAction::FOLD
-          when AcpcPokerTypes::PokerAction::RAISE
-            AcpcPokerTypes::PokerAction::RAISE
-          end
-        )
+        AcpcPokerTypes::PokerAction.new(a).to_s.must_equal a
       end
     end
     it 'works properly when no chips have been added to the pot' do
@@ -89,7 +76,7 @@ describe AcpcPokerTypes::PokerAction do
           when AcpcPokerTypes::PokerAction::BET
             AcpcPokerTypes::PokerAction::BET
           when AcpcPokerTypes::PokerAction::CALL
-            AcpcPokerTypes::PokerAction::CHECK
+            AcpcPokerTypes::PokerAction::CALL
           when AcpcPokerTypes::PokerAction::CHECK
             AcpcPokerTypes::PokerAction::CHECK
           when AcpcPokerTypes::PokerAction::FOLD
@@ -105,7 +92,7 @@ describe AcpcPokerTypes::PokerAction do
         AcpcPokerTypes::PokerAction.new(a).to_s(player_sees_wager: false).must_equal (
           case a
           when AcpcPokerTypes::PokerAction::BET
-            AcpcPokerTypes::PokerAction::RAISE
+            AcpcPokerTypes::PokerAction::BET
           when AcpcPokerTypes::PokerAction::CALL
             AcpcPokerTypes::PokerAction::CHECK
           when AcpcPokerTypes::PokerAction::CHECK

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acpc_poker_types
 version: !ruby/object:Gem::Version
-  version: 7.1.4
+  version: 7.1.5
 platform: ruby
 authors:
 - Dustin Morrill