acpc_table_manager 0.0.1

data/lib/acpc_table_manager/match_view.rb

@@ -0,0 +1,203 @@
+require 'delegate'
+require 'timeout'
+
+require 'acpc_poker_types/match_state'
+require 'acpc_poker_types/game_definition'
+require 'acpc_poker_types/hand'
+
+require 'contextual_exceptions'
+using ContextualExceptions::ClassRefinement
+
+require_relative 'match'
+
+module AcpcTableManager
+class MatchView < SimpleDelegator
+  include AcpcPokerTypes
+
+  exceptions :unable_to_find_next_slice
+
+  attr_reader :match, :slice_index, :messages_to_display
+  attr_writer :messages_to_display
+
+  def self.chip_contributions_in_previous_rounds(player, round)
+    if round > 0
+      player['chip_contributions'][0..round-1].inject(:+)
+    else
+      0
+    end
+  end
+
+  DEFAULT_WAIT_FOR_SLICE_TIMEOUT = 0 # seconds
+
+  def initialize(match_id, slice_index = nil, load_previous_messages: false, timeout: DEFAULT_WAIT_FOR_SLICE_TIMEOUT)
+    @match = Match.find(match_id)
+    super @match
+
+    @messages_to_display = []
+
+    @slice_index = slice_index || @match.last_slice_viewed
+
+    raise StandardError.new("Illegal slice index: #{@slice_index}") unless @slice_index >= 0
+
+    unless @slice_index < @match.slices.length
+      if timeout > 0
+        Timeout.timeout(timeout, UnableToFindNextSlice) do
+          while @slice_index >= @match.slices.length do
+            sleep 0.5
+            @match = Match.find(match_id)
+          end
+        end
+        super @match
+      else
+        raise UnableToFindNextSlice
+      end
+    end
+
+    @messages_to_display = slice.messages
+
+    @loaded_previous_messages_ = false
+
+    load_previous_messages! if load_previous_messages
+  end
+  def user_contributions_in_previous_rounds
+    self.class.chip_contributions_in_previous_rounds(user, state.round)
+  end
+  def state() @state ||= MatchState.parse slice.state_string end
+  def slice() slices[@slice_index] end
+
+  # zero indexed
+  def users_seat() @users_seat ||= @match.seat - 1 end
+  def betting_sequence() slice.betting_sequence end
+  def pot_at_start_of_round() slice.pot_at_start_of_round end
+  def hand_ended?() slice.hand_ended? end
+  def match_ended?() slice.match_ended? end
+  def users_turn_to_act?() slice.users_turn_to_act? end
+  def legal_actions
+    slice.legal_actions.map do |action|
+      AcpcPokerTypes::PokerAction.new(action)
+    end
+  end
+
+  # @return [Array<Hash>] Player information ordered by seat.
+  # Each player hash should contain
+  # values for the following keys:
+  # 'name',
+  # 'seat'
+  # 'chip_stack'
+  # 'chip_contributions'
+  # 'chip_balance'
+  # 'hole_cards'
+  def players
+    return @players if @players
+
+    @players = slice.players
+  end
+  def user
+    @user ||= players[users_seat]
+  end
+  def opponents
+    @opponents ||= compute_opponents
+  end
+  def opponents_sorted_by_position_from_user
+    @opponents_sorted_by_position_from_user ||= opponents.sort_by do |opp|
+      Seat.new(
+        opp['seat'],
+        players.length
+      ).seats_from(
+        users_seat
+      )
+    end
+  end
+  def amount_for_next_player_to_call
+    @amount_for_next_player_to_call ||= slice.amount_to_call
+  end
+
+  # Over round
+  def chip_contribution_for_next_player_after_calling
+    @chip_contribution_for_next_player_after_calling ||= slice.chip_contribution_after_calling
+  end
+
+  # Over round
+  def minimum_wager_to
+    @minimum_wager_to ||= slice.minimum_wager_to
+  end
+
+  # Over round
+  def pot_after_call
+    @pot_after_call ||= slice.pot_after_call
+  end
+
+  # Over round
+  def pot_fraction_wager_to(fraction=1)
+    return 0 if hand_ended?
+
+    [
+      [
+        (
+          fraction * pot_after_call +
+          chip_contribution_for_next_player_after_calling
+        ),
+        minimum_wager_to
+      ].max,
+      all_in
+    ].min.floor
+  end
+
+  # Over round
+  def all_in
+    @all_in ||= slice.all_in
+  end
+
+  def betting_type_label
+    if @betting_type_label.nil?
+      @betting_type_label = if no_limit?
+        'nolimit'
+      else
+       'limit'
+      end
+    end
+
+    @betting_type_label
+  end
+
+  def load_previous_messages!(index = @slice_index)
+    @messages_to_display = slices[0...index].inject([]) do |messages, s|
+      messages += s.messages
+    end + @messages_to_display
+    @loaded_previous_messages_ = true
+    self
+  end
+
+  def loaded_previous_messages?
+    @loaded_previous_messages_
+  end
+
+  private
+
+  def compute_opponents
+    opp = players.dup
+    opp.delete_at(users_seat)
+    opp
+  end
+
+  def next_slice_without_updating_messages!(max_retries = 0)
+    @slice_index += 1
+    retries = 0
+    if @slice_index >= slices.length && max_retries < 1
+      @slice_index -= 1
+      raise UnableToFindNextSlice.new("Unable to find next match slice after #{retries} retries")
+    end
+    while @slice_index >= slices.length do
+      sleep(0.1)
+      @match = Match.find(@match.id)
+      __setobj__ @match
+      if retries >= max_retries
+        @slice_index -= 1
+        raise UnableToFindNextSlice.new("Unable to find next match slice after #{retries} retries")
+      end
+      retries += 1
+    end
+    self
+  end
+end
+end

