Exemple #1
0
    def __init__(self, factory, id=0, description=None):
        self.log = PokerTable.log.get_instance(self, refs=[
            ('Game', self, lambda table: table.game.id),
            ('Hand', self, lambda table: table.game.hand_serial if table.game.hand_serial > 1 else None)
        ])
        self.factory = factory
        settings = self.factory.settings
        self.game = PokerGameServer("poker.%s.xml", factory.dirs)
        self.game.prefix = "[Server]"
        self.history_index = 0
        predefined_decks = settings.headerGetList("/server/decks/deck")
        if predefined_decks:
            self.game.shuffler = PokerPredefinedDecks(map(
                lambda deck: self.game.eval.string2card(deck.split()),
                predefined_decks
            ))
        self.observers = []
        self.waiting = []
        self.game.id = id
        self.game.name = description["name"]
        self.game.setVariant(description["variant"])
        self.game.setBettingStructure(description["betting_structure"])
        self.game.setMaxPlayers(int(description["seats"]))
        self.game.forced_dealer_seat = int(description.get("forced_dealer_seat", -1))
        self.game.registerCallback(self._gameCallbackTourneyEndTurn)
        self.game.registerCallback(self._gameCallbackTourneyUpdateStats)
        self.skin = description.get("skin", "default")
        self.currency_serial = int(description.get("currency_serial", 0))
        self.playerTimeout = int(description.get("player_timeout", 60))
        self.muckTimeout = int(description.get("muck_timeout", 5))
        self.transient = 'transient' in description
        self.tourney = description.get("tourney", None)

        # max_missed_round can be configured on a per table basis, which
        # overrides the server-wide default
        self.max_missed_round = int(description.get("max_missed_round",factory.getMissedRoundMax()))

        self.delays = settings.headerGetProperties("/server/delays")[0]
        self.autodeal = settings.headerGet("/server/@autodeal") == "yes"
        self.autodeal_temporary = settings.headerGet("/server/users/@autodeal_temporary") == 'yes'
        self.cache = createCache()
        self.owner = 0
        self.avatar_collection = PokerAvatarCollection("Table%d" % id)
        self.timer_info = {
            "playerTimeout": None,
            "playerTimeoutSerial": 0,
            "playerTimeoutTime": None,
            "muckTimeout": None,
        }
        self.timeout_policy = "sitOut"
        self.previous_dealer = -1
        self.game_delay = {
            "start": 0,
            "delay": 0,
        }
        self.update_recursion = False

        # Lock Checker
        self._initLockCheck()
Exemple #2
0
 def setUp(self):
     self.game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
     self.game.setVariant("holdem")
     self.game.setBettingStructure("1-2_20-200_limit")
     predefined_decks = [
         "8d 2h 2c 8c 4c Kc Ad 9d Ts Jd 5h Tc 4d 9h 8h 7h 9c 2s 3c Kd 5s Td 5d Th 3s Kh Js Qh 7d 2d 3d 9s Qd Ac Jh Jc Qc 6c 7s Ks 5c 4h 7c 4s Qs 6s 6h Ah 6d As 3h 8s", # distributed from the end
         ]
     self.game.shuffler = PokerPredefinedDecks(map(lambda deck: self.game.eval.string2card(split(deck)), predefined_decks))
 def setUp(self):
     predefined_decks = [
         "8d 2h 2c 8c 4c Kc Ad 9d Ts Jd 5h Tc 4d 9h 8h 7h 9c 2s 3c Kd 5s Td 5d Th 3s Kh Js Qh 7d 2d 3d 9s Qd Ac Jh Jc Qc 6c 7s Ks 5c 4h 7c 4s Qs 6s 6h Ah 6d As 3h 8s", # distributed from the end
         ]
     self.games = []
     for i in xrange(NGAMES):
         game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
         game.setVariant("7stud")
         game.setBettingStructure("0-0_50-5000_limit")
         game.id = i
         game.shuffler = PokerPredefinedDecks(map(lambda deck: game.eval.string2card(deck.split(' ')), predefined_decks))
         self.games.append(game)
Exemple #4
0
def playGame(timestamp, playerNames):
    players = dict()
    numPlayers = len(playerNames)
    for name in playerNames:
        f = open(os.path.join(basedir, 'pdb', 'pdb.' + name))
        player = None
        for line in f:
            if line.split()[1] == timestamp:
                player = IRCPlayer(line)
                break
        assert player
        players[player.pos] = player
    print players

    game = PokerGameServer("poker.%s.xml", ['/etc/poker-engine'])
    game.verbose = 1
    game.setVariant("holdem")
    game.setBettingStructure("10-20-pot-limit")

    # Each player sits at the table and buys in 1500.
    # The blinds are posted automatically, no action is required from
    # the player.
    for serial in range(1, 1 + numPlayers):
        #serial = numPlayers - i
        game.addPlayer(serial)
        game.payBuyIn(serial, 1500 * 100)
        game.sit(serial)
        #game.autoBlindAnte(serial)

    game.setDealer(numPlayers - 1)

    game.beginTurn(1)
    print 'current round:', game.current_round
    print 'dealer:', game.player_list[game.dealer]

    print 'next player:', game.getSerialInPosition()
    while game.state in ['blindAnte', 'pre-flop', 'flop', 'turn', 'river']:
        serial = game.getSerialInPosition()
        player = players[serial]
        print serial, game.canAct(serial)

        state = game.state
        if state == 'blindAnte': state = 'pre-flop'
        takeAction(game, state, serial, player)

    print "*" * 70
    for winner in game.winners:
        print "The winner is PLAYER%d with %s" % (
            winner, game.readablePlayerBestHands(winner))

    return game
