acpc_poker_types 5.0.3 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cb9cb8ff43820e44d0d424314ffa480a1a10e53
-  data.tar.gz: 48a0dde3388f6fe3c829fba78eab32764feedb85
+  metadata.gz: 3381e33e9879dcca0d128817498cb80ef96155f7
+  data.tar.gz: f1a3fd8a83746913f6a395d715fa5aaa1c085529
 SHA512:
-  metadata.gz: 238349c4a28a621eef03e9226baafb1275cb0258e627c088bdcfcce5a7a7ce7e4bb5b5d12a9f471b0c626824344f2f1c0e767c2c5fa8ca6217e79fe9c3c635ca
-  data.tar.gz: 9f8328b2e465f50a6a6bd2c71d36e83779f2b29404cb0f95d0b1b79dfacb34b76d771f684d86fc17c48e9c73fd32a09192fcb8da8a17a3966e3c1548e2fa4b9e
+  metadata.gz: 8cd00ac46a327928b2bee5e2a92c87001ff01f3d0e8afe9c3ab6792d4f72cc1651322fcd0dc485b2691286858461c2135015dd743c9cd439e96410a0da6d11b1
+  data.tar.gz: abee379aa7a779b73b344997bba3fb036852211493f3abcc72fb4fa528d2f2e1518bdd40cf2ce0cd81a16f6ac16e651dcc85c3488b7c4bd0a7b4e5d119defaaa

data/Rakefile

@@ -8,5 +8,5 @@ Rake::TestTask.new do |t|
   t.libs << "lib" << 'spec/support'
   t.test_files = FileList['spec/**/*_spec.rb']
   t.verbose = false
-  t.warning = false # pry-rescue has a lot of warnings
+  t.warning = false
 end

data/acpc_poker_types.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/dmorrill10/acpc_poker_types"
   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.license     = 'MIT'
 
   s.add_dependency 'process_runner', '~> 0.0'
   s.add_dependency 'acpc_dealer', '~> 2.0'
@@ -19,10 +20,10 @@ Gem::Specification.new do |s|
   s.test_files    = Dir.glob "spec/**/*"
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'turn', '~> 0.9'
-  s.add_development_dependency 'minitest', '~> 4.7'
+  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.rb

@@ -5,9 +5,9 @@ require "acpc_poker_types/card"
 require "acpc_poker_types/chip_stack"
 require "acpc_poker_types/game_definition"
 require "acpc_poker_types/hand"
+require 'acpc_poker_types/player_group'
 require "acpc_poker_types/match_state"
 require "acpc_poker_types/pile_of_cards"
-require "acpc_poker_types/player"
 require "acpc_poker_types/rank"
 require "acpc_poker_types/suit"
 require "acpc_poker_types/acpc_dealer_data"

data/lib/acpc_poker_types/acpc_dealer_data/hand_results.rb

@@ -14,7 +14,7 @@ module AcpcPokerTypes::AcpcDealerData
         players = $2.split '|'
 
         players.each_index.inject({}) do |player_results, j|
-           player_results[players[j].to_sym] = stack_changes[j].to_r
+           player_results[players[j].to_sym] = stack_changes[j].to_f
            player_results
         end
       else
@@ -31,7 +31,7 @@ module AcpcPokerTypes::AcpcDealerData
         players = $2.split '|'
 
         players.each_index.inject({}) do |player_results, j|
-           player_results[players[j].to_sym] = stack_changes[j].to_r
+           player_results[players[j].to_sym] = stack_changes[j].to_f
            player_results
         end
       else
@@ -58,9 +58,9 @@ module AcpcPokerTypes::AcpcDealerData
 
       @data = acpc_log_statements.inject([]) do |accumulating_data, log_line|
         if @match_def.nil?
-          @match_def =  AcpcPokerTypes::AcpcDealerData::MatchDefinition.parse(log_line, player_names, game_def_directory)
+          @match_def = AcpcPokerTypes::AcpcDealerData::MatchDefinition.parse(log_line, player_names, game_def_directory)
         else
-          parsed_message =  AcpcPokerTypes::AcpcDealerData::HandResults.parse_state(log_line)
+          parsed_message = AcpcPokerTypes::AcpcDealerData::HandResults.parse_state(log_line)
           if parsed_message
             # Yes, this causes one more result to be parsed than is saved as long as
             # the number of hands is less than the total number in the log, but this