data/lib/acpc_table_manager/monkey_patches.rb

@@ -0,0 +1,19 @@
+module AcpcTableManager
+  module MonkeyPatches
+    module ConversionToEnglish
+      def to_english
+        gsub '_', ' '
+      end
+    end
+    module StringToEnglishExtension
+      refine String do
+        include ConversionToEnglish
+      end
+    end
+    module SymbolToEnglishExtension
+      refine Symbol do
+        include ConversionToEnglish
+      end
+    end
+  end
+end

data/lib/acpc_table_manager/opponents.rb

@@ -0,0 +1,39 @@
+require 'timeout'
+require 'process_runner'
+require_relative 'config'
+require_relative 'simple_logging'
+
+module AcpcTableManager
+module Opponents
+  extend SimpleLogging
+
+  @logger = nil
+
+  # @return [Array<Integer>] PIDs of the opponents started
+  def self.start(*bot_start_commands)
+    @logger ||= ::AcpcTableManager.new_log 'opponents.log'
+    log __method__, num_opponents: bot_start_commands.length
+
+    bot_start_commands.map do |bot_start_command|
+      log(
+        __method__,
+        {
+          bot_start_command_parameters: bot_start_command,
+          command_to_be_run: bot_start_command.join(' ')
+        }
+      )
+      pid = Timeout::timeout(3) do
+        ProcessRunner.go(bot_start_command)
+      end
+      log(
+        __method__,
+        {
+          bot_started?: true,
+          pid: pid
+        }
+      )
+      pid
+    end
+  end
+end
+end

data/lib/acpc_table_manager/param_retrieval.rb

