acpc_poker_types 2.0.0 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf1293107d6832328e4a3d10d28970b1aff99bd6
-  data.tar.gz: ab16e7afe3e9eb9a21856dab774ff7184123d2ac
+  metadata.gz: 4486cbb027fcef016f2c31f6cb33360b618a17e0
+  data.tar.gz: c06bc66f83a1609b25e7a8f30b577cb99c121454
 SHA512:
-  metadata.gz: 4632797276b35e397949d8fe5ef274b8e7c5dda915e4ffc1ec0aed08d6971e1743794d0001137c7a7ec685eee3d66f6f850cf8b2b59e1d5ae136f8a92c3282bc
-  data.tar.gz: afefe7d96e5f0a65adc415a3333ab89490de3b1224bc8c8e3e05891d17686fad12293e7b09c9453e42d750bbae3ce328da6b1058eb58e33b95cdd6857e921f02
+  metadata.gz: 7f10ec42bac803bd7a134d1fa3686ce45462fab47f56672050704c249fb48c3b4c0aa942ed911e8083805143992b0a39f41d3041e718aef984bcb8ca379794ce
+  data.tar.gz: fd175bdd332b8cdad9ad26baff8663364cfdadc8db1f65bc320864d5b409193c833c4045f21d21632e8f9b217423751ceaa86e92ffcbfd7a97cb67ab8c886c16

data/acpc_poker_types.gemspec

@@ -10,10 +10,10 @@ Gem::Specification.new do |s|
   s.summary     = %q{ACPC Poker Types}
   s.description = %q{Poker classes and constants that conform to the standards of the Annual Computer Poker Competition.}
 
-  s.add_dependency 'dmorrill10-utils'
+  s.add_dependency 'dmorrill10-utils', '~> 1.0'
   s.add_dependency 'acpc_dealer', '~> 0.0'
+  s.add_dependency 'celluloid', '~> 0.13'
 
-  s.add_development_dependency 'celluloid', '~> 0.13'
   s.add_development_dependency 'awesome_print'
   s.add_development_dependency 'minitest'
   s.add_development_dependency 'turn'

data/lib/acpc_poker_types/acpc_dealer_data/action_messages.rb

@@ -41,12 +41,10 @@ module AcpcPokerTypes::AcpcDealerData
       end
     end
 
