acpc_table_manager 3.0.18 → 4.0.0

data/lib/acpc_table_manager/match_view.rb

@@ -1,203 +0,0 @@
-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/opponents.rb

@@ -1,62 +0,0 @@
-require 'timeout'
-require 'process_runner'
-require_relative 'config'
-require_relative 'simple_logging'
-require 'fileutils'
-require 'shellwords'
-
-module AcpcTableManager
-module Opponents
-  extend SimpleLogging
-
-  @logger = nil
-
-  # @return [Array<Integer>] PIDs of the opponents started
-  def self.start(match)
-    @logger ||= ::AcpcTableManager.new_log 'opponents.log'
-
-    opponents = match.bots(AcpcTableManager.config.dealer_host)
-    log __method__, num_opponents: opponents.length
-
-    if opponents.empty?
-      raise StandardError.new("No opponents found to start for \"#{match.name}\" (#{match.id.to_s})!")
-    end
-
-    opponents_log_dir = File.join(AcpcTableManager.config.log_directory, 'opponents')
-    FileUtils.mkdir(opponents_log_dir) unless File.directory?(opponents_log_dir)
-
-    bot_start_commands = opponents.map do |name, info|
-      {
-        args: [info[:runner], info[:host], info[:port], Shellwords.escape(match.random_seed.to_s)],
-        log: File.join(opponents_log_dir, "#{match.name}.#{match.id}.#{name}.log")
-      }
-    end
-
-    bot_start_commands.map do |bot_start_command|
-      log(
-        __method__,
-        {
-          bot_start_command_parameters: bot_start_command[:args],
-          command_to_be_run: bot_start_command[:args].join(' ')
-        }
-      )
-      pid = Timeout::timeout(3) do
-        ProcessRunner.go(
-          bot_start_command[:args].map { |e| e.to_s },
-          {
-            [:err, :out] => [bot_start_command[:log], File::CREAT|File::WRONLY]
-          }
-        )
-      end
-      log(
-        __method__,
-        {
-          bot_started?: true,
-          pid: pid
-        }
-      )
-      pid
-    end
-  end
-end
-end

data/lib/acpc_table_manager/proxy.rb

@@ -1,346 +0,0 @@
-require_relative 'config'
-require_relative 'match'
-require_relative 'match_slice'
-
-require 'hescape'
-require 'acpc_poker_player_proxy'
-require 'acpc_poker_types'
-
-require_relative 'simple_logging'
-using AcpcTableManager::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, must_send_ready = false)
-    game_definition = GameDefinition.parse_file(match.game_definition_file_name)
-    match.game_def_hash = game_definition.to_h
-    match.save!
-
-    proxy = new(
-      match.id,
-      match.sanitized_name,
-      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,
-      must_send_ready
-    ) 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 [String] match_name The name 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,
-    match_name,
-    dealer_information,
-    users_seat,
-    game_definition,
-    player_names='user p2',
-    number_of_hands=1,
-    must_send_ready=false
-  )
-    @logger = AcpcTableManager.new_log File.join('proxies', "#{match_name}.#{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,
-      must_send_ready
-    ) 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
-
-  def next_hand!
-    log __method__
-
-    if @player_proxy.hand_ended?
-      @player_proxy.next_hand! do |players_at_the_table|
-        update_database! players_at_the_table
-
-        yield players_at_the_table if block_given?
-      end
-     end
-
-    log(
-      __method__,
-      {
-        users_turn_to_act?: @player_proxy.users_turn_to_act?,
-        match_ended?: @player_proxy.match_ended?
-      }
-    )
-
-    self
-  end
-
-  # Player action interface
-  # @see PlayerProxy#play!
-  def play!(action, fast_forward = false)
-    log __method__, users_turn_to_act?: @player_proxy.users_turn_to_act?, action: action
-
-    if @player_proxy.users_turn_to_act?
-      action = PokerAction.new(action) unless action.is_a?(PokerAction)
-
-      @player_proxy.play! action do |players_at_the_table|
-        update_database! players_at_the_table, fast_forward
-
-        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?
-        }
-      )
-    end
-
-    self
-  end
-
-  def users_turn_to_act?() @player_proxy.users_turn_to_act? end
-
-  def play_check_fold!
-    log __method__
-    if @player_proxy.users_turn_to_act?
-      play!(
-        if (
-          @player_proxy.legal_actions.any? do |a|
-            a == AcpcPokerTypes::PokerAction::FOLD
-          end
-        )
-          AcpcPokerTypes::PokerAction::FOLD
-        else
-          AcpcPokerTypes::PokerAction::CALL
-        end,
-        true
-      )
-    end
-    self
-  end
-
-  # @see PlayerProxy#match_ended?
-  def match_ended?
-    return false if @player_proxy.nil?
-
-    @match ||= begin
-      Match.find(@match_id)
-    rescue Mongoid::Errors::DocumentNotFound
-      log(
-        __method__,
-        {
-          msg: "Unable to find match",
-          match_id: @match_id,
-          match_ended: @player_proxy.match_ended?
-        }
-      )
-      return true
-    end
-    @player_proxy.match_ended? @match.number_of_hands
-  end
-
-  private
-
-  def update_database!(players_at_the_table, fast_forward = false)
-    @match = Match.find(@match_id)
-
-    begin
-      if fast_forward
-        @match.last_slice_viewed = @match.slices.length - 1
-      end
-
-      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.map { |n| Hescape.escape_html(n) },
-          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 ms.first_state_of_round? && ms.round > 0
-        s = if ms.community_cards[ms.round - 1].length > 1 then 'are' else 'is' end
-        new_slice.messages << (
-          "#{(ms.community_cards[ms.round - 1].map { |c| c.rank.to_s + c.suit.to_html }).join('')} #{s} revealed."
-        )
-      end
-
-      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 << "#{Hescape.escape_html(@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| Hescape.escape_html(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(
-            Hescape.escape_html(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