acpc_table_manager 0.0.1

data/lib/acpc_table_manager/dealer.rb

@@ -0,0 +1,57 @@
+require 'acpc_dealer'
+require 'timeout'
+
+require_relative 'config'
+require_relative 'match'
+
+require_relative 'simple_logging'
+
+module AcpcTableManager
+module Dealer
+  extend SimpleLogging
+
+  @logger = nil
+
+  # @return [Hash<Symbol, Object>] The dealer information
+  # @note Saves the actual port numbers used by the dealer instance in +match+
+  def self.start(options, match, port_numbers: nil)
+    @logger ||= ::AcpcTableManager.new_log 'dealer.log'
+    log __method__, options: options, match: match
+
+    dealer_arguments = {
+      match_name: Shellwords.escape(match.name.gsub(/\s+/, '_')),
+      game_def_file_name: Shellwords.escape(match.game_definition_file_name),
+      hands: Shellwords.escape(match.number_of_hands),
+      random_seed: Shellwords.escape(match.random_seed.to_s),
+      player_names: match.player_names.map { |name| Shellwords.escape(name.gsub(/\s+/, '_')) }.join(' '),
+      options: (options.split(' ').map { |o| Shellwords.escape o }.join(' ') || '')
+    }
+
+    log __method__, {
+      match_id: match.id,
+      dealer_arguments: dealer_arguments,
+      log_directory: ::AcpcTableManager.config.match_log_directory,
+      port_numbers: port_numbers,
+      command: AcpcDealer::DealerRunner.command(dealer_arguments, port_numbers)
+    }
+
+    dealer_info = Timeout::timeout(3) do
+      AcpcDealer::DealerRunner.start(
+        dealer_arguments,
+        ::AcpcTableManager.config.match_log_directory,
+        port_numbers
+      )
+    end
+
+    match.port_numbers = dealer_info[:port_numbers]
+    match.save!
+
+    log __method__, {
+      match_id: match.id,
+      saved_port_numbers: match.port_numbers
+    }
+
+    dealer_info
+  end
+end
+end

data/lib/acpc_table_manager/match.rb