-    CONCATONATED_ACTIONS = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join('')
-
     # @param [String] from_message FROM message (message from player)
     def self.parse_from_message(from_message)
       if from_message.strip.match(
-  /^FROM\s*(\d+)\s*at\s*[\d\.]+\s*(#{AcpcPokerTypes::MatchState::LABEL}\S+):([#{CONCATONATED_ACTIONS}]\s*\d*)$/
+  /^FROM\s*(\d+)\s*at\s*[\d\.]+\s*(#{AcpcPokerTypes::MatchState::LABEL}\S+):([#{AcpcPokerTypes::PokerAction::CONCATONATED_ACTIONS}]\s*\d*)$/
       )
         FromMessage.new(
           $1.to_i - 1,

data/lib/acpc_poker_types/acpc_dealer_data/poker_match_data.rb

@@ -330,7 +330,7 @@ module AcpcPokerTypes::AcpcDealerData
     #   return nil unless current_hand
 
     #   @match_def.game_def.min_wagers[current_hand.next_state.round]
-    #   ChipStack.new [@min_wager.to_i, action_with_context.amount_to_put_in_pot.to_i].max
+    #   ChipStack.new [@min_wager.to_i, action_with_context.cost.to_i].max
     # end
 
     protected

data/lib/acpc_poker_types/board_cards.rb

@@ -1,50 +1,51 @@
-
-require 'dmorrill10-utils/class'
-
 require 'acpc_poker_types/pile_of_cards'
 
 # List of community board cards.
-class AcpcPokerTypes::BoardCards < AcpcPokerTypes::PileOfCards
-
-  exceptions :too_many_board_cards
+module AcpcPokerTypes
+  class BoardCards < Array
+    def initialize(board_cards=[[]])
+      super(board_cards.map { |elem| AcpcPokerTypes::PileOfCards.new elem })
+    end
 
-  attr_reader :round
+    def round
+      self.length - 1
+    end
 
-  def initialize() @round = nil; next_round! end
+    alias_method :array_push, :push
 
-  def next_round!
-    @round = if @round then @round + 1 else 0 end
-    self[@round] = AcpcPokerTypes::PileOfCards.new
-    self
-  end
+    def next_round!
+      self.array_push AcpcPokerTypes::PileOfCards.new
+      self
+    end
 
-  def push(new_element)
-    self[@round].push new_element
-    self
-  end
+    def push(new_element)
+      self.last.push new_element
+      self
+    end
 
-  alias_method :<<, :push
+    alias_method :<<, :push
 
-  # @return [String] The string representation of these board cards.
-  def to_s
-    if all? { |pile_for_round| pile_for_round.empty? }
-      ''
-    else
-      '/' + (map { |pile_for_round| pile_for_round.join }).join('/')
+    # @return [String] The string representation of these board cards.
+    def to_s
+      if all? { |pile_for_round| pile_for_round.empty? }
+        ''
+      else
+        '/' + (map { |pile_for_round| pile_for_round.join }).join('/')
+      end
     end
-  end
 
-  # @see #to_s
-  alias_method :to_str, :to_s
-
-  # @return [String] The string representation of these board cards.
-  def to_acpc
-    if all? { |pile_for_round| pile_for_round.empty? }
-      ''
-    else
-      '/' + (map do |pile_for_round|
-        (pile_for_round.map { |card| card.to_acpc }).join
-      end).join('/')
+    # @see #to_s
+    alias_method :to_str, :to_s
+
+    # @return [String] The string representation of these board cards.
+    def to_acpc
+      if all? { |pile_for_round| pile_for_round.empty? }
+        ''
+      else
+        '/' + (map do |pile_for_round|
+          (pile_for_round.map { |card| card.to_acpc }).join
+        end).join('/')
+      end
     end
   end
-end
+end

data/lib/acpc_poker_types/card.rb

@@ -1,71 +1,57 @@
 
 require 'dmorrill10-utils'
 
-require File.expand_path('../rank', __FILE__)
-require File.expand_path('../suit', __FILE__)
-
-class AcpcPokerTypes::Card
-  exceptions :parse_error
-
-  # @param [String] acpc_string_of_cards A string of cards in ACPC format
-  # @return [Array<AcpcPokerTypes::Card>]
-  def self.cards(acpc_string_of_cards)
-    all_ranks = AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
-     rank_properties[:acpc_character]
-    end.join
-    all_suits = AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
-      suit_properties[:acpc_character]
-    end.join
-
-    acpc_string_of_cards.scan(/[#{all_ranks}][#{all_suits}]/).inject([]) do |pile, acpc_card|
-      pile.push << AcpcPokerTypes::Card.from_acpc(acpc_card)
+require 'acpc_poker_types/rank'
+require 'acpc_poker_types/suit'
+
+module AcpcPokerTypes
+  class Card
+    CONCATONATED_RANKS = (AcpcPokerTypes::Rank::DOMAIN.map { |rank, properties| properties[:acpc_character] }).join
+    CONCATONATED_SUITS = (AcpcPokerTypes::Suit::DOMAIN.map { |suit, properties| properties[:acpc_character] }).join
+    CONCATONATED_CARDS = CONCATONATED_RANKS + CONCATONATED_SUITS
+
+    # @param [String] acpc_string_of_cards A string of cards in ACPC format
+    # @return [Array<AcpcPokerTypes::Card>]
+    def self.cards(acpc_string_of_cards)
+      acpc_string_of_cards.scan(/[#{CONCATONATED_RANKS}][#{CONCATONATED_SUITS}]/).map do |acpc_card|
+        AcpcPokerTypes::Card.from_acpc(acpc_card)
+      end
     end
-  end
 
-  # @return [Integer] The numeric ACPC representation of the card.
-  def self.acpc_card_number(rank, suit)
-    rank.to_i * AcpcPokerTypes::Suit::DOMAIN.length + suit.to_i
-  end
-
-  attr_reader :rank, :suit
+    # @return [Integer] The numeric ACPC representation of the card.
+    def self.acpc_card_number(rank, suit)
+      rank.to_i * AcpcPokerTypes::Suit::DOMAIN.length + suit.to_i
+    end
 
-  # @return AcpcPokerTypes::Card
-  def self.from_acpc(acpc_card)
-    all_ranks = AcpcPokerTypes::Rank::DOMAIN.values.map do |card_rank|
-      card_rank[:acpc_character]
-    end.join
-    all_suits = AcpcPokerTypes::Suit::DOMAIN.values.map do |card_suit|
-      card_suit[:acpc_character]
-    end.join
+    attr_reader :rank, :suit
 
-    if acpc_card.match(/([#{all_ranks}])([#{all_suits}])/)
-      rank = $1
-      suit = $2
+    # @return AcpcPokerTypes::Card
+    def self.from_acpc(acpc_card)
+      rank = acpc_card[0]
+      suit = acpc_card[1]
 
       AcpcPokerTypes::Card.from_components rank, suit
-    else
-      raise ParseError, acpc_card
     end
-  end
 
-  alias_new :from_components
+    alias_new :from_components
 
-  def initialize(rank, suit)
-    @rank = AcpcPokerTypes::Rank.new rank
-    @suit = AcpcPokerTypes::Suit.new suit
-  end
+    def initialize(rank, suit)
+      @rank = AcpcPokerTypes::Rank.new rank
+      @suit = AcpcPokerTypes::Suit.new suit
+    end
 
-  def to_i
-    AcpcPokerTypes::Card.acpc_card_number(@rank, @suit)
-  end
+    def to_i
+      AcpcPokerTypes::Card.acpc_card_number(@rank, @suit)
+    end
 
-  def to_str
-    @rank.to_s + @suit.to_s
-  end
+    def to_str
+      @rank.to_s + @suit.to_s
+    end
 
-  alias_method :to_s, :to_str
+    alias_method :to_s, :to_str
 
-  def to_acpc
-    @rank.to_acpc + @suit.to_acpc
+    def to_acpc
+      @rank.to_acpc + @suit.to_acpc
+    end
   end
-end
+end

data/lib/acpc_poker_types/chip_stack.rb

@@ -1,38 +1,38 @@
-
 require 'dmorrill10-utils/class'
-
 require 'delegate'
 
-class AcpcPokerTypes::ChipStack < DelegateClass(Rational)
-  exceptions :illegal_number_of_chips
+module AcpcPokerTypes
+  class ChipStack < DelegateClass(Rational)
+    exceptions :illegal_number_of_chips
 
-  # @param [#to_i] number_of_chips The number of chips to be made into a stack.
-  # @raise (see #assert_valid_value)
-  def initialize(number_of_chips=0)
-    @value = number_of_chips.to_i
+    # @param [#to_i] number_of_chips The number of chips to be made into a stack.
+    # @raise (see #assert_valid_value)
+    def initialize(number_of_chips=0)
+      @value = number_of_chips.to_i
 
-    assert_valid_value
+      assert_valid_value
 
-    super @value
-  end
+      super @value
+    end
 
-  def receive!(number_of_chips)
-    @value += number_of_chips
+    def receive!(number_of_chips)
+      @value += number_of_chips
 
-    assert_valid_value
+      assert_valid_value
 
-    __setobj__ @value
+      __setobj__ @value
 
-    self
-  end
-  def give!(number_of_chips)
-    receive!(-number_of_chips)
-  end
+      self
+    end
+    def give!(number_of_chips)
+      receive!(-number_of_chips)
+    end
 
-  private
+    private
 
-  # @raise IllegalNumberOfChips
-  def assert_valid_value
-    raise IllegalNumberOfChips if @value < 0
+    # @raise IllegalNumberOfChips
+    def assert_valid_value
+      raise IllegalNumberOfChips if @value < 0
+    end
   end
-end
+end

data/lib/acpc_poker_types/game_definition.rb

@@ -8,332 +8,334 @@ require 'acpc_poker_types/suit'
 require 'acpc_poker_types/rank'
 
 # Class that parses and manages game definition information from a game definition file.
-class AcpcPokerTypes::GameDefinition
-  exceptions :parse_error
-
-  # @return [String] The string designating the betting type.
-  attr_reader :betting_type
-
-  # @return [Integer] The number of players.
-  attr_reader :number_of_players
-
-  # @return [Integer] The number of rounds.
-  attr_reader :number_of_rounds
-
-  # @return [Array] The number of board cards in each round.
-  # @example The usual Texas hold'em sequence would look like this:
-  #     number_of_board_cards == [0, 3, 1, 1]
-  attr_reader :number_of_board_cards
-
-  # @return [Array] The minimum wager in each round.
-  attr_reader :min_wagers
-
-  # @return [Array] The position relative to the dealer that is first to act
-  #     in each round, indexed from 0.
-  # @example The usual Texas hold'em sequence would look like this:
-  #     first_player_positions == [1, 0, 0, 0]
-  attr_reader :first_player_positions
-
-  # @return [Array] The maximum number of wagers in each round.
-  attr_reader :max_number_of_wagers
-
-  # @return [Array] The list containing the initial stack size for every player.
-  attr_reader :chip_stacks
-
-  # @return [Integer] The number of suits in the deck.
-  attr_reader :number_of_suits
-
-  # @return [Integer] The number of ranks in the deck.
-  attr_reader :number_of_ranks
-
-  # @return [Integer] The number of hole cards that each player is dealt.
-  attr_reader :number_of_hole_cards
-
-  # @return [Array] The list of blind sizes.
-  attr_reader :blinds
-
-  # @return [Integer] The maximum value of an eight bit unsigned integer (for consistency with the ACPC Dealer).
-  UINT8_MAX = 2**8 - 1
-
-  DEFAULT_MAX_NUMBER_OF_WAGERS = UINT8_MAX
-
-  # @return [Integer] The maximum value of a 32 bit signed integer (for consistency with the ACPC Dealer).
-  INT32_MAX = 2**31 - 1
-
-  DEFAULT_CHIP_STACK = INT32_MAX
-
-  # @return [Hash] Maximum game parameter values.
-  MIN_VALUES = {
-    :@number_of_rounds => 1,
-    :@number_of_players => 2,
-    :@number_of_hole_cards => 1,
-    :@number_of_suits => 1,
-    :@number_of_ranks => 2
-  }
-
-  MAX_VALUES = {
-    :@number_of_suits => AcpcPokerTypes::Suit::DOMAIN.length,
-    :@number_of_ranks => AcpcPokerTypes::Rank::DOMAIN.length
-  }
-
-  # @return [Hash] Betting types understood by this class.
-  BETTING_TYPES = {
-    :limit => 'limit',
-    :nolimit => 'nolimit'
-  }
-
-  DEFINITIONS = {
-    :@chip_stacks => 'stack',
-    :@number_of_players => 'numPlayers',
-    :@blinds => 'blind',
-    :@raise_sizes => 'raiseSize',
-    :@number_of_rounds => 'numRounds',
-    :@first_player_positions => 'firstPlayer',
-    :@max_number_of_wagers => 'maxRaises',
-    :@number_of_suits => 'numSuits',
-    :@number_of_ranks => 'numRanks',
-    :@number_of_hole_cards => 'numHoleCards',
-    :@number_of_board_cards => 'numBoardCards'
-  }
-
-  def self.default_first_player_positions(number_of_rounds)
-    number_of_rounds.to_i.times.inject([]) do |list, i|
-      list << 0
+module AcpcPokerTypes
+  class GameDefinition
+    exceptions :parse_error
+
+    # @return [String] The string designating the betting type.
+    attr_reader :betting_type
+
+    # @return [Integer] The number of players.
+    attr_reader :number_of_players
+
+    # @return [Integer] The number of rounds.
+    attr_reader :number_of_rounds
+
+    # @return [Array] The number of board cards in each round.
+    # @example The usual Texas hold'em sequence would look like this:
+    #     number_of_board_cards == [0, 3, 1, 1]
+    attr_reader :number_of_board_cards
+
+    # @return [Array] The minimum wager in each round.
+    attr_reader :min_wagers
+
+    # @return [Array] The position relative to the dealer that is first to act
+    #     in each round, indexed from 0.
+    # @example The usual Texas hold'em sequence would look like this:
+    #     first_player_positions == [1, 0, 0, 0]
+    attr_reader :first_player_positions
+
+    # @return [Array] The maximum number of wagers in each round.
+    attr_reader :max_number_of_wagers
+
+    # @return [Array] The list containing the initial stack size for every player.
+    attr_reader :chip_stacks
+
+    # @return [Integer] The number of suits in the deck.
+    attr_reader :number_of_suits
+
+    # @return [Integer] The number of ranks in the deck.
+    attr_reader :number_of_ranks
+
+    # @return [Integer] The number of hole cards that each player is dealt.
+    attr_reader :number_of_hole_cards
+
+    # @return [Array] The list of blind sizes.
+    attr_reader :blinds
+
+    # @return [Integer] The maximum value of an eight bit unsigned integer (for consistency with the ACPC Dealer).
+    UINT8_MAX = 2**8 - 1
+
+    DEFAULT_MAX_NUMBER_OF_WAGERS = UINT8_MAX
+
+    # @return [Integer] The maximum value of a 32 bit signed integer (for consistency with the ACPC Dealer).
+    INT32_MAX = 2**31 - 1
+
+    DEFAULT_CHIP_STACK = INT32_MAX
+
+    # @return [Hash] Maximum game parameter values.
+    MIN_VALUES = {
+      :@number_of_rounds => 1,
+      :@number_of_players => 2,
+      :@number_of_hole_cards => 1,
+      :@number_of_suits => 1,
+      :@number_of_ranks => 2
+    }
+
+    MAX_VALUES = {
+      :@number_of_suits => AcpcPokerTypes::Suit::DOMAIN.length,
+      :@number_of_ranks => AcpcPokerTypes::Rank::DOMAIN.length
+    }
+
+    # @return [Hash] Betting types understood by this class.
+    BETTING_TYPES = {
+      :limit => 'limit',
+      :nolimit => 'nolimit'
+    }
+
+    DEFINITIONS = {
+      :@chip_stacks => 'stack',
+      :@number_of_players => 'numPlayers',
+      :@blinds => 'blind',
+      :@raise_sizes => 'raiseSize',
+      :@number_of_rounds => 'numRounds',
+      :@first_player_positions => 'firstPlayer',
+      :@max_number_of_wagers => 'maxRaises',
+      :@number_of_suits => 'numSuits',
+      :@number_of_ranks => 'numRanks',
+      :@number_of_hole_cards => 'numHoleCards',
+      :@number_of_board_cards => 'numBoardCards'
+    }
+
+    def self.default_first_player_positions(number_of_rounds)
+      number_of_rounds.to_i.times.inject([]) do |list, i|
+        list << 0
+      end
     end
-  end
 
-  # @return [Array] The default maximum raise in each round.
-  def self.default_max_number_of_wagers(number_of_rounds)
-    number_of_rounds.to_i.times.inject([]) do |list, i|
-      list << DEFAULT_MAX_NUMBER_OF_WAGERS
+    # @return [Array] The default maximum raise in each round.
+    def self.default_max_number_of_wagers(number_of_rounds)
+      number_of_rounds.to_i.times.inject([]) do |list, i|
+        list << DEFAULT_MAX_NUMBER_OF_WAGERS
+      end
     end
-  end
 
-  # @param [Integer] number_of_players The number of players that require stacks.
-  # @return [Array<AcpcPokerTypes::ChipStack>] The default list of initial stacks for every player.
-  def self.default_chip_stacks(number_of_players)
-    number_of_players.to_i.times.inject([]) do |list, i|
-      list << AcpcPokerTypes::ChipStack.new(DEFAULT_CHIP_STACK)
+    # @param [Integer] number_of_players The number of players that require stacks.
+    # @return [Array<AcpcPokerTypes::ChipStack>] The default list of initial stacks for every player.
+    def self.default_chip_stacks(number_of_players)
+      number_of_players.to_i.times.inject([]) do |list, i|
+        list << AcpcPokerTypes::ChipStack.new(DEFAULT_CHIP_STACK)
+      end
     end
-  end
 
-  # @param [Array] array The array to flatten into a single element.
-  # @return +array+ if +array+ has more than one element, the single element in +array+ otherwise.
-  def self.flatten_if_single_element_array(array)
-    if 1 == array.length then array[0] else array end
-  end
+    # @param [Array] array The array to flatten into a single element.
+    # @return +array+ if +array+ has more than one element, the single element in +array+ otherwise.
+    def self.flatten_if_single_element_array(array)
+      if 1 == array.length then array[0] else array end
+    end
 
-  # Checks if the given line is a comment beginning with '#' or ';', or empty.
-  #
-  # @param [String] line
-  # @return [Boolean] True if +line+ is a comment or empty, false otherwise.
-  def self.line_is_comment_or_empty?(line)
-    line.nil? || line.match(/^\s*[#;]/) || line.empty?
-  end
+    # Checks if the given line is a comment beginning with '#' or ';', or empty.
+    #
+    # @param [String] line
+    # @return [Boolean] True if +line+ is a comment or empty, false otherwise.
+    def self.line_is_comment_or_empty?(line)
+      line.nil? || line.match(/^\s*[#;]/) || line.empty?
+    end
 
-  # Checks a given line from a game definition file for a game
-  # definition name and returns the given default value unless there is a match.
-  #
-  # @param [String, #match] line A line from a game definition file.
-  # @param [String] definition_name The name of the game definition that is
-  #     being checked for in +line+.
-  # @return The game definition value in +line+ if +line+ contains the game definition
-  #     referred to by +definition_name+, +nil+ otherwise.
-  def self.check_game_def_line_for_definition(line, definition_name)
-    if line.match(/^\s*#{definition_name}\s*=\s*([\d\s]+)/i)
-      values = $1.chomp.split(/\s+/)
-      (0..values.length-1).each do |i|
-        values[i] = values[i].to_i
+    # Checks a given line from a game definition file for a game
+    # definition name and returns the given default value unless there is a match.
+    #
+    # @param [String, #match] line A line from a game definition file.
+    # @param [String] definition_name The name of the game definition that is
+    #     being checked for in +line+.
+    # @return The game definition value in +line+ if +line+ contains the game definition
+    #     referred to by +definition_name+, +nil+ otherwise.
+    def self.check_game_def_line_for_definition(line, definition_name)
+      if line.match(/^\s*#{definition_name}\s*=\s*([\d\s]+)/i)
+        values = $1.chomp.split(/\s+/)
+        (0..values.length-1).each do |i|
+          values[i] = values[i].to_i
+        end
+        flatten_if_single_element_array values
       end
-      flatten_if_single_element_array values
     end
-  end
 
-  # Checks if the given line from a game definition file is informative or not
-  # (in which case the line is either: a comment beginning with '#', empty, or
-  # contains 'gamedef').
-  #
-  # @return [String] line The line to check.
-  # @return [Boolean] +true+ if the line is not informative, +false+ otherwise.
-  def self.game_def_line_not_informative?(line)
-    line_is_comment_or_empty?(line) || line.match(/\s*gamedef\s*/i)
-  end
+    # Checks if the given line from a game definition file is informative or not
+    # (in which case the line is either: a comment beginning with '#', empty, or
+    # contains 'gamedef').
+    #
+    # @return [String] line The line to check.
+    # @return [Boolean] +true+ if the line is not informative, +false+ otherwise.
+    def self.game_def_line_not_informative?(line)
+      line_is_comment_or_empty?(line) || line.match(/\s*gamedef\s*/i)
+    end
 
-  # @param [String] game_definition_file_name The name of the game definition file that this instance should parse.
-  def self.parse_file(game_definition_file_name)
-    File.open(game_definition_file_name, 'r') { |file|  parse file }
-  end
+    # @param [String] game_definition_file_name The name of the game definition file that this instance should parse.
+    def self.parse_file(game_definition_file_name)
+      File.open(game_definition_file_name, 'r') { |file|  parse file }
+    end
 
-  alias_new :parse
+    alias_new :parse
 
-  def initialize(definitions)
-    initialize_members!
-    parse_definitions! definitions
+    def initialize(definitions)
+      initialize_members!
+      parse_definitions! definitions
 
-    @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks(@number_of_players) if @chip_stacks.empty?
+      @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks(@number_of_players) if @chip_stacks.empty?
 
-    unless @first_player_positions.any? { |pos| pos <= 0 }
-      @first_player_positions.map! { |position| position - 1 }
-    end
-
-    sanity_check_game_definitions!
-  end
+      unless @first_player_positions.any? { |pos| pos <= 0 }
+        @first_player_positions.map! { |position| position - 1 }
+      end
 
-  def to_s
-    to_a.join("\n")
-  end
+      sanity_check_game_definitions!
+    end
 
-  alias_method :to_str, :to_s
-
-  def to_a
-    list_of_lines = []
-    list_of_lines << BETTING_TYPES[@betting_type] if @betting_type
-    list_of_lines << "stack = #{@chip_stacks.join(' ')}" unless @chip_stacks.empty?
-    list_of_lines << "numPlayers = #{@number_of_players}" if @number_of_players
-    list_of_lines << "blind = #{@blinds.join(' ')}" unless @blinds.empty?
-    list_of_lines << "raiseSize = #{min_wagers.join(' ')}" unless min_wagers.empty?
-    list_of_lines << "numRounds = #{@number_of_rounds}" if @number_of_rounds
-    list_of_lines << "firstPlayer = #{(@first_player_positions.map{|p| p + 1}).join(' ')}" unless @first_player_positions.empty?
-    list_of_lines << "maxRaises = #{@max_number_of_wagers.join(' ')}" unless @max_number_of_wagers.empty?
-    list_of_lines << "numSuits = #{@number_of_suits}" if @number_of_suits
-    list_of_lines << "numRanks = #{@number_of_ranks}" if @number_of_ranks
-    list_of_lines << "numHoleCards = #{@number_of_hole_cards}" if @number_of_hole_cards
-    list_of_lines << "numBoardCards = #{@number_of_board_cards.join(' ')}" unless @number_of_board_cards.empty?
-    list_of_lines
-  end
+    def to_s
+      to_a.join("\n")
+    end
 
-  def ==(other_game_definition)
-    Set.new(to_a) == Set.new(other_game_definition.to_a)
-  end
+    alias_method :to_str, :to_s
+
+    def to_a
+      list_of_lines = []
+      list_of_lines << BETTING_TYPES[@betting_type] if @betting_type
+      list_of_lines << "stack = #{@chip_stacks.join(' ')}" unless @chip_stacks.empty?
+      list_of_lines << "numPlayers = #{@number_of_players}" if @number_of_players
+      list_of_lines << "blind = #{@blinds.join(' ')}" unless @blinds.empty?
+      list_of_lines << "raiseSize = #{min_wagers.join(' ')}" unless min_wagers.empty?
+      list_of_lines << "numRounds = #{@number_of_rounds}" if @number_of_rounds
+      list_of_lines << "firstPlayer = #{(@first_player_positions.map{|p| p + 1}).join(' ')}" unless @first_player_positions.empty?
+      list_of_lines << "maxRaises = #{@max_number_of_wagers.join(' ')}" unless @max_number_of_wagers.empty?
+      list_of_lines << "numSuits = #{@number_of_suits}" if @number_of_suits
+      list_of_lines << "numRanks = #{@number_of_ranks}" if @number_of_ranks
+      list_of_lines << "numHoleCards = #{@number_of_hole_cards}" if @number_of_hole_cards
+      list_of_lines << "numBoardCards = #{@number_of_board_cards.join(' ')}" unless @number_of_board_cards.empty?
+      list_of_lines
+    end
 
-  def min_wagers
-    if @raise_sizes
-      @raise_sizes
-    else
-      @number_of_rounds.times.map { |i| @blinds.max }
+    def ==(other_game_definition)
+      Set.new(to_a) == Set.new(other_game_definition.to_a)
     end
-  end
 
-  private
-
-  def initialize_members!
-    @betting_type = BETTING_TYPES[:limit]
-    @number_of_players = MIN_VALUES[:@number_of_players]
-    @blinds = @number_of_players.times.inject([]) { |blinds, i| blinds << 0 }
-    @number_of_rounds = MIN_VALUES[:@number_of_rounds]
-    @number_of_board_cards = @number_of_rounds.times.inject([]) { |cards, i| cards << 0 }
-    @first_player_positions = AcpcPokerTypes::GameDefinition.default_first_player_positions @number_of_rounds
-    @max_number_of_wagers = AcpcPokerTypes::GameDefinition.default_max_number_of_wagers @number_of_rounds
-    @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks @number_of_players
-    @number_of_suits = MIN_VALUES[:@number_of_suits]
-    @number_of_ranks = MIN_VALUES[:@number_of_ranks]
-    @number_of_hole_cards = MIN_VALUES[:@number_of_hole_cards]
-
-    self
-  end
+    def min_wagers
+      if @raise_sizes
+        @raise_sizes
+      else
+        @number_of_rounds.times.map { |i| @blinds.max }
+      end
+    end
 
-  def set_defintion_if_present!(definition_symbol, line, definition_label_in_line)
-    new_definition = AcpcPokerTypes::GameDefinition.check_game_def_line_for_definition(
-      line,
-      definition_label_in_line
-    )
-    if new_definition
-      instance_variable_set(definition_symbol, new_definition)
-      true
-    else
-      false
+    private
+
+    def initialize_members!
+      @betting_type = BETTING_TYPES[:limit]
+      @number_of_players = MIN_VALUES[:@number_of_players]
+      @blinds = @number_of_players.times.inject([]) { |blinds, i| blinds << 0 }
+      @number_of_rounds = MIN_VALUES[:@number_of_rounds]
+      @number_of_board_cards = @number_of_rounds.times.inject([]) { |cards, i| cards << 0 }
+      @first_player_positions = AcpcPokerTypes::GameDefinition.default_first_player_positions @number_of_rounds
+      @max_number_of_wagers = AcpcPokerTypes::GameDefinition.default_max_number_of_wagers @number_of_rounds
+      @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks @number_of_players
+      @number_of_suits = MIN_VALUES[:@number_of_suits]
+      @number_of_ranks = MIN_VALUES[:@number_of_ranks]
+      @number_of_hole_cards = MIN_VALUES[:@number_of_hole_cards]
+
+      self
     end
-  end
 
-  def parse_definitions!(definitions)
-    definitions.each do |line|
-      break if line.match(/\bend\s*gamedef\b/i)
-      next if (
-        AcpcPokerTypes::GameDefinition.game_def_line_not_informative?(line) ||
-        BETTING_TYPES.any? do |type_and_name|
-          type = type_and_name.first
-          name = type_and_name[1]
-          if line.match(/\b#{name}\b/i)
-            @betting_type = type
-            true
-          else
-            false
-          end
-        end ||
-        DEFINITIONS.any? do |symbol, string|
-          set_defintion_if_present!(symbol, line, string)
-        end
+    def set_defintion_if_present!(definition_symbol, line, definition_label_in_line)
+      new_definition = AcpcPokerTypes::GameDefinition.check_game_def_line_for_definition(
+        line,
+        definition_label_in_line
       )
+      if new_definition
+        instance_variable_set(definition_symbol, new_definition)
+        true
+      else
+        false
+      end
     end
 
-    self
-  end
+    def parse_definitions!(definitions)
+      definitions.each do |line|
+        break if line.match(/\bend\s*gamedef\b/i)
+        next if (
+          AcpcPokerTypes::GameDefinition.game_def_line_not_informative?(line) ||
+          BETTING_TYPES.any? do |type_and_name|
+            type = type_and_name.first
+            name = type_and_name[1]
+            if line.match(/\b#{name}\b/i)
+              @betting_type = type
+              true
+            else
+              false
+            end
+          end ||
+          DEFINITIONS.any? do |symbol, string|
+            set_defintion_if_present!(symbol, line, string)
+          end
+        )
+      end
 
-  # @raise ParseError
-  def sanity_check_game_definitions!
-    adjust_definitions_if_necessary!
+      self
+    end
 
-    raise ParseError, "list of player stacks not specified" unless @chip_stacks
-    raise ParseError, "list of blinds not specified" unless @blinds
-    raise ParseError, "raise size in each round not specified" unless min_wagers
-    raise ParseError, "first player position in each round not specified" unless @first_player_positions
-    raise ParseError, "maximum raise in each round not specified" unless @max_number_of_wagers
-    raise ParseError, "number of board cards in each round not specified" unless @number_of_board_cards
+    # @raise ParseError
+    def sanity_check_game_definitions!
+      adjust_definitions_if_necessary!
+
+      raise ParseError, "list of player stacks not specified" unless @chip_stacks
+      raise ParseError, "list of blinds not specified" unless @blinds
+      raise ParseError, "raise size in each round not specified" unless min_wagers
+      raise ParseError, "first player position in each round not specified" unless @first_player_positions
+      raise ParseError, "maximum raise in each round not specified" unless @max_number_of_wagers
+      raise ParseError, "number of board cards in each round not specified" unless @number_of_board_cards
+
+      MIN_VALUES.each do |symbol, min_value|
+        if instance_variable_get(symbol) < min_value
+          raise(
+            ParseError,
+            "Invalid definition, #{DEFINITION[symbol]} must be greater than #{min_value} but was set to #{instance_variable_get(symbol)}"
+          )
+        end
+      end
 
-    MIN_VALUES.each do |symbol, min_value|
-      if instance_variable_get(symbol) < min_value
-        raise(
-          ParseError,
-          "Invalid definition, #{DEFINITION[symbol]} must be greater than #{min_value} but was set to #{instance_variable_get(symbol)}"
-        )
+      (0..@number_of_players-1).each do |i|
+        if @blinds[i] > @chip_stacks[i]
+          raise(
+            ParseError,
+            "Blind for player #{i+1} (#{@blinds[i]}) is greater than stack size (#{@chip_stacks[i]})"
+          )
+        end
       end
-    end
 
-    (0..@number_of_players-1).each do |i|
-      if @blinds[i] > @chip_stacks[i]
-        raise(
-          ParseError,
-          "Blind for player #{i+1} (#{@blinds[i]}) is greater than stack size (#{@chip_stacks[i]})"
-        )
+      @number_of_rounds.times do |i|
+        unless @first_player_positions[i].seat_in_bounds? @number_of_players
+          raise(
+            ParseError,
+            "Invalid first player #{@first_player_positions[i]} on round #{i+1}"
+          )
+        end
       end
-    end
 
-    @number_of_rounds.times do |i|
-      unless @first_player_positions[i].seat_in_bounds? @number_of_players
-        raise(
-          ParseError,
-          "Invalid first player #{@first_player_positions[i]} on round #{i+1}"
-        )
+      MAX_VALUES.each do |symbol, max_value|
+        if instance_variable_get(symbol) > max_value
+          raise(
+            ParseError,
+            "Invalid definition, #{DEFINITIONS[symbol]} must be less than #{max_value} but was set to #{instance_variable_get(symbol)}"
+          )
+        end
       end
-    end
 
-    MAX_VALUES.each do |symbol, max_value|
-      if instance_variable_get(symbol) > max_value
+      number_of_cards_required = (@number_of_hole_cards * @number_of_players) + @number_of_board_cards.sum
+
+      if number_of_cards_required > (@number_of_suits * @number_of_ranks)
         raise(
           ParseError,
-          "Invalid definition, #{DEFINITIONS[symbol]} must be less than #{max_value} but was set to #{instance_variable_get(symbol)}"
+          "Too many hole and board cards (#{number_of_cards_required}) for specified deck (#{(@number_of_suits * @number_of_ranks)})"
         )
       end
     end
 
-    number_of_cards_required = (@number_of_hole_cards * @number_of_players) + @number_of_board_cards.sum
-
-    if number_of_cards_required > (@number_of_suits * @number_of_ranks)
-      raise(
-        ParseError,
-        "Too many hole and board cards (#{number_of_cards_required}) for specified deck (#{(@number_of_suits * @number_of_ranks)})"
-      )
-    end
-  end
-
-  def adjust_definitions_if_necessary!
-    @number_of_players.times do |i|
-      @blinds << 0 unless @blinds.length > i
-      @chip_stacks << DEFAULT_CHIP_STACK unless @chip_stacks.length > i
-    end
-    @number_of_rounds.times do |i|
-      @first_player_positions << 0 unless @first_player_positions.length > i
-      @number_of_board_cards << 0 unless @number_of_board_cards.length > i
+    def adjust_definitions_if_necessary!
+      @number_of_players.times do |i|
+        @blinds << 0 unless @blinds.length > i
+        @chip_stacks << DEFAULT_CHIP_STACK unless @chip_stacks.length > i
+      end
+      @number_of_rounds.times do |i|
+        @first_player_positions << 0 unless @first_player_positions.length > i
+        @number_of_board_cards << 0 unless @number_of_board_cards.length > i
+      end
     end
   end
-end
+end