acpc_poker_types 2.0.0 → 3.0.2

data/lib/acpc_poker_types/pile_of_cards.rb

@@ -1,9 +1,11 @@
 
 require 'hand_evaluator'
 
-class AcpcPokerTypes::PileOfCards < Array
-  # @return [Integer] The strength of the strongest poker hand that can be made from this pile of cards.
-  def to_poker_hand_strength
-    HandEvaluator.rank_hand map { |card| card.to_i }
+module AcpcPokerTypes
+  class PileOfCards < Array
+    # @return [Integer] The strength of the strongest poker hand that can be made from this pile of cards.
+    def to_poker_hand_strength
+      HandEvaluator.rank_hand map { |card| card.to_i }
+    end
   end
 end

data/lib/acpc_poker_types/player.rb

@@ -5,172 +5,177 @@ require 'acpc_poker_types/chip_stack'
 require 'acpc_poker_types/hand'
 
 # Class to model a player.
-class AcpcPokerTypes::Player
-  exceptions :incorrect_number_of_player_names
-
-  def self.create_players(player_names, game_def)
-    if game_def.number_of_players != player_names.length
-      raise(
-        IncorrectNumberOfPlayerNames,
-        "#{player_names.length} names for #{game_def.number_of_players} players"
-      )
-    end
-
-    game_def.number_of_players.times.inject([]) do |players, seat|
-      players << AcpcPokerTypes::Player.join_match(
-        player_names[seat],
-        seat,
-        AcpcPokerTypes::ChipStack.new(game_def.chip_stacks[seat])
-      )
+module AcpcPokerTypes
+  class Player
+    exceptions :incorrect_number_of_player_names
+
+    def self.create_players(player_names, game_def)
+      if game_def.number_of_players != player_names.length
+        raise(
+          IncorrectNumberOfPlayerNames,
+          "#{player_names.length} names for #{game_def.number_of_players} players"
+        )
+      end
+
+      game_def.number_of_players.times.inject([]) do |players, seat|
+        players << AcpcPokerTypes::Player.join_match(
+          player_names[seat],
+          seat,
+          AcpcPokerTypes::ChipStack.new(game_def.chip_stacks[seat])
+        )
+      end
     end
-  end
 
-  # @return [String] The name of this player.
-  attr_reader :name
+    # @return [String] The name of this player.
+    attr_reader :name
 
-  # @return [Integer] This player's seat.  This is a 0 indexed
-  #  number that represents the order that this player joined the dealer.
-  attr_reader :seat
+    # @return [Integer] This player's seat.  This is a 0 indexed
+    #  number that represents the order that this player joined the dealer.
+    attr_reader :seat
 
-  # @return [AcpcPokerTypes::ChipStack] This player's chip stack.
-  attr_reader :chip_stack
+    # @return [AcpcPokerTypes::ChipStack] This player's chip stack.
+    attr_reader :chip_stack
 
-  # @return [Array<AcpcPokerTypes::ChipStack>] This player's contribution to the pot in the
-  #  current hand, organized by round.
-  attr_reader :chip_contributions
+    # @return [Array<AcpcPokerTypes::ChipStack>] This player's contribution to the pot in the
+    #  current hand, organized by round.
+    attr_reader :chip_contributions
 
-  # @return [Integer] The amount this player has won or lost in the current
-  #  match.  During a hand, this is a projected amount assuming that this
-  #  player loses.  Positive amounts are winnings, negative amounts are losses.
-  attr_reader :chip_balance
+    # @return [Integer] The amount this player has won or lost in the current
+    #  match.  During a hand, this is a projected amount assuming that this
+    #  player loses.  Positive amounts are winnings, negative amounts are losses.
+    attr_reader :chip_balance
 
-  # @return [Hand] This player's hole cards or nil if this player is not
-  #  holding cards.
-  # @example (see MatchState#users_hole_cards)
-  attr_reader :hole_cards
+    # @return [Hand] This player's hole cards or nil if this player is not
+    #  holding cards.
+    # @example (see MatchState#users_hole_cards)
+    attr_reader :hole_cards
 