Exemple #5
0
def setupGame(argv):
    """Process command line arguments and setup game"""
    def usage():
        print >> stderr, "Usage: %s [-a] [-n PLAYERS] [-s]" % argv[0]

    global autoPlay, players, game, mySerial, self_voicing
    try:
        opts, args = getopt(argv[1:], "an:s", ["help"])
    except GetoptError:
        usage()
        exit(2)
    for opt, arg in opts:
        if opt == "-a":
            autoPlay = True
        elif opt == "--help":
            usage()
            exit()
        elif opt == "-n":
            try:
                players = int(arg)
            except:
                print >> stderr, "%s is not a valid argument for %s" % (arg,
                                                                        opt)
                usage()
                exit(3)
        elif opt == "-s":
            self_voicing = True
    game = PokerGameServer("poker.%s.xml", ['/etc/poker-engine'])
    game.verbose = 0
    game.setVariant("holdem")
    game.setBettingStructure("10-15-pot-limit")
    serials = [n + 1 for n in range(players)]
    if not autoPlay:
        mySerial = choice(serials)
    game.registerCallback(pokerEvent)
    for serial in serials:
        game.addPlayer(serial)
        game.payBuyIn(serial, 1500 * 100)
        game.sit(serial)
        if serial == mySerial and not autoPlay:
            game.autoBlindAnte(serial)
        else:
            game.botPlayer(serial)
Exemple #6
0
 def setUp(self, variant, betting):
     self.game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
     self.game.setVariant(variant)
     self.game.setBettingStructure(betting)
Exemple #7
0
 def setUp(self):
     self.game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
     self.game.setVariant("holdem")
     self.game.setBettingStructure("1-2_20-200_limit")
Exemple #8
0
 def setUp(self):
     self.game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
     self.game.setVariant("7stud")
     self.game.setBettingStructure("10-20_100-2000000_ante-limit")
    def __init__(self, *args, **kwargs):
        self.name = kwargs.get('name', 'no name')
        self.description_short = kwargs.get('description_short',
                                            'nodescription_short')
        self.description_long = kwargs.get('description_long',
                                           'nodescription_long')
        self.serial = kwargs.get('serial', 1)
        self.verbose = kwargs.get('verbose', 0)
        self.players_quota = kwargs.get('players_quota', 10)
        self.players_min = kwargs.get('players_min', 2)
        self.variant = kwargs.get('variant', 'holdem')
        self.betting_structure = kwargs.get('betting_structure',
                                            'level-15-30-no-limit')
        self.dirs = kwargs.get('dirs', [])
        self.seats_per_game = kwargs.get('seats_per_game', 10)
        self.sit_n_go = kwargs.get('sit_n_go', 'y')
        self.register_time = kwargs.get('register_time', 0)
        self.start_time = kwargs.get('start_time', 0)
        self.breaks_first = kwargs.get('breaks_first', 7200)
        self.breaks_interval = kwargs.get('breaks_interval', 3600)
        self.breaks_duration = kwargs.get('breaks_duration', 300)
        self.breaks_running_since = -1
        self.breaks_since = -1
        self.breaks_count = 0
        self.buy_in = int(kwargs.get('buy_in', 0))
        self.rake = int(kwargs.get('rake', 0))
        self.rebuy_delay = kwargs.get('rebuy_delay', 0)
        self.add_on = kwargs.get('add_on', 0)
        self.add_on_delay = kwargs.get('add_on_delay', 60)
        self.prize_min = kwargs.get('prize_min', 0)
        self.prizes_specs = kwargs.get('prizes_specs', "table")
        self.rank2prize = None
        self.finish_time = -1
        if type(self.start_time) is StringType:
            self.start_time = int(
                time.mktime(time.strptime(self.start_time, "%Y/%m/%d %H:%M")))
        self.prefix = ""

        self.players = []
        self.need_balance = False
        self.registered = 0
        self.winners = []
        self.state = TOURNAMENT_STATE_ANNOUNCED
        self.can_register = False
        self.games = []
        self.id2game = {}

        self.callback_new_state = lambda tournament, old_state, new_state: True
        self.callback_create_game = lambda tournament: PokerGameServer(
            "poker.%s.xml", tournament.dirs)
        # I think callback_game_filled() is a misnomer because it's not
        # about the table being "filled" (i.e., the table could have less
        # than the max seated at it).  What really happens is that the
        # callback_game_filled() is made when the table is deemed to have
        # the number of players at it the tourney manager has decided
        # belong there (which may or may not be "filled").
        self.callback_game_filled = lambda tournament, game: True
        self.callback_destroy_game = lambda tournament, game: True
        self.callback_move_player = lambda tournament, from_game_id, to_game_id, serial: self.movePlayer(
            from_game_id, to_game_id, serial)
        self.callback_remove_player = lambda tournament, game_id, serial: self.removePlayer(
            game_id, serial)
        self.callback_cancel = lambda tournament: True

        self.loadPayouts()
        self.updateRegistering()
Exemple #10
0
#
# poker-engine
#

import sys, os
sys.path.insert(0, "..")

from pokerengine.pokergame import PokerGameServer

#
# Instantiate a poker engine for a hold'em game with a 10/15 pot limit
# betting structure. The variant and betting structure descriptions
# will be read from the conf/poker.holdem.xml and conf/poker.10-15-pot-limit.xml
# files.
#
game = PokerGameServer("poker.%s.xml",
                       ['conf', '../conf', '/etc/poker-engine'])
game.verbose = 1
game.setVariant("holdem")
game.setBettingStructure("10-15-pot-limit")

#
# The serial numbers of the four players
#
PLAYER1 = 1
PLAYER2 = 2
PLAYER3 = 3
PLAYER4 = 4

#
# Each player sits at the table and buys in 1500.
# The blinds are posted automatically, no action is required from