@@ -68,7 +68,7 @@ module AcpcPokerTypes::AcpcDealerData
             break accumulating_data if accumulating_data.length == num_hands
             accumulating_data << parsed_message
           else
-            @final_score =  AcpcPokerTypes::AcpcDealerData::HandResults.parse_score(log_line) unless @final_score
+            @final_score = AcpcPokerTypes::AcpcDealerData::HandResults.parse_score(log_line) unless @final_score
           end
         end
 

data/lib/acpc_poker_types/acpc_dealer_data/poker_match_data.rb

@@ -1,6 +1,3 @@
-
-require 'acpc_poker_types/player'
-
 require 'celluloid/autostart'
 
 require 'acpc_poker_types/acpc_dealer_data/action_messages'
@@ -11,404 +8,374 @@ require 'acpc_poker_types/acpc_dealer_data/match_definition'
 require 'contextual_exceptions'
 using ContextualExceptions::ClassRefinement
 
-module AcpcPokerTypes::AcpcDealerData
-  class PokerMatchData
-
-    exceptions :match_definitions_do_not_match, :final_scores_do_not_match, :data_inconsistent, :names_do_not_match
-
-    attr_accessor(
-      # @returns [Array<Numeric>] Chip distribution at the end of the match
-      :chip_distribution,
-      # @returns [MatchDefinition] Game definition and match parameters
-      :match_def,
-      # @returns [Integer] Zero-index turn number within the hand
-      :hand_number,
-      # @returns [ AcpcPokerTypes::AcpcDealerData::HandData] Data from each hand
-      :data,
-      # @returns [Array<AcpcPokerTypes::>] AcpcPokerTypes:: information
-      :players,
-      # @returns [Integer] Seat of the active player
-      :seat
-    )
-
-    # @returns [ AcpcPokerTypes::AcpcDealerData::PokerMatchData]
-    def self.parse_files(
-      action_messages_file,
-      result_messages_file,
-      player_names,
-      dealer_directory,
-      num_hands=nil
-    )
-      parsed_action_messages = Celluloid::Future.new do
-         AcpcPokerTypes::AcpcDealerData::ActionMessages.parse_file(
-          action_messages_file,
-          player_names,
-          dealer_directory,
-          num_hands
-        )
-      end
-      parsed_hand_results = Celluloid::Future.new do
-         AcpcPokerTypes::AcpcDealerData::HandResults.parse_file(
-          result_messages_file,
-          player_names,
-          dealer_directory,
-          num_hands
-        )
-      end
-
-      new(
-        parsed_action_messages.value,
-        parsed_hand_results.value,
+module AcpcPokerTypes
+module AcpcDealerData
+
+class PokerMatchData
+  exceptions :match_definitions_do_not_match, :final_scores_do_not_match, :data_inconsistent, :names_do_not_match
+
+  Player = Struct.new(:name, :seat, :balance)
+
+  attr_accessor(
+    # @returns [Array<Numeric>] Chip distribution at the end of the match
+    :chip_distribution,
+    # @returns [MatchDefinition] Game definition and match parameters
+    :match_def,
+    # @returns [Integer] Zero-index turn number within the hand
+    :hand_number,
+    # @returns [AcpcDealerData::HandData] Data from each hand
+    :data,
+    # @returns [Array<AcpcDealerData::PokerMatchData::Player>]
+    :players,
+    # @returns [Integer] Seat of the active player
+    :seat
+  )
+
+  # @returns [AcpcDealerData::PokerMatchData]
+  def self.parse_files(
+    action_messages_file,
+    result_messages_file,
+    player_names,
+    dealer_directory,
+    num_hands=nil
+  )
+    parsed_action_messages = Celluloid::Future.new do
+       AcpcDealerData::ActionMessages.parse_file(
+        action_messages_file,
         player_names,
-        dealer_directory
+        dealer_directory,
+        num_hands
+      )
+    end
+    parsed_hand_results = Celluloid::Future.new do
+       AcpcDealerData::HandResults.parse_file(
+        result_messages_file,
+        player_names,
+        dealer_directory,
+        num_hands
       )
     end
 
-    # @returns [ AcpcPokerTypes::AcpcDealerData::PokerMatchData]
-    def self.parse(
-      action_messages,
-      result_messages,
+    new(
+      parsed_action_messages.value,
+      parsed_hand_results.value,
       player_names,
-      dealer_directory,
-      num_hands=nil
+      dealer_directory
     )
-      parsed_action_messages = Celluloid::Future.new do
-         AcpcPokerTypes::AcpcDealerData::ActionMessages.parse(
-          action_messages,
-          player_names,
-          dealer_directory,
-          num_hands
-        )
-      end
-      parsed_hand_results = Celluloid::Future.new do
-         AcpcPokerTypes::AcpcDealerData::HandResults.parse(
-          result_messages,
-          player_names,
-          dealer_directory,
-          num_hands
-        )
-      end
+  end
 
-      new(
-        parsed_action_messages.value,
-        parsed_hand_results.value,
+  # @returns [AcpcDealerData::PokerMatchData]
+  def self.parse(
+    action_messages,
+    result_messages,
+    player_names,
+    dealer_directory,
+    num_hands=nil
+  )
+    parsed_action_messages = Celluloid::Future.new do
+       AcpcDealerData::ActionMessages.parse(
+        action_messages,
+        player_names,
+        dealer_directory,
+        num_hands
+      )
+    end
+    parsed_hand_results = Celluloid::Future.new do
+       AcpcDealerData::HandResults.parse(
+        result_messages,
         player_names,
-        dealer_directory
+        dealer_directory,
+        num_hands
       )
     end
 
-    def initialize(
-      parsed_action_messages,
-      parsed_hand_results,
+    new(
+      parsed_action_messages.value,
+      parsed_hand_results.value,
       player_names,
       dealer_directory
     )
-      if (
-        parsed_action_messages.match_def.nil? ||
-        parsed_hand_results.match_def.nil? ||
-        parsed_action_messages.match_def != parsed_hand_results.match_def
-      )
-        raise MatchDefinitionsDoNotMatch
-      end
+  end
 
-      if parsed_action_messages.final_score != parsed_hand_results.final_score
-        raise FinalScoresDoNotMatch
-      end
+  def initialize(
+    parsed_action_messages,
+    parsed_hand_results,
+    player_names,
+    dealer_directory
+  )
+    if (
+      parsed_action_messages.match_def.nil? ||
+      parsed_hand_results.match_def.nil? ||
+      parsed_action_messages.match_def != parsed_hand_results.match_def
+    )
+      raise MatchDefinitionsDoNotMatch
+    end
 
-      @match_def = parsed_hand_results.match_def
+    if parsed_action_messages.final_score != parsed_hand_results.final_score
+      raise FinalScoresDoNotMatch
+    end
 
-      if parsed_hand_results.final_score
-        set_chip_distribution! parsed_hand_results.final_score
-      end
+    @match_def = parsed_hand_results.match_def
 
-      set_data! parsed_action_messages, parsed_hand_results
+    if parsed_hand_results.final_score
+      set_chip_distribution! parsed_hand_results.final_score
+    end
 
-      # Zero-indexed seat
-      @seat = 0
+    set_data! parsed_action_messages, parsed_hand_results
 
-      initialize_players!
-    end
+    # Zero-indexed seat
+    @seat = 0
 
-    def for_every_seat!
-      match_def.game_def.number_of_players.times do |seat|
-        @seat = seat
+    initialize_players!
+  end
 
-        initialize_players!
+  def for_every_seat!
+    match_def.game_def.number_of_players.times do |seat|
+      @seat = seat
 
-        yield seat
-      end
+      initialize_players!
 
-      self
+      yield seat
     end
 
-    def player(seat=@seat) @players[seat] end
+    self
+  end
 
-    def next_hand!
-      init_or_increment_hand_num!
-      provide_players_with_new_hand!
-      current_hand.start_hand! @seat
-    end
+  def player(seat=@seat) @players[seat] end
 
-    def end_match!
-      if @chip_distribution && @chip_distribution != @players.map { |p| p.chip_balance }
-        raise DataInconsistent, "chip distribution: #{@chip_distribution}, player balances: #{@players.map { |p| p.chip_balance }}"
-      end
+  def next_hand!
+    init_or_increment_hand_num!
+    current_hand.start_hand! @seat
 
-      @hand_number = nil
-      self
+    self
+  end
+
+  def end_hand!
+    @players.each do |plyr|
+      plyr.balance += hand_player(plyr).balance
     end
+    current_hand.end_hand!
 
-    def for_every_hand!
-      while @hand_number.nil? || (@hand_number < @data.length - 1) do
-        next_hand!
-        yield @hand_number
-        current_hand.end_hand!
-      end
+    self
+  end
 
-      end_match!
+  def end_match!
+    player_balances = @players.map { |plyr| plyr.balance }
+    if @chip_distribution && @chip_distribution != player_balances
+      raise DataInconsistent, "chip distribution: #{@chip_distribution}, player balances: #{player_balances}"
     end
 
-    def next_turn!
-      current_hand.next_turn!
+    @hand_number = nil
+    self
+  end
 
-      @players.each_with_index do |player, seat|
-        last_match_state = current_hand.last_match_state(seat)
-        match_state = current_hand.current_match_state(seat)
+  def hand_player_balances
+    return [0] * match_def.game_def.number_of_players unless current_hand && current_hand.current_match_state
 
-        if current_hand.last_action && player.seat == current_hand.last_action.seat
+    @players.map { |p| hand_player(p).balance }
+  end
 
-          player.take_action!(current_hand.last_action.action)
-        end
+  def hand_player(plyr = player)
+    return nil unless current_hand && current_hand.current_match_state
 
-        if (
-          player.active? &&
-          !match_state.first_state_of_first_round? &&
-          match_state.round > last_match_state.round
-        )
-          player.start_new_round!
-        end
-
-        if current_hand.final_turn?
-          player.take_winnings!(
-            current_hand.chip_distribution[seat] + @match_def.game_def.blinds[current_hand.current_match_state(seat).position_relative_to_dealer]
-          )
-        end
-      end
-      self
+    current_hand.current_match_state.players(match_def.game_def)[position_relative_to_dealer(plyr)]
+  end
+
+  def for_every_hand!
+    while @hand_number.nil? || (@hand_number < @data.length - 1) do
+      next_hand!
+      yield @hand_number
+      end_hand!
     end
 
-    def for_every_turn!
-      while current_hand.turn_number.nil? || (current_hand.turn_number < current_hand.data.length - 1) do
-        next_turn!
-        yield current_hand.turn_number
-      end
+    end_match!
+  end
 
-      self
-    end
+  def next_turn!
+    current_hand.next_turn!
 
-    def match_has_another_round?(current_round, turn_index, turns_taken)
-      new_round?(current_round, turn_index) ||
-      players_all_in?(current_round, turn_index, turns_taken)
+    @players.each_with_index do |player, seat|
+      last_match_state = current_hand.last_match_state(seat)
+      match_state = current_hand.current_match_state(seat)
     end
 
-    def hand_started?
-      @hand_number &&
-      current_hand.turn_number &&
-      current_hand.turn_number > 0
+    self
+  end
+
+  def for_every_turn!
+    while current_hand.turn_number.nil? || (current_hand.turn_number < current_hand.data.length - 1) do
+      next_turn!
+      yield current_hand.turn_number
     end
 
-    def player_acting_sequence
-      sequence = [[]]
+    self
+  end
 
-      return sequence unless hand_started?
+  def match_has_another_round?(current_round, turn_index, turns_taken)
+    new_round?(current_round, turn_index) ||
+    players_all_in?(current_round, turn_index, turns_taken)
+  end
 
-      turns_taken = current_hand.data[0..current_hand.turn_number-1]
-      turns_taken.each_with_index do |turn, turn_index|
-        next unless turn.action_message
+  def hand_started?
+    @hand_number &&
+    current_hand.turn_number &&
+    current_hand.turn_number > 0
+  end
 
-        sequence[turn.action_message.state.round] << turn.action_message.seat
-        if match_has_another_round?(sequence.length - 1, turn_index, turns_taken)
-          sequence << []
-        end
-      end
+  def player_acting_sequence
+    sequence = [[]]
 
-      sequence
-    end
+    return sequence unless hand_started?
 
-    def current_hand
-      if @hand_number then @data[@hand_number] else nil end
-    end
+    turns_taken = current_hand.data[0..current_hand.turn_number-1]
+    turns_taken.each_with_index do |turn, turn_index|
+      next unless turn.action_message
 
-    def final_hand?
-      if @hand_number then @hand_number >= @data.length - 1 else nil end
+      sequence[turn.action_message.state.round] << turn.action_message.seat
+      if match_has_another_round?(sequence.length - 1, turn_index, turns_taken)
+        sequence << []
+      end
     end
 
-    # @return [Array<ChipStack>] AcpcPokerTypes:: stacks.
-    def chip_stacks
-      @players.map { |player| player.chip_stack }
-    end
+    sequence
+  end
 
-    # return [Array<Integer>] Each player's current chip balance.
-    def chip_balances
-      @players.map { |player| player.chip_balance }
-    end
+  def current_hand
+    if @hand_number then @data[@hand_number] else nil end
+  end
 
-    # return [Array<Array<Integer>>] Each player's current chip contribution organized by round.
-    def chip_contributions
-      @players.map { |player| player.chip_contributions }
-    end
+  def final_hand?
+    if @hand_number then @hand_number >= @data.length - 1 else nil end
+  end
 
-    def opponents
-      @players.reject { |other_player| player == other_player }
-    end
-    def active_players
-      @players.select { |player_to_collect| player_to_collect.active? }
-    end
-    def non_folded_players
-      @players.reject { |player_to_reject| player_to_reject.folded? }
-    end
-    def opponents_cards_visible?
-      return false unless current_hand
+  # return [Array<Integer>] Each player's current chip balance.
+  def balances
+    @players.map { |player| player.balance }
+  end
 
-      current_hand.current_match_state.list_of_hole_card_hands.reject_empty_elements.length > 1
-    end
-    def player_with_dealer_button
-      return nil unless current_hand
+  def opponents_cards_visible?
+    return false unless current_hand
 
-      @players.find do |plr|
-        current_hand.current_match_state(plr.seat).position_relative_to_dealer == @players.length - 1
-      end
-    end
-    # @return [Hash<AcpcPokerTypes::, #to_i] Relation from player to the blind that player paid.
-    def player_blind_relation
-      return nil unless current_hand
+    current_hand.current_match_state.opponents_cards_visible?
+  end
+  def player_with_dealer_button
+    return nil unless current_hand
 
-      @players.inject({}) do |relation, plr|
-        relation[plr] = @match_def.game_def.blinds[current_hand.current_match_state(plr.seat).position_relative_to_dealer]
-        relation
-      end
+    @players.find do |plr|
+      position_relative_to_dealer(plr) == @players.length - 1
     end
+  end
 
-    # @todo Untested
-    # @return [String] player acting sequence as a string.
-    def player_acting_sequence_string
-      (player_acting_sequence.map { |per_round| per_round.join('') }).join('/')
-    end
-    def users_turn_to_act?
-      return false unless current_hand && current_hand.next_action
-      current_hand.next_action.seat == @seat
+  def position_relative_to_dealer(plyr = player)
+    return nil unless current_hand && current_hand.current_match_state(plyr.seat)
+
+    current_hand.current_match_state(plyr.seat).position_relative_to_dealer
+  end
+
+  # @todo Untested
+  # @return [String] player acting sequence as a string.
+  def player_acting_sequence_string
+    (player_acting_sequence.map { |per_round| per_round.join('') }).join('/')
+  end
+  def users_turn_to_act?
+    return false unless current_hand && current_hand.next_action
+    current_hand.next_action.seat == @seat
+  end
+  def betting_sequence
+    sequence = [[]]
+
+    if (
+      @hand_number.nil? ||
+      current_hand.turn_number.nil? ||
+      current_hand.turn_number < 1
+    )
+      return sequence
     end
-    def betting_sequence
-      sequence = [[]]
+
+    turns_taken = current_hand.data[0..current_hand.turn_number-1]
+    turns_taken.each_with_index do |turn, turn_index|
+      next unless turn.action_message
+
+      sequence[turn.action_message.state.round] << turn.action_message.action
 
       if (
-        @hand_number.nil? ||
-        current_hand.turn_number.nil? ||
-        current_hand.turn_number < 1
+        new_round?(sequence.length - 1 , turn_index) ||
+        players_all_in?(sequence.length - 1, turn_index, turns_taken)
       )
-        return sequence
+        sequence << []
       end
+    end
 
-      turns_taken = current_hand.data[0..current_hand.turn_number-1]
-      turns_taken.each_with_index do |turn, turn_index|
-        next unless turn.action_message
-
-        sequence[turn.action_message.state.round] << turn.action_message.action
+    sequence
+  end
+  def betting_sequence_string
+    (betting_sequence.map do |per_round|
+       (per_round.map{|action| action.to_acpc}).join('')
+    end).join('/')
+  end
 
-        if (
-          new_round?(sequence.length - 1 , turn_index) ||
-          players_all_in?(sequence.length - 1, turn_index, turns_taken)
-        )
-          sequence << []
-        end
-      end
+  protected
 
-      sequence
-    end
-    def betting_sequence_string
-      (betting_sequence.map do |per_round|
-         (per_round.map{|action| action.to_acpc}).join('')
-      end).join('/')
-    end
-    # @todo Test and implement this
-    # def min_wager
-    #   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.cost.to_i].max
-    # end
-
-    protected
-
-    def initialize_players!
-      @players = @match_def.player_names.length.times.map do |seat|
-        AcpcPokerTypes::Player.join_match(
-          @match_def.player_names[seat],
-          AcpcPokerTypes::Seat.new(seat, @match_def.player_names.length),
-          @match_def.game_def.chip_stacks[seat]
-        )
-      end
-      self
+  def initialize_players!
+    @players = @match_def.player_names.length.times.map do |seat|
+      Player.new(
+        @match_def.player_names[seat],
+        Seat.new(seat, @match_def.player_names.length),
+        0
+      )
     end
+    self
+  end
 
-    def set_chip_distribution!(final_score)
-      @chip_distribution = []
-      final_score.each do |player_name, amount|
-        begin
-          @chip_distribution[@match_def.player_names.index(player_name.to_s)] = amount
-        rescue TypeError => e
-          raise NamesDoNotMatch.with_context(
-            "Player name \"#{player_name.to_s}\" in match definition is not listed in final chip distribution",
-            e
-          )
-        end
+  def set_chip_distribution!(final_score)
+    @chip_distribution = []
+    final_score.each do |player_name, amount|
+      begin
+        @chip_distribution[@match_def.player_names.index(player_name.to_s)] = amount
+      rescue TypeError => e
+        raise NamesDoNotMatch.with_context(
+          "Player name \"#{player_name.to_s}\" in match definition is not listed in final chip distribution",
+          e
+        )
       end
-      self
     end
+    self
+  end
 
-    def set_data!(parsed_action_messages, parsed_hand_results)
-      @data = []
-      parsed_action_messages.data.zip(parsed_hand_results.data).each do |action_messages_by_hand, hand_result|
-        @data <<  AcpcPokerTypes::AcpcDealerData::HandData.new(
-          @match_def,
-          action_messages_by_hand,
-          hand_result
-        )
-      end
-      self
+  def set_data!(parsed_action_messages, parsed_hand_results)
+    @data = []
+    parsed_action_messages.data.zip(parsed_hand_results.data).each do |action_messages_by_hand, hand_result|
+      @data << AcpcDealerData::HandData.new(
+        @match_def,
+        action_messages_by_hand,
+        hand_result
+      )
     end
+    self
+  end
 
-    private
+  private
 
-    def players_all_in?(current_round, turn_index, turns_taken)
-      current_hand.data.length == turn_index + 2 &&
-      current_round < (@match_def.game_def.number_of_rounds - 1) &&
-      (turns_taken[0..turn_index].count do |t|
-        t.action_message.action.to_acpc_character == AcpcPokerTypes::PokerAction::FOLD
-      end) != @players.length - 1
-    end
-    def new_round?(current_round, turn_index)
-      current_hand.data.length > turn_index + 1 &&
-      current_hand.data[turn_index + 1].action_message &&
-      current_hand.data[turn_index + 1].action_message.state.round > current_round
-    end
-    def provide_players_with_new_hand!
-      @players.each_with_index do |player, seat|
-        player.start_new_hand!(
-          @match_def.game_def.blinds[current_hand.data.first.state_messages[seat].position_relative_to_dealer],
-          @match_def.game_def.chip_stacks[current_hand.data.first.state_messages[seat].position_relative_to_dealer],
-          current_hand.data.first.state_messages[seat].users_hole_cards
-        )
-      end
-      self
-    end
-    def init_or_increment_hand_num!
-      if @hand_number
-        @hand_number += 1
-      else
-        @hand_number = 0
-      end
-      self
+  def players_all_in?(current_round, turn_index, turns_taken)
+    current_hand.data.length == turn_index + 2 &&
+    current_round < (@match_def.game_def.number_of_rounds - 1) &&
+    (turns_taken[0..turn_index].count do |t|
+      t.action_message.action.to_acpc_character == PokerAction::FOLD
+    end) != @players.length - 1
+  end
+  def new_round?(current_round, turn_index)
+    current_hand.data.length > turn_index + 1 &&
+    current_hand.data[turn_index + 1].action_message &&
+    current_hand.data[turn_index + 1].action_message.state.round > current_round
+  end
+  def init_or_increment_hand_num!
+    if @hand_number
+      @hand_number += 1
+    else
+      @hand_number = 0
     end
+    self
   end
+end
+end
 end