-  # @return [Array<Array<PokerAction>>] The list of actions this player has taken in
-  #  the current hand, separated by round.
-  attr_reader :actions_taken_this_hand
+    # @return [Array<Array<String>>] The list of actions this player has taken in
+    #  the current hand, separated by round.
+    attr_reader :actions_taken_this_hand
 
-  alias_new :join_match
+    alias_new :join_match
 
-  # @todo These comments don't work as expected
-  # @param [String] name This players name.
-  # @param [Integer] seat (see #seat)
-  # @param [#to_i] chip_stack (see #chip_stack)
-  def initialize(name, seat, chip_stack)
-    @name = name
-    @seat = seat
-    @chip_balance = 0
-    @chip_stack = chip_stack
-    @chip_contributions = [0]
+    # @todo These comments don't work as expected
+    # @param [String] name This players name.
+    # @param [Integer] seat (see #seat)
+    # @param [#to_i] chip_stack (see #chip_stack)
+    def initialize(name, seat, chip_stack)
+      @name = name
+      @seat = seat
+      @chip_balance = 0
+      @chip_stack = chip_stack
+      @chip_contributions = [0]
 
-    @actions_taken_this_hand = [[]]
-  end
+      @actions_taken_this_hand = [[]]
+    end
 
-  def ==(other)
-    equal_on_public_info?(other) &&
-    @hole_cards == other.hole_cards
-  end
+    def ==(other)
+      equal_on_public_info?(other) &&
+      @hole_cards == other.hole_cards
+    end
 
-  def equal_on_public_info?(other)
-    @name == other.name &&
-    @seat == other.seat &&
-    @chip_stack == other.chip_stack &&
-    @chip_contributions == other.chip_contributions &&
-    @chip_balance == other.chip_balance &&
-    @actions_taken_this_hand == other.actions_taken_this_hand
-  end
+    def equal_on_public_info?(other)
+      @name == other.name &&
+      @seat == other.seat &&
+      @chip_stack == other.chip_stack &&
+      @chip_contributions == other.chip_contributions &&
+      @chip_balance == other.chip_balance &&
+      @actions_taken_this_hand == other.actions_taken_this_hand
+    end
 
-  # @param [#to_i] blind_amount The blind amount for this player to pay.
-  # @param [#to_i] chip_stack (see #chip_stack)
-  # @param [Hand] hole_cards (see #hole_cards)
-  def start_new_hand!(blind=AcpcPokerTypes::ChipStack.new(0), chip_stack=@chip_stack, hole_cards=AcpcPokerTypes::Hand.new)
-    @chip_stack = chip_stack
-    @hole_cards = hole_cards
-    @actions_taken_this_hand = []
-    @chip_contributions = []
+    # @param [#to_i] blind_amount The blind amount for this player to pay.
+    # @param [#to_i] chip_stack (see #chip_stack)
+    # @param [Hand] hole_cards (see #hole_cards)
+    def start_new_hand!(blind=AcpcPokerTypes::ChipStack.new(0), chip_stack=@chip_stack, hole_cards=AcpcPokerTypes::Hand.new)
+      @chip_stack = chip_stack
+      @hole_cards = hole_cards
+      @actions_taken_this_hand = []
+      @chip_contributions = []
 
-    start_new_round!
+      start_new_round!
 
-    pay_blind! blind
-  end
+      pay_blind! blind
+    end
 
-  def start_new_round!
-    @actions_taken_this_hand << []
-    @chip_contributions << 0
+    def start_new_round!
+      @actions_taken_this_hand << []
+      @chip_contributions << 0
 
-    self
-  end
+      self
+    end
 
-  # @param [PokerAction] action The action to take.
-  def take_action!(action)
-    @actions_taken_this_hand.last << action
+    # @param [PokerAction] action The action to take.
+    # @param pot_gained_chips [Boolean] Whether or not the pot had gained chips before this action. Defaults to true.
+    # @param sees_wager [Boolean] Whether or not the player is reacting to a wager.
+    #   Defaults to the value of +pot_gained_chips+.
+    def take_action!(action, pot_gained_chips: true, sees_wager: pot_gained_chips)
+      @actions_taken_this_hand.last << action.to_s(pot_gained_chips: pot_gained_chips, player_sees_wager: sees_wager)
 