@@ -0,0 +1,350 @@
+
+require 'mongoid'
+
+require 'acpc_poker_types/game_definition'
+require 'acpc_poker_types/match_state'
+
+require_relative 'match_slice'
+require_relative 'config'
+
+module AcpcTableManager
+module TimeRefinement
+  refine Time.class() do
+    def now_as_string
+      now.strftime('%b%-d_%Y-at-%-H_%-M_%-S')
+    end
+  end
+end
+end
+using AcpcTableManager::TimeRefinement
+
+module AcpcTableManager
+class Match
+  include Mongoid::Document
+  include Mongoid::Timestamps::Updated
+
+  embeds_many :slices, class_name: "AcpcTableManager::MatchSlice"
+
+  # Scopes
+  scope :old, ->(lifespan) do
+    where(:updated_at.lt => (Time.new - lifespan))
+  end
+  scope :inactive, ->(lifespan) do
+    started.and.old(lifespan)
+  end
+  scope :with_slices, ->(has_slices) do
+    where({ 'slices.0' => { '$exists' => has_slices }})
+  end
+  scope :started, -> { with_slices(true) }
+  scope :not_started, -> { with_slices(false) }
+  scope :with_running_status, ->(is_running) do
+    where(is_running: is_running)
+  end
+  scope :running, -> { with_running_status(true) }
+  scope :not_running, -> { with_running_status(false) }
+  scope :running_or_started, -> { any_of([running.selector, started.selector]) }
+
+  class << self
+    def id_exists?(match_id)
+      where(id: match_id).exists?
+    end
+
+    # Almost scopes
+    def finished
+      all.select { |match| match.finished? }
+    end
+    def unfinished(matches=all)
+      matches.select { |match| !match.finished? }
+    end
+    def started_and_unfinished()
+      started.to_a.select { |match| !match.finished? }
+    end
+
+    # Schema
+    def include_name
+      field :name
+      validates_presence_of :name
+      validates_format_of :name, without: /\A\s*\z/
+    end
+    def include_name_from_user
+      field :name_from_user
+      validates_presence_of :name_from_user
+      validates_format_of :name_from_user, without: /\A\s*\z/
+      validates_uniqueness_of :name_from_user
+    end
+    def include_game_definition
+      field :game_definition_key, type: Symbol
+      validates_presence_of :game_definition_key
+      field :game_definition_file_name
+      field :game_def_hash, type: Hash
+    end
+    def include_number_of_hands
+      field :number_of_hands, type: Integer
+      validates_presence_of :number_of_hands
+      validates_numericality_of :number_of_hands, greater_than: 0, only_integer: true
+    end
+    def include_opponent_names
+      field :opponent_names, type: Array
+      validates_presence_of :opponent_names
+    end
+    def include_seat
+      field :seat, type: Integer
+    end
+    def include_user_name
+      field :user_name
+      validates_presence_of :user_name
+      validates_format_of :user_name, without: /\A\s*\z/
+    end
+
+    # Generators
+    def new_name(
+      user_name,
+      game_def_key: nil,
+      num_hands: nil,
+      seed: nil,
+      seat: nil,
+      time: true
+    )
+      name = "match.#{user_name}"
+      name += ".#{game_def_key}" if game_def_key
+      name += ".#{num_hands}h" if num_hands
+      name += ".#{seat}s" if seat
+      name += ".#{seed}r" if seed
+      name += ".#{Time.now_as_string}" if time
+      name
+    end
+    def new_random_seed
+      random_float = rand
+      random_int = (random_float * 10**random_float.to_s.length).to_i
+    end
+    def new_random_seat(num_players)
+      rand(num_players) + 1
+    end
+    def default_opponent_names(num_players)
+      (num_players - 1).times.map { |i| "Tester" }
+    end
+    # @todo Port numbers don't need to be stored
+    def create_with_defaults(
+      user_name: 'Guest',
+      game_definition_key: :two_player_limit,
+      port_numbers: []
+    )
+      new(
+        name_from_user: new_name(user_name),
+        user_name: user_name,
+        port_numbers: port_numbers,
+        game_definition_key: game_definition_key
+      ).finish_starting!
+    end
+
+    # Deletion
+    def delete_matches_older_than!(lifespan)
+      old(lifespan).delete_all
+      self
+    end
+    def delete_finished_matches!
+      finished.each do |m|
+        m.delete if m.all_slices_viewed?
+      end
+      self
+    end
+    def delete_match!(match_id)
+      begin
+        match = find match_id
+      rescue Mongoid::Errors::DocumentNotFound
+      else
+        match.delete
+      end
+      self
+    end
+  end
+
+  # Schema
+  field :port_numbers, type: Array
+  field :random_seed, type: Integer, default: new_random_seed
+  field :last_slice_viewed, type: Integer, default: -1
+  field :is_running, type: Boolean, default: false
+  field :dealer_options, type: String, default: (
+    [
+      '-a', # Append logs with the same name rather than overwrite
+      "--t_response 80000", # 80 seconds per action
+      '--t_hand -1',
+      '--t_per_hand -1'
+    ].join(' ')
+  )
+  include_name
+  include_name_from_user
+  include_user_name
+  include_game_definition
+  include_number_of_hands
+  include_opponent_names
+  include_seat
+
+
+  def bots(dealer_host)
+    bot_info_from_config_that_match_opponents = ::AcpcTableManager.exhibition_config.bots(game_definition_key, *opponent_names)
+    bot_opponent_ports = opponent_ports_with_condition do |name|
+      bot_info_from_config_that_match_opponents.keys.include? name
+    end
+
+    raise unless (
+      port_numbers.length == player_names.length ||
+      bot_opponent_ports.length == bot_info_from_config_that_match_opponents.length
+    )
+
+    bot_opponent_ports.zip(
+      bot_info_from_config_that_match_opponents.keys,
+      bot_info_from_config_that_match_opponents.values
+    ).reduce({}) do |map, args|
+      port_num, name, info = args
+      map[name] = {
+        runner: (if info['runner'] then info['runner'] else info end),
+        host: dealer_host, port: port_num
+      }
+      map
+    end
+  end
+
+  # Initializers
+  def set_name!(name_ = self.name_from_user)
+    name_from_user_ = name_.strip
+    self.name = name_from_user_
+    self.name_from_user = name_from_user_
+    self
+  end
+  def set_seat!(seat_ = self.seat)
+    self.seat = seat_ || self.class().new_random_seat(game_info['num_players'])
+    if self.seat > game_info['num_players']
+      self.seat = game_info['num_players']
+    end
+    self
+  end
+  def set_game_definition_file_name!(file_name = game_info['file'])
+    self.game_definition_file_name = file_name
+    self
+  end
+  def set_game_definition_hash!(hash = self.game_def_hash)
+    self.game_def_hash = hash || game_def_hash_from_key
+  end
+  def finish_starting!
+    set_name!.set_seat!.set_game_definition_file_name!.set_game_definition_hash!
+    self.opponent_names ||= self.class().default_opponent_names(game_info['num_players'])
+    self.number_of_hands ||= 1
+    save!
+    self
+  end
+
+  UNIQUENESS_GUARANTEE_CHARACTER = '_'
+  def copy_for_next_human_player(next_user_name, next_seat)
+    match = dup
+    # This match was not given a name from the user,
+    # so set this parameter to an arbitrary character
+    match.name_from_user = UNIQUENESS_GUARANTEE_CHARACTER
+    while !match.save do
+      match.name_from_user << UNIQUENESS_GUARANTEE_CHARACTER
+    end
+    match.user_name = next_user_name
+
+    # Swap seat
+    match.seat = next_seat
+    match.opponent_names.insert(seat - 1, user_name)
+    match.opponent_names.delete_at(seat - 1)
+    match.save!(validate: false)
+    match
+  end
+  def copy?
+    self.name_from_user.match(/^#{UNIQUENESS_GUARANTEE_CHARACTER}+$/)
+  end
+
+  # Convenience accessors
+  def game_info
+    @game_info ||= AcpcTableManager.exhibition_config.games[self.game_definition_key.to_s]
+  end
+  # @todo Why am I storing the file name if I want to get it from the key anyway?
+  def game_def_file_name_from_key() game_info['file'] end
+  def game_def_hash_from_key()
+    @game_def_hash_from_key ||= AcpcPokerTypes::GameDefinition.parse_file(game_def_file_name_from_key).to_h
+  end
+  def game_def
+    @game_def ||= AcpcPokerTypes::GameDefinition.new(game_def_hash_from_key)
+  end
+  def hand_number
+    return nil if slices.last.nil?
+    state = AcpcPokerTypes::MatchState.parse(
+      slices.last.state_string
+    )
+    if state then state.hand_number else nil end
+  end
+  def no_limit?
+    @is_no_limit ||= game_def.betting_type == AcpcPokerTypes::GameDefinition::BETTING_TYPES[:nolimit]
+  end
+  def started?
+    !self.slices.empty?
+  end
+  def finished?
+    started? && self.slices.last.match_ended?
+  end
+  def running?
+    self.is_running
+  end
+  def all_slices_viewed?
+    self.last_slice_viewed >= (self.slices.length - 1)
+  end
+  def all_slices_up_to_hand_end_viewed?
+    (self.slices.length - 1).downto(0).each do |slice_index|
+      slice = self.slices[slice_index]
+      if slice.hand_has_ended
+        if self.last_slice_viewed >= slice_index
+          return true
+        else
+          return false
+        end
+      end
+    end
+    return all_slices_viewed?
+  end
+  def player_names
+    opponent_names.dup.insert seat-1, self.user_name
+  end
+  def bot_special_port_requirements
+    ::AcpcTableManager.exhibition_config.bots(game_definition_key, *opponent_names).values.map do |bot|
+      bot['requires_special_port']
+    end
+  end
+  def users_port
+    port_numbers[seat - 1]
+  end
+  def opponent_ports
+    port_numbers_ = port_numbers.dup
+    users_port_ = port_numbers_.delete_at(seat - 1)
+    port_numbers_
+  end
+  def opponent_seats_with_condition
+    player_names.each_index.select do |i|
+      yield player_names[i]
+    end.map { |s| s + 1 } - [self.seat]
+  end
+  def opponent_seats(opponent_name)
+    opponent_seats_with_condition { |player_name| player_name == opponent_name }
+  end
+  def opponent_ports_with_condition
+    opponent_seats_with_condition { |player_name| yield player_name }.map do |opp_seat|
+      port_numbers[opp_seat - 1]
+    end
+  end
+  def opponent_ports_without_condition
+    local_opponent_ports = opponent_ports
+    opponent_ports_with_condition { |player_name| yield player_name }.each do |port|
+      local_opponent_ports.delete port
+    end
+    local_opponent_ports
+  end
+  def rejoinable_seats(user_name)
+    (
+      opponent_seats(user_name) -
+      # Remove seats already taken by players who have already joined this match
+      self.class().where(name: self.name).ne(name_from_user: self.name).map { |m| m.seat }
+    )
+  end
+end
+end

data/lib/acpc_table_manager/match_slice.rb

@@ -0,0 +1,196 @@
+require 'mongoid'
+
+require 'acpc_poker_types/game_definition'
+
+require_relative 'config'
+
+module AcpcTableManager
+class MatchSlice
+  include Mongoid::Document
+
+  embedded_in :match, inverse_of: :slices
+
+  field :hand_has_ended, type: Boolean
+  field :match_has_ended, type: Boolean
+  field :seat_with_dealer_button, type: Integer
+  field :seat_next_to_act, type: Integer
+  field :state_string, type: String
+  # Not necessary to be in the database, but more performant than processing on the
+  # Rails server
+  field :betting_sequence, type: String
+  field :pot_at_start_of_round, type: Integer
+  field :players, type: Array
+  field :minimum_wager_to, type: Integer
+  field :chip_contribution_after_calling, type: Integer
+  field :pot_after_call, type: Integer
+  field :is_users_turn_to_act, type: Boolean
+  field :legal_actions, type: Array
+  field :amount_to_call, type: Integer
+  field :messages, type: Array
+
+  def self.from_players_at_the_table!(patt, match_has_ended, match)
+    match.slices.create!(
+      hand_has_ended: patt.hand_ended?,
+      match_has_ended: match_has_ended,
+      seat_with_dealer_button: patt.dealer_player.seat.to_i,
+      seat_next_to_act: if patt.next_player_to_act
+        patt.next_player_to_act.seat.to_i
+      end,
+      state_string: patt.match_state.to_s,
+      # Not necessary to be in the database, but more performant than processing on the
+      # Rails server
+      betting_sequence: betting_sequence(patt.match_state, patt.game_def),
+      pot_at_start_of_round: pot_at_start_of_round(patt.match_state, patt.game_def).to_i,
+      players: players(patt, match.player_names),
+      minimum_wager_to: minimum_wager_to(patt.match_state, patt.game_def).to_i,
+      chip_contribution_after_calling: chip_contribution_after_calling(patt.match_state, patt.game_def).to_i,
+      pot_after_call: pot_after_call(patt.match_state, patt.game_def).to_i,
+      all_in: all_in(patt.match_state, patt.game_def).to_i,
+      is_users_turn_to_act: patt.users_turn_to_act?,
+      legal_actions: patt.legal_actions.map { |action| action.to_s },
+      amount_to_call: amount_to_call(patt.match_state, patt.game_def).to_i
+    )
+  end
+
+  def self.betting_sequence(match_state, game_def)
+    sequence = ''
+    match_state.betting_sequence(game_def).each_with_index do |actions_per_round, round|
+      actions_per_round.each_with_index do |action, action_index|
+        adjusted_action = adjust_action_amount(
+          action,
+          round,
+          match_state,
+          game_def
+        )
+
+        sequence << if (
+          match_state.player_acting_sequence(game_def)[round][action_index].to_i ==
+          match_state.position_relative_to_dealer
+        )
+          adjusted_action.capitalize
+        else
+          adjusted_action
+        end
+      end
+      sequence << '/' unless round == match_state.betting_sequence(game_def).length - 1
+    end
+    sequence
+  end
+
+  def self.pot_at_start_of_round(match_state, game_def)
+    return 0 if match_state.round == 0
+
+    match_state.players(game_def).inject(0) do |sum, pl|
+      sum += pl.contributions[0..match_state.round - 1].inject(:+)
+    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'
+  # 'winnings'
+  def self.players(patt, player_names)
+    player_names_queue = player_names.dup
+    patt.players.map do |player|
+      hole_cards = if !(player.hand.empty? || player.folded?)
+        player.hand.to_acpc
+      elsif player.folded?
+        ''
+      else
+        '_' * patt.game_def.number_of_hole_cards
+      end
+
+      {
+        'name' => player_names_queue.shift,
+        'seat' => player.seat,
+        'chip_stack' => player.stack.to_i,
+        'chip_contributions' => player.contributions.map { |contrib| contrib.to_i },
+        'chip_balance' => player.balance,
+        'hole_cards' => hole_cards,
+        'winnings' => player.winnings.to_f
+      }
+    end
+  end
+
+  # Over round
+  def self.minimum_wager_to(state, game_def)
+    return 0 unless state.next_to_act(game_def)
+
+    (
+      state.min_wager_by(game_def) +
+      chip_contribution_after_calling(state, game_def)
+    ).ceil
+  end
+
+  # Over round
+  def self.chip_contribution_after_calling(state, game_def)
+    return 0 unless state.next_to_act(game_def)
+
+    (
+      (
+        state.players(game_def)[
+          state.next_to_act(game_def)
+        ].contributions[state.round] || 0
+      ) + amount_to_call(state, game_def)
+    )
+  end
+
+  # Over round
+  def self.pot_after_call(state, game_def)
+    return state.pot(game_def) if state.hand_ended?(game_def)
+
+    state.pot(game_def) + state.players(game_def).amount_to_call(state.next_to_act(game_def))
+  end
+
+  # Over round
+  def self.all_in(state, game_def)
+    return 0 if state.hand_ended?(game_def)
+
+    (
+      state.players(game_def)[state.next_to_act(game_def)].stack +
+      (
+        state.players(game_def)[state.next_to_act(game_def)]
+          .contributions[state.round] || 0
+      )
+    ).floor
+  end
+
+  def self.amount_to_call(state, game_def)
+    return 0 if state.next_to_act(game_def).nil?
+
+    state.players(game_def).amount_to_call(state.next_to_act(game_def))
+  end
+
+  def users_turn_to_act?
+    self.is_users_turn_to_act
+  end
+  def hand_ended?
+    self.hand_has_ended
+  end
+  def match_ended?
+    self.match_has_ended
+  end
+
+  private
+
+  def self.adjust_action_amount(action, round, match_state, game_def)
+    amount_to_over_hand = action.modifier
+    if amount_to_over_hand.blank?
+      action
+    else
+      amount_to_over_round = (
+        amount_to_over_hand.to_i - match_state.players(game_def)[
+          match_state.position_relative_to_dealer
+        ].contributions_before(round).to_i
+      )
+      "#{action[0]}#{amount_to_over_round}"
+    end
+  end
+end
+end