@@ -0,0 +1,32 @@
+require_relative 'monkey_patches'
+using AcpcTableManager::MonkeyPatches::StringToEnglishExtension
+
+require_relative 'config'
+
+module AcpcTableManager
+  module ParamRetrieval
+    protected
+
+    # @param [Hash<String, Object>] params Parameter hash
+    # @param parameter_key The key of the parameter to be retrieved.
+    # @raise
+    def retrieve_parameter_or_raise_exception(
+      params,
+      parameter_key
+    )
+      raise StandardError.new("nil params hash given") unless params
+      retrieved_param = params[parameter_key]
+      unless retrieved_param
+        raise StandardError.new("No #{parameter_key.to_english} provided")
+      end
+      retrieved_param
+    end
+
+    # @param [Hash<String, Object>] params Parameter hash
+    # @raise (see #param)
+    def retrieve_match_id_or_raise_exception(params)
+      AcpcTableManager.raise_if_uninitialized
+      retrieve_parameter_or_raise_exception params, AcpcTableManager.config.match_id_key
+    end
+  end
+end

data/lib/acpc_table_manager/proxy.rb

@@ -0,0 +1,276 @@
+require_relative 'config'
+require_relative 'match'
+require_relative 'match_slice'
+
+require 'acpc_poker_player_proxy'
+require 'acpc_poker_types'
+
+require_relative 'simple_logging'
+using SimpleLogging::MessageFormatting
+
+require 'contextual_exceptions'
+using ContextualExceptions::ClassRefinement
+
+module AcpcTableManager
+
+class Proxy
+  include SimpleLogging
+  include AcpcPokerTypes
+
+  exceptions :unable_to_create_match_slice
+
+  def self.start(match)
+    game_definition = GameDefinition.parse_file(match.game_definition_file_name)
+    match.game_def_hash = game_definition.to_h
+    match.save!
+
+    proxy = new(
+      match.id,
+      AcpcDealer::ConnectionInformation.new(
+        match.port_numbers[match.seat - 1],
+        ::AcpcTableManager.config.dealer_host
+      ),
+      match.seat - 1,
+      game_definition,
+      match.player_names.join(' '),
+      match.number_of_hands
+    ) do |players_at_the_table|
+      yield players_at_the_table if block_given?
+    end
+  end
+
+  # @todo Reduce the # of params
+  #
+  # @param [String] match_id The ID of the match in which this player is participating.
+  # @param [DealerInformation] dealer_information Information about the dealer to which this bot should connect.
+  # @param [GameDefinition, #to_s] game_definition A game definition; either a +GameDefinition+ or the name of the file containing a game definition.
+  # @param [String] player_names The names of the players in this match.
+  # @param [Integer] number_of_hands The number of hands in this match.
+  def initialize(
+    match_id,
+    dealer_information,
+    users_seat,
+    game_definition,
+    player_names='user p2',
+    number_of_hands=1
+  )
+    @logger = AcpcTableManager.new_log File.join('proxies', "#{match_id}.#{users_seat}.log")
+
+    log __method__, {
+      dealer_information: dealer_information,
+      users_seat: users_seat,
+      game_definition: game_definition,
+      player_names: player_names,
+      number_of_hands: number_of_hands
+    }
+
+    @match_id = match_id
+    @player_proxy = AcpcPokerPlayerProxy::PlayerProxy.new(
+      dealer_information,
+      game_definition,
+      users_seat
+    ) do |players_at_the_table|
+
+      if players_at_the_table.match_state
+        update_database! players_at_the_table
+
+        yield players_at_the_table if block_given?
+      else
+        log __method__, {before_first_match_state: true}
+      end
+    end
+  end
+
+  # Player action interface
+  # @see PlayerProxy#play!
+  def play!(action)
+    log __method__, action: action
+
+    action = PokerAction.new(action) unless action.is_a?(PokerAction)
+
+    @player_proxy.play! action do |players_at_the_table|
+      update_database! players_at_the_table
+
+      yield players_at_the_table if block_given?
+    end
+
+    log(
+      __method__,
+      {
+        users_turn_to_act?: @player_proxy.users_turn_to_act?,
+        match_ended?: @player_proxy.match_ended?
+      }
+    )
+
+    self
+  end
+
+  # @see PlayerProxy#match_ended?
+  def match_ended?
+    return false if @player_proxy.nil?
+
+    @match ||= Match.find(@match_id)
+
+    @player_proxy.match_ended? ||
+    (
+      @player_proxy.hand_ended? &&
+      @player_proxy.match_state.hand_number >= @match.number_of_hands - 1
+    )
+  end
+
+  private
+
+  def update_database!(players_at_the_table)
+    @match = Match.find(@match_id)
+
+    begin
+      MatchSlice.from_players_at_the_table!(
+        players_at_the_table,
+        match_ended?,
+        @match
+      )
+
+      new_slice = @match.slices.last
+      new_slice.messages = []
+
+      ms = players_at_the_table.match_state
+
+      log(
+        __method__,
+        {
+          first_state_of_first_round?: ms.first_state_of_first_round?
+        }
+      )
+
+      if ms.first_state_of_first_round?
+        new_slice.messages << hand_dealt_description(
+          @match.player_names,
+          ms.hand_number + 1,
+          players_at_the_table.game_def,
+          @match.number_of_hands
+        )
+      end
+
+      last_action = ms.betting_sequence(
+        players_at_the_table.game_def
+      ).flatten.last
+
+      log(
+        __method__,
+        {
+          last_action: last_action
+        }
+      )
+
+      if last_action
+        last_actor = @match.player_names[
+          @match.slices[-2].seat_next_to_act
+        ]
+
+        log(
+          __method__,
+          {
+            last_actor: last_actor
+          }
+        )
+
+        case last_action.to_acpc_character
+        when PokerAction::CHECK
+          new_slice.messages << check_description(
+            last_actor
+          )
+        when PokerAction::CALL
+          new_slice.messages << call_description(
+            last_actor,
+            last_action
+          )
+        when PokerAction::BET
+          new_slice.messages << bet_description(
+            last_actor,
+            last_action
+          )
+        when PokerAction::RAISE
+          new_slice.messages << if @match.no_limit?
+            no_limit_raise_description(
+              last_actor,
+              last_action,
+              @match.slices[-2].amount_to_call
+            )
+          else
+            limit_raise_description(
+              last_actor,
+              last_action,
+              ms.players(players_at_the_table.game_def).num_wagers(ms.round) - 1,
+              players_at_the_table.game_def.max_number_of_wagers[ms.round]
+            )
+          end
+        when PokerAction::FOLD
+          new_slice.messages << fold_description(
+            last_actor
+          )
+        end
+      end
+
+      log(
+        __method__,
+        {
+          hand_ended?: players_at_the_table.hand_ended?
+        }
+      )
+
+      if players_at_the_table.hand_ended?
+        log(
+          __method__,
+          {
+            reached_showdown?: ms.reached_showdown?
+          }
+        )
+
+        if ms.reached_showdown?
+          players_at_the_table.players.each_with_index do |player, i|
+            hd = PileOfCards.new(
+              player.hand +
+              ms.community_cards.flatten
+            ).to_poker_hand_description
+            new_slice.messages << "#{@match.player_names[i]} shows #{hd}"
+          end
+        end
+        winning_players = new_slice.players.select do |player|
+          player['winnings'] > 0
+        end
+        if winning_players.length > 1
+          new_slice.messages << split_pot_description(
+            winning_players.map { |player| player['name'] },
+            ms.pot(players_at_the_table.game_def)
+          )
+        else
+          winnings = winning_players.first['winnings']
+          if winnings.to_i == winnings
+            winnings = winnings.to_i
+          end
+          chip_balance = winning_players.first['chip_balance']
+          if chip_balance.to_i == chip_balance
+            chip_balance = chip_balance.to_i
+          end
+
+          new_slice.messages << hand_win_description(
+            winning_players.first['name'],
+            winnings,
+            chip_balance - winnings
+          )
+        end
+      end
+
+      new_slice.save!
+
+      # Since creating a new slice doesn't "update" the match for some reason
+      @match.update_attribute(:updated_at, Time.now)
+      @match.save!
+    rescue => e
+      raise UnableToCreateMatchSlice.with_context('Unable to create match slice', e)
+    end
+
+    self
+  end
+end
+end