-    take_from_chip_stack! action.amount_to_put_in_pot
-  end
+      take_from_chip_stack! action.cost.to_r
+    end
 
-  # @return [Boolean] Reports whether or not this player has folded.
-  def folded?
-    @actions_taken_this_hand.any? do |actions|
-      actions.any? { |action| action.to_sym == :fold }
+    # @return [Boolean] Reports whether or not this player has folded.
+    def folded?
+      @actions_taken_this_hand.any? do |actions|
+        actions.any? { |action| action == AcpcPokerTypes::PokerAction::FOLD }
+      end
     end
-  end
 
-  # @return [Boolean] Reports whether or not this player is all-in.
-  def all_in?
-    0 == @chip_stack
-  end
+    # @return [Boolean] Reports whether or not this player is all-in.
+    def all_in?
+      0 == @chip_stack
+    end
 
-  # @return [Boolean] Whether or not this player is active (has not folded
-  #     or gone all-in). +true+ if this player is active, +false+ otherwise.
-  def active?
-    !(folded? || all_in?)
-  end
+    # @return [Boolean] Whether or not this player is active (has not folded
+    #     or gone all-in). +true+ if this player is active, +false+ otherwise.
+    def active?
+      !(folded? || all_in?)
+    end
 
-  # @return [Integer] The current round, zero indexed.
-  def round
-    @actions_taken_this_hand.length - 1
-  end
+    # @return [Integer] The current round, zero indexed.
+    def round
+      @actions_taken_this_hand.length - 1
+    end
 
-  # Adjusts this player's state when it takes chips from the pot.
-  # @param [Integer] chips The number of chips this player has won from the pot.
-  def take_winnings!(chips)
-    @chip_contributions << 0
+    # Adjusts this player's state when it takes chips from the pot.
+    # @param [Integer] chips The number of chips this player has won from the pot.
+    def take_winnings!(chips)
+      @chip_contributions << 0
 
-    add_to_stack! chips
-  end
+      add_to_stack! chips
+    end
 
-  def assign_cards!(hole_cards)
-    @hole_cards = hole_cards
+    def assign_cards!(hole_cards)
+      @hole_cards = hole_cards
 
-    self
-  end
+      self
+    end
 
-  private
+    private
 
-  # @param [#to_i] blind_amount The blind amount for this player to pay.
-  def pay_blind!(blind_amount)
-    take_from_chip_stack! blind_amount
-  end
+    # @param [#to_i] blind_amount The blind amount for this player to pay.
+    def pay_blind!(blind_amount)
+      take_from_chip_stack! blind_amount
+    end
 
-  def add_to_stack!(chips)
-    @chip_stack += chips
-    @chip_balance += chips.to_r
-    @chip_contributions[-1] -= chips.to_r
+    def add_to_stack!(chips)
+      @chip_stack += chips
+      @chip_balance += chips.to_r
+      @chip_contributions[-1] -= chips.to_r
 
-    self
-  end
+      self
+    end
 
-  # Take chips away from this player's chip stack.
-  # @param (see AcpcPokerTypes::ChipStack#-)
-  # @raise (see AcpcPokerTypes::ChipStack#-)
-  def take_from_chip_stack!(number_of_chips)
-    @chip_stack -= number_of_chips
-    @chip_balance -= number_of_chips.to_r
-    @chip_contributions[-1] += number_of_chips.to_r
+    # Take chips away from this player's chip stack.
+    # @param (see AcpcPokerTypes::ChipStack#-)
+    # @raise (see AcpcPokerTypes::ChipStack#-)
+    def take_from_chip_stack!(number_of_chips)
+      @chip_stack -= number_of_chips
+      @chip_balance -= number_of_chips.to_r
+      @chip_contributions[-1] += number_of_chips.to_r
 
-    self
+      self
+    end
   end
-end
+end

data/lib/acpc_poker_types/poker_action.rb

@@ -4,118 +4,108 @@ require 'dmorrill10-utils/class'
 
 require 'acpc_poker_types/chip_stack'
 
-class AcpcPokerTypes::PokerAction
+module AcpcPokerTypes
+  class PokerAction
+    exceptions :illegal_action, :illegal_modification
 
-  exceptions :illegal_action, :illegal_amount
+    BET = 'b'
+    CALL = 'c'
+    CHECK = 'k'
+    FOLD = 'f'
+    RAISE = 'r'
 
-  # @return The amount that the player taking this action needs to put in the pot.
-  #  Could be negative to imply the acting player takes chips from the pot.
-  attr_reader :amount_to_put_in_pot
+    ACTIONS = Set.new [BET, CALL, CHECK, FOLD, RAISE]
 
-  # @return A modifier for the action (i.e. a bet or raise size).
-  attr_reader :modifier
+    # @return [Set<String>] The set of legal ACPC action characters.
+    CANONICAL_ACTIONS = Set.new [CALL, FOLD, RAISE]
 
-  # @return [Hash<Symbol, String>] Representations of legal actions.
-  LEGAL_ACTIONS = {bet: 'b', call: 'c', check: 'k', fold: 'f', raise: 'r'}
+    MODIFIABLE_ACTIONS = Set.new [BET, RAISE]
 
-  # @return [Set<Symbol>] The set of legal action symbols.
-  LEGAL_SYMBOLS = Set.new LEGAL_ACTIONS.keys
+    CONCATONATED_ACTIONS = ACTIONS.to_a.join
 
-  # @return [Set<String>] The set of legal action strings.
-  LEGAL_STRINGS = Set.new LEGAL_ACTIONS.keys.map { |action| action.to_s }
+    # @return [Rational] The amount that the player taking this action needs to put in the pot.
+    #  Could be negative to imply the acting player takes chips from the pot.
+    attr_reader :cost
 
-  # @return [Set<String>] The set of legal ACPC action characters.
-  LEGAL_ACPC_CHARACTERS = Set.new LEGAL_ACTIONS.values
+    # @return [String] A modifier for the action (i.e. a bet or raise size).
+    attr_reader :modifier
 
-  # @return [Hash<Symbol, String>] Representations of the legal ACPC action characters that may be accompanied by a modifier.
-  MODIFIABLE_ACTIONS = LEGAL_ACTIONS.select { |sym, char| 'r' == char || 'b' == char }
+    # @return [String] Action character
+    attr_reader :action
+    alias_method :to_acpc_character, :action
 
-  # @return [Hash] Map of general actions to more specific actions (e.g. call to check and raise to bet).
-  HIGH_RESOLUTION_ACTION_CONVERSION = {call: :check, raise: :bet, fold: :fold, check: :check, bet: :bet}
+    # @return [Boolean] Whether or not the pot has been added to this round before this action.
+    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+,
-  #  +:acting_player_sees_wager+, and +:amount_to_put_in_pot+.
-  # @raise IllegalAction
-  def initialize(action, context={})
-    (@symbol, @modifier) = validate_action(
-      action,
-      context[:modifier],
-      if context[:acting_player_sees_wager].nil?
-        true
-      else
-        context[:acting_player_sees_wager]
-      end
-    )
-    @amount_to_put_in_pot = context[:amount_to_put_in_pot].to_i
-  end
-
-  def ==(other_action)
-    to_sym == other_action.to_sym && to_s == other_action.to_s && to_acpc == other_action.to_acpc && @modifier == other_action.modifier
-  end
-
-  # @return [Boolean] +true+ if this action has a modifier, +false+ otherwise.
-  def has_modifier?
-    !@modifier.nil?
-  end
-
-  # @return [Symbol]
-  def to_sym
-    @symbol
-  end
-
-  # @return [String] String representation of this action.
-  def to_s
-    @symbol.to_s + @modifier.to_s
-  end
+    # @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+.
+    # @raise IllegalAction
+    def initialize(action, modifier: nil, cost: AcpcPokerTypes::ChipStack.new(0))
+      validate_action!(action, modifier)
+      @cost = cost
+    end
 
-  # @return [String] Full ACPC representation of this action.
-  def to_acpc
-    LEGAL_ACTIONS[@symbol] + @modifier.to_s
-  end
+    def ==(other_action)
+      to_s == other_action.to_s
+    end
 
-  # @return [String] ACPC character representation of this action.
-  def to_acpc_character
-    LEGAL_ACTIONS[@symbol]
-  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 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)
+      combine_action_and_modifier(
+        if @action == FOLD
+          @action
+        elsif @action == BET || @action == RAISE
+          if pot_gained_chips then RAISE else BET end
+        elsif @action == CALL || @action == CHECK
+          if player_sees_wager then CALL else CHECK end
+        end
+      )
+    end
 
-  private
+    alias_method :to_acpc, :to_s
 
-  def validate_action(action, modifier, acting_player_sees_wager)
-    if action.to_s.match(/^(#{(LEGAL_SYMBOLS.to_a.map{ |sym| sym.to_s }).join('|')})\s*(\d*)$/)
-    elsif action.to_s.match(/^(#{LEGAL_STRINGS.to_a.join('|')})\s*(\d*)$/)
-    elsif action.to_s.match(/^([#{LEGAL_ACPC_CHARACTERS.to_a.join('')}])\s*(\d*)$/)
-    else
-      raise(IllegalAction, action.to_s)
+    # @return [Boolean] +true+ if this action has a modifier, +false+ otherwise.
+    def has_modifier?
+      !@modifier.nil?
     end
-    action_type, in_place_modifier = $1, $2
 
-    raise(IllegalAmount, "in-place modifier: #{in_place_modifier}, explicit modifier: #{modifier}") if modifier && !in_place_modifier.empty?
+    private
 
-    modifier_to_use = if modifier
-      modifier
-    elsif !in_place_modifier.empty?
-      AcpcPokerTypes::ChipStack.new in_place_modifier.to_i
+    def combine_action_and_modifier(action=@action, modifier=@modifier)
+      action + modifier.to_s
     end
 
-    symbol_betting_type = LEGAL_ACTIONS.key(action_type) || action_type.to_sym
-    action_symbol = increase_resolution_of_action(symbol_betting_type, acting_player_sees_wager)
+    def validate_action!(action, given_modifier)
+      if action.to_s.match(/^([#{CONCATONATED_ACTIONS}])\s*(\d*)$/)
+      else
+        raise IllegalAction, action.to_s
+      end
+      @action, @modifier = $1, $2
+
+      if given_modifier && !@modifier.empty?
+        raise(
+          IllegalModification,
+          "in-place modifier: #{@modifier}, explicit modifier: #{given_modifier}"
+        )
+      end
 
-    raise(IllegalAction, 'Players may only fold if they are faced with a wager.') if :fold == symbol_betting_type && !acting_player_sees_wager
+      @modifier = if !@modifier.empty?
+        @modifier
+      elsif given_modifier
+        given_modifier
+      end
 
-    action_modifier = validate_modifier(modifier_to_use, action_symbol)
-    [action_symbol, action_modifier]
-  end
+      validate_modifier
 
-  def validate_modifier(modifier, action_symbol)
-    raise(IllegalAmount, modifier.to_s) unless modifier.nil? || MODIFIABLE_ACTIONS.keys.include?(action_symbol)
-    modifier
-  end
+      self
+    end
 
-  def increase_resolution_of_action(action, acting_player_sees_wager)
-    if acting_player_sees_wager
-      return action
+    def validate_modifier
+      raise(IllegalModification, "Illegal modifier: #{@modifier}") unless @modifier.nil? || AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.include?(@action)
     end
-    HIGH_RESOLUTION_ACTION_CONVERSION[action]
   end
-end
+end