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()
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))
class TestBugUncalled(unittest.TestCase):
def setUp(self):
self.game = PokerGameServer("poker.%s.xml", [ "../conf", "../conf" ])
self.game.verbose = 3
self.game.setVariant("holdem")
self.game.setBettingStructure(".10-.25-no-limit")
def tearDown(self):
del self.game
def test01(self):
pass
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)
class TestHistory(unittest.TestCase):
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 tearDown(self):
del self.game
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.autoBlindAnte(serial)
def test1(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
self.assertEqual(
str(
history2messages(self.game,
self.game.turn_history,
pocket_messages=True)),
"('hand #1, holdem, 1-2_20-200_limit', ['2 pays 1 blind', '3 pays 2 blind', 'pre-flop, 4 players', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', 'Cards player 3: As 6s', 'Cards player 4: 6d Qs', '4 calls 2', '1 calls 2', '2 calls 1', '3 checks', 'flop, 4 players', 'Board: 4s 7c 4h', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', 'Cards player 3: As 6s', 'Cards player 4: 6d Qs', '2 checks', '3 checks', '4 checks', '1 checks', 'turn, 4 players', 'Board: 4s 7c 4h 5c', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', 'Cards player 3: As 6s', 'Cards player 4: 6d Qs', '2 raises 4', '3 folds', '4 folds', '1 calls 4', 'river, 2 players', 'Board: 4s 7c 4h 5c Ks', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', '2 raises 4', '1 calls 4', 'Rake 1', 'Board: 4s 7c 4h 5c Ks', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', '2 shows Straight Seven to Trey ', '1 mucks loosing hand', '2 wins ', '2 receives 24'])"
)
def test2(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
for event in self.game.historyGet():
if event[0] == "round":
(type, name, board, pockets) = event
for (player_serial, pocket) in pockets.iteritems():
pocket.loseNotVisible()
self.assertEqual(
pocket, PokerCards([PokerCards.NOCARD] * pocket.len()))
class TestAllIn(unittest.TestCase):
def setUp(self, variant, betting):
self.game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
self.game.setVariant(variant)
self.game.setBettingStructure(betting)
def bestWithStrings(self, side, serial):
(value, cards) = self.game.bestHand(side, serial)
return (cards[0], self.game.eval.card2string(cards[1:]))
def tearDown(self):
del self.game
def log(self, string):
print string
def make_cards(self, visible, *args):
cards = PokerCards(poker_eval.string2card(args))
if visible:
cards.allVisible()
else:
cards.allHidden()
return cards
def make_new_player(self, i, initial_money = _initial_money):
self.assert_(self.game.addPlayer(i))
player = self.game.serial2player[i]
player.money = initial_money
player.buy_in_payed = True
self.assert_(self.game.sit(i))
player.auto_blind_ante = True
self.game.autoMuck(i, pokergame.AUTO_MUCK_ALWAYS)
def prepareGame(self, nplayers):
pot = 9100
self.money = 1
self.player = {}
money = self.money
game = self.game
player = self.player
for serial in xrange(1,nplayers+1):
self.make_new_player(serial, money)
player[serial] = game.serial2player[serial]
game.beginTurn(1)
game.pot = pot
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)
class TestHistory(unittest.TestCase):
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 tearDown(self):
del self.game
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.autoBlindAnte(serial)
def test1(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
self.assertEqual(str(history2messages(self.game, self.game.turn_history, pocket_messages = True)), "('hand #1, holdem, 1-2_20-200_limit', ['2 pays 1 blind', '3 pays 2 blind', 'pre-flop, 4 players', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', 'Cards player 3: As 6s', 'Cards player 4: 6d Qs', '4 calls 2', '1 calls 2', '2 calls 1', '3 checks', 'flop, 4 players', 'Board: 4s 7c 4h', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', 'Cards player 3: As 6s', 'Cards player 4: 6d Qs', '2 checks', '3 checks', '4 checks', '1 checks', 'turn, 4 players', 'Board: 4s 7c 4h 5c', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', 'Cards player 3: As 6s', 'Cards player 4: 6d Qs', '2 raises 4', '3 folds', '4 folds', '1 calls 4', 'river, 2 players', 'Board: 4s 7c 4h 5c Ks', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', '2 raises 4', '1 calls 4', 'Rake 1.20', 'Board: 4s 7c 4h 5c Ks', 'Cards player 1: 8s Ah', 'Cards player 2: 3h 6h', '2 shows Straight Seven to Trey for hi ', '1 mucks loosing hand', '2 wins hi ', '2 receives 24'])")
def test2(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
for event in self.game.historyGet():
if event[0] == "round":
(type, name, board, pockets) = event
for (player_serial, pocket) in pockets.iteritems():
pocket.loseNotVisible()
self.assertEqual(pocket, PokerCards([PokerCards.NOCARD] * pocket.len()))
class TestPosition(unittest.TestCase):
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")
def tearDown(self):
del self.game
def log(self, string):
print string
def make_cards(self, *args):
return PokerCards(poker_eval.string2card(args))
def make_new_player(self, i, initial_money = _initial_money):
self.assert_(self.game.addPlayer(i))
player = self.game.serial2player[i]
player.money = initial_money
player.buy_in_payed = True
self.assert_(self.game.sit(i))
player.auto_blind_ante = True
def test1(self):
"""
"""
game = self.game
player = {}
for serial in xrange(1,6):
self.make_new_player(serial)
player[serial] = game.serial2player[serial]
game.beginTurn(1)
for serial in (2, 3, 4, 5):
player[serial].hand = self.make_cards('__', '__')
player[1].hand = self.make_cards('Ad', 'As')
self.assertTrue(540 <= game.handEV(1, 100000) <= 570)
player[1].hand = self.make_cards('2c', '7s')
self.assertTrue(100 <= game.handEV(1, 100000) <= 120)
game.board = self.make_cards('2c', '3c', '4s')
player[1].hand = self.make_cards('2s', '7s')
self.assertTrue(160 <= game.handEV(1, 100000) <= 180)
game.board = self.make_cards('2c', '3c', '4s', '4c')
player[1].hand = self.make_cards('2s', '7s')
self.assertTrue(70 <= game.handEV(1, 100000) <= 80)
game.board = self.make_cards('2c', '3c', '4s', '4c', 'Kc')
player[1].hand = self.make_cards('2s', '7s')
self.assertTrue(3 <= game.handEV(1, 100000) <= 9)
class TestDeal(unittest.TestCase):
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 tearDown(self):
del self.game
def log(self, string):
print string
def make_new_player(self, i, initial_money):
self.assert_(self.game.addPlayer(i))
player = self.game.serial2player[i]
player.money = initial_money
player.buy_in_payed = True
self.assert_(self.game.sit(i))
player.auto_blind_ante = True
def test1(self):
"""
8 players, non fold, last card is a community card
"""
game = self.game
for serial in xrange(1,9):
self.make_new_player(serial, 2000)
game.beginTurn(1)
while True:
if game.isLastRound():
self.assertEqual(len(game.board.tolist(True)), 1)
for _x in xrange(1,9):
serial = game.getSerialInPosition()
self.assertEqual(game.check(serial), True)
if not game.isRunning():
break;
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
class TestPosition(unittest.TestCase):
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 tearDown(self):
del self.game
def log(self, string):
print string
def make_cards(self, *args):
return PokerCards(poker_eval.string2card(args))
def make_new_player(self, i, initial_money = _initial_money):
self.assert_(self.game.addPlayer(i))
player = self.game.serial2player[i]
player.money = initial_money
player.auto_play = 0
player.buy_in_payed = True
self.assert_(self.game.sit(i))
player.auto_blind_ante = True
def test1(self):
"""
Five players, they check/call during rounds and start over.
Players
serials 1 2 3 4 5
seats 0 1 2 3 4
positions 0 1 2 3 4
"""
game = self.game
player = {}
for serial in xrange(1,6):
player[serial] = serial - 1
self.make_new_player(serial)
#
# First turn, everyone checks and stays in game
#
game.beginTurn(1)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[1]) # dealer
self.assertEqual(game.last_to_talk, player[3]) # big blind
for serial in (4, 5, 1, 2):
self.assertEqual(game.position, player[serial])
game.call(serial)
self.assertEqual(game.position, player[3])
game.check(3) # big blind
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
for serial in (2, 3, 4, 5, 1):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Second turn, everyone folds games end prematurely
#
game.beginTurn(2)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[2]) # dealer
self.assertEqual(game.last_to_talk, player[4]) # big blind
for serial in (5, 1, 2, 3):
self.assertEqual(game.position, player[serial])
self.assertEqual(game.fold(serial), True)
self.assertEqual(game.state, "end")
#
# Third turn, a new player comes in during the turn, two
# players in game. The new player is ignored.
#
game.beginTurn(3)
self.make_new_player(6)
player[6] = 5
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[3]) # dealer
self.assertEqual(game.last_to_talk, player[5]) # big blind
self.assertEqual(game.position, player[1])
game.call(1)
for serial in (2, 3, 4):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.position, player[5])
game.check(5)
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
self.assertEqual(game.position, player[5]) # next to the dealer is gone, therefore it's the next to him
for serial in (5, 1):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Fourth turn, we now have six players in game, the
# newcomer pays the big blind
#
game.beginTurn(4)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[4]) # dealer
self.assertEqual(game.last_to_talk, player[6]) # big blind
self.assertEqual(game.position, player[1])
game.call(1)
for serial in (2, 3, 4, 5):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.position, player[6])
game.check(6)
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
self.assertEqual(game.position, player[6]) # next to the dealer is gone, therefore it's the next to him
for serial in (6, 1):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Fifth turn, a player (the dealer) leaves in the middle
# of the game, auto_play takes over.
#
game.beginTurn(5)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[5]) # dealer
self.assertEqual(game.last_to_talk, player[1]) # big blind
for serial in (2, 3):
self.assertEqual(game.position, player[serial])
game.fold(serial)
game.removePlayer(5)
game.autoPlayer(5)
for serial in (4, 6):
self.assertEqual(game.position, player[serial])
game.call(serial)
self.assertEqual(game.position, player[1])
game.check(1)
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
self.assertEqual(game.last_to_talk, player[4])
self.assertEqual(game.position, player[6]) # next to the dealer is gone, therefore it's the next to him
for serial in (6, 1, 4):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Sixth turn, everyone folds and game ends prematurely.
# player[5] is gone for good, discarded at the end of the
# previous turn.
#
player[6] -= 1
game.beginTurn(6)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[6]) # dealer
self.assertEqual(game.last_to_talk, player[2]) # big blind
for serial in (3, 4, 6, 1):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.state, "end")
#
# Seventh turn, the dealer passes to player[1] again
#
game.beginTurn(7)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[1]) # dealer
self.assertEqual(game.last_to_talk, player[3]) # big blind
for serial in (4, 6, 1, 2):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.state, "end")
def test2(self):
"""
getRequestedAction and setPlayerBlind tests
"""
game = self.game
for serial in xrange(1,5):
self.failUnless(game.addPlayer(serial))
self.failUnless(game.payBuyIn(serial, game.maxBuyIn()))
self.failUnless(game.sit(serial))
self.failUnless(game.addPlayer(5))
self.assertEqual(game.getRequestedAction(5), "buy-in")
self.failUnless(game.payBuyIn(5, game.maxBuyIn()))
self.assertEqual(game.getRequestedAction(5), None)
game.getPlayer(5).money= 1
self.assertEqual(game.getRequestedAction(5), "rebuy")
self.failUnless(game.rebuy(5, game.bestBuyIn()))
self.assertEqual(game.getRequestedAction(5), None)
self.failUnless(game.sit(5))
#
# turn 1
#
game.beginTurn(8)
self.assertEqual(game.state, "blindAnte")
self.assertEqual(game.getRequestedAction(2), "blind_ante")
(amount, dead, state) = game.blindAmount(2)
game.blind(2, amount, dead)
self.assertEqual(game.getRequestedAction(3), "blind_ante")
(amount, dead, state) = game.blindAmount(3)
game.blind(3, amount, dead)
self.assertEqual(game.getRequestedAction(4), "play")
for serial in xrange(1,6):
game.botPlayer(serial)
#
# turn 2,3,4
#
self.failUnless(game.sitOut(4))
game.beginTurn(9)
game.beginTurn(10)
game.beginTurn(11)
for serial in xrange(1,6):
game.interactivePlayer(serial)
#
# player 4 back in the game must pay the big blind
#
self.failUnless(game.sit(4))
game.beginTurn(12)
self.assertEqual(game.state, "blindAnte")
self.assertEqual(game.getRequestedAction(2), "blind_ante")
(amount, dead, state) = game.blindAmount(2)
game.blind(2, amount, dead)
self.assertEqual(game.getRequestedAction(3), "blind_ante")
(amount, dead, state) = game.blindAmount(3)
game.blind(3, amount, dead)
self.assertEqual(game.getRequestedAction(4), "blind_ante")
game.setPlayerBlind(4, "big_and_dead")
self.assertEqual(game.getRequestedAction(4), "blind_ante")
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()
#
# 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
class TestBlinds(unittest.TestCase):
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")
self.amounts = {}
self.amounts['big'] = 2
self.amounts['small'] = 1
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 tearDown(self):
del self.game
def make_new_bot(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.noAutoBlindAnte(serial)
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
def pay_blinds(self, skipSerials = {}):
game = self.game
for serial in game.serialsAll():
if serial in skipSerials: continue
game.autoBlindAnte(serial)
for serial in game.serialsAll():
if serial in skipSerials: continue
game.noAutoBlindAnte(serial)
def check_button(self, serial):
self.assertEquals(self.game.player_list[self.game.dealer], serial)
def check_blinds(self, descriptions):
players = self.game.playersAll()
players.sort(key=lambda i: i.seat)
failStr = None
ii = 0
for player in players:
ii += 1
(blind, missed, wait, missedCount) = descriptions.pop(0)
if(blind != player.blind or missed != player.missed_blind or wait != player.wait_for or player.missed_big_blind_count != missedCount):
failStr = "%d check_blinds FAILED actual %s != from expected %s" % ( ii, (player.blind, player.missed_blind, player.wait_for, player.missed_big_blind_count), (blind, missed, wait, missedCount) )
log.debug(failStr)
else:
goodStr = "%d check_blinds %s == %s" % (ii, (player.blind, player.missed_blind, player.wait_for, player.missed_big_blind_count), (blind, missed, wait, missedCount) )
log.debug(goodStr)
if failStr:
self.fail(failStr)
def confirm_blind(self, hist, acceptedEntries):
for ee in acceptedEntries:
(val1, val2, val3) = ee
ee = ('blind', val1, val2, val3)
self.assertEquals(ee in hist, True)
hist.remove(ee)
for hh in hist:
self.assertNotEquals(hh[0], 'blind')
self.assertNotEquals(hh[0], 'ante')
def confirm_hist(self, hist, acceptedEntries):
for ee in acceptedEntries:
self.assertEquals(ee in hist, True)
hist.remove(ee)
def test1(self):
big = self.amounts['big']
small = self.amounts['small']
seat2serial = {}
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_bot(serial, seat)
seat2serial[seat] = serial
self.game.beginTurn(1)
# (blind, missed, wait, missedCount)
self.check_button(1)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(3, big, 0), (2, small, 0)])
self.game.beginTurn(2)
self.check_button(2)
# (blind, missed, wait, missedCount)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
('small', None, False, 0), # 3
('big', None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(4, big, 0), (3, small, 0)])
self.game.beginTurn(3)
self.check_button(3)
# (blind, missed, wait, missedCount)
self.check_blinds([
('big', None, False, 0), # 1
(False, None, False, 0), # 2
(False, None, False, 0), # 3
('small', None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(1, big, 0), (4, small, 0)])
self.game.beginTurn(4)
# (blind, missed, wait)
self.check_button(4)
self.check_blinds([
('small', None, False, 0), # 1
('big', None, False, 0), # 2
(False, None, False, 0), # 3
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, big, 0), (1, small, 0)])
# --------------------------------------------------------------------------
def test2(self):
"""
Two new players enter the game and both pay the big blind
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 8)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.check_button(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(3, big, 0), (2, small, 0)])
for (serial, seat) in ((10, 4), (11, 5)):
self.make_new_bot(serial, seat)
self.game.beginTurn(2)
self.check_button(2)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
('small', None, False, 0), # 3
('big', 'n/a', False, 0), # 10
('late', 'n/a', False, 0), # 11
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(11, big, 0), (10, big, 0), (3, small, 0)])
# --------------------------------------------------------------------------
def test3(self):
"""
Two new players enter the game between the small
and big blind. They are allowed to play during the
second turn because they cannot be awarded the button
as they arrive.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((1, 0), (2, 1), (3, 7), (4, 8)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.check_button(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0)])
for (serial, seat) in ((10, 4), (11, 5)):
self.make_new_bot(serial, seat)
self.game.beginTurn(2)
# (blind, missed, wait)
self.check_button(2)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
(False, 'n/a', 'late', 0), # 10
(False, 'n/a', 'late', 0), # 11
('small', None, False, 0), # 3
('big', None, False, 0), # 4
])
self.pay_blinds()
history = self.game.turn_history
self.confirm_blind(history, [(4, big, 0), (3, small, 0)])
# players who did not pay the big blind are removed from
# the history by historyReduce
game_index = 0
player_list_index = 7
serial2chips_index = 9
self.assertEqual(history[game_index][player_list_index], [1, 2, 10, 11, 3, 4])
self.assertEqual(history[game_index][serial2chips_index].keys(), [1, 2, 3, 4, 10, 11])
self.game.historyReduce()
self.game.historyReduce()
self.assertEqual(self.game.turn_history[game_index][player_list_index], [1, 2, 3, 4])
self.assertEqual(self.game.turn_history[game_index][serial2chips_index].keys(), [1, 2, 3, 4])
self.game.beginTurn(3)
self.check_button(3)
# (blind, missed, wait)
self.check_blinds([
('big', None, False, 0), # 1
(False, None, False, 0), # 2
('late', 'n/a', False, 0), # 10
('late', 'n/a', False, 0), # 11
(False, None, False, 0), # 3
('small', None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(1, big, 0), (10, big, 0),(11, big, 0), (4, small, 0)])
self.game.beginTurn(4)
# (blind, missed, wait)
self.check_button(4)
self.check_blinds([
('small', None, False, 0), # 1
('big', None, False, 0), # 2
(False, None, False, 0), # 10
(False, None, False, 0), # 11
(False, None, False, 0), # 3
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(1, small, 0), (2, big, 0)])
# --------------------------------------------------------------------------
def test4_fourPlayers_player4missedBothBlinds_onlyBigRequired(self):
"""
Less than 6 players, player 4 missed the big and small blinds and
must pay the big blind when back in the game. The missed blind
count only ever goes to one, because the player is not passed again.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.check_button(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0)])
self.game.sitOut(4)
self.game.beginTurn(2)
self.check_button(2)
# (blind, missed, wait)
self.check_blinds([
('big', None, False, 0), # 1
(False, None, False, 0), # 2
('small', None, False, 0), # 3
(False, 'big', False, 1), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(3, small, 0), (1, big, 0)])
self.game.beginTurn(3)
self.check_button(3)
# (blind, missed, wait)
self.check_blinds([
('small', None, False, 0), # 1
('big', None, False, 0), # 2
(False, None, False, 0), # 3
(False, 'big', False, 1), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(1, small, 0), (2, big, 0)])
self.assertEquals(self.game.serial2player[4].getMissedRoundCount(), 1)
self.assertEquals(self.game.serial2player[1].getMissedRoundCount(), 0)
self.game.sit(4)
self.game.beginTurn(4)
self.check_button(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
('late', 'big', False, 1), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0),(4, big, 0)])
self.game.beginTurn(5)
self.check_button(2)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
('small', None, False, 0), # 3
('big', None, False, 0), # 4
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(3, small, 0), (4, big, 0)])
# --------------------------------------------------------------------------
def test5_sixPlayers_missedBothBlinds_bothRequired(self):
"""
At six players, player 4 missed the big and small blinds and
must pay BOTH when back in the game. The missed blind
count only ever goes to one, because the player is not passed again.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3), (5, 4), (6, 5)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.check_button(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
(False, None, False, 0), # 5
(False, None, False, 0), # 6
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0)])
self.game.sitOut(4)
self.game.beginTurn(2)
self.check_button(2)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
('small', None, False, 0), # 3
(False, 'big', False, 1), # 4
('big', None, False, 0), # 5
(False, None, False, 0), # 6
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(3, small, 0), (5, big, 0)])
self.game.beginTurn(3)
self.check_button(3)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
(False, None, False, 0), # 3
(False, 'big', False, 1), # 4
('small', None, False, 0), # 5
('big', None, False, 0), # 6
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(5, small, 0), (6, big, 0)])
self.assertEquals(self.game.serial2player[4].getMissedRoundCount(), 1)
self.game.sit(4)
self.game.beginTurn(4)
self.check_button(5)
# (blind, missed, wait)
self.check_blinds([
('big', None, False, 0), # 1
(False, None, False, 0), # 2
(False, None, False, 0), # 3
('big_and_dead', 'big', False, 1), # 4
(False, None, False, 0), # 5
('small', None, False, 0), # 6
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(6, small, 0), (1, big, 0), (4, big, small)])
self.game.beginTurn(5)
# (blind, missed, wait)
self.check_blinds([
('small', None, False, 0), # 1
('big', None, False, 0), # 2
(False, None, False, 0), # 3
(False, None, False, 0), # 4
(False, None, False, 0), # 5
(False, None, False, 0), # 6
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(1, small, 0), (2, big, 0)])
# --------------------------------------------------------------------------
def test6_fivePlayers_multiDecline_noHandStarts(self):
"""Five players, goes 2 handed before first hand dealt. Others sit in after.
At five players, 1, 2 and 4 sit out before first hand begins. 3
accepts the small blind, as 1, 2, and 4 sit back in. 5 rejects
the big blind, and the turn ends. We restart with the five
sitting out and blinds in the right place.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3), (5, 4)):
self.make_new_bot(serial, seat)
self.game.sitOut(1)
self.game.sitOut(2)
self.game.sitOut(4)
self.game.beginTurn(1)
self.check_button(5)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
(False, 'small', False, 0), # 2
('small', None, False, 0), # 3
(False, 'big', False, 1), # 4
('big', None, False, 0), # 5
])
self.assertEquals(self.game.serial2player[4].getMissedRoundCount(), 1)
self.game.sit(1)
self.game.sit(2)
self.game.autoBlindAnte(3)
self.game.noAutoBlindAnte(3)
self.game.sit(4)
self.confirm_hist(self.game.turn_history, [('blind_request', 5, big, 0, 'big'), ('blind', 3, small, 0)])
self.check_button(5)
# (blind, missed, wait)
self.check_blinds([
(False, None, 'first_round', 0), # 1
(False, 'small', 'first_round', 0), # 2
(True, None, False, 0), # 3
(False, 'big', 'first_round', 1), # 4
('big', None, False, 0), # 5
])
self.game.sitOut(5)
self.confirm_hist(self.game.turn_history, [('canceled', 3, small)])
self.failUnless(self.game.state, "end")
self.failUnless(self.game.serial2player[3].money, self.game.bestBuyIn())
self.game.sitOut(5)
self.game.beginTurn(2)
self.check_button(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
(False, None, False, 0), # 5
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0)])
# --------------------------------------------------------------------------
def test7_specialTwoWaitForPost(self):
"""Special case where two players came in waiting to post.
"""
game = self.game
# for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
for (serial, seat) in ((1, 2), (2, 3)):
self.make_new_bot(serial, seat)
game.beginTurn(1)
self.pay_blinds()
self.game.beginTurn(2)
# (blind, missed, wait)
self.check_blinds([
('small', None, False, 0), # 1
('big', None, False, 0), # 2
])
game.autoBlindAnte(1)
game.noAutoBlindAnte(1)
game.autoBlindAnte(2)
game.noAutoBlindAnte(2)
game.sitOutNextTurn(2)
self.failUnless(self.game.state, "end")
#
# Two players came in and are waiting for
# the late blind because they attempted to enter
# either on the small blind or the dealer position.
# Fake this situation instead of playing hands that
# will lead to the same because it introduces an
# complexity that is not necessary. This case can happen
# indeed although very rarely.
#
for (serial, seat) in ((3, 0), (4, 7)):
self.make_new_player(serial, seat)
game.getPlayer(serial).wait_for = 'late'
self.game.beginTurn(3)
# (blind, missed, wait)
self.check_blinds([
('big', None, False, 0), # 1
(False, None, False, 0), # 2
(False, 'small', False, 0), # 3
('small', None, False, 0) # 4
])
# --------------------------------------------------------------------------
def test8_updateBlinds(self):
"""updateBlinds() test
"""
game = self.game
for (serial, seat) in ((1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)):
self.make_new_bot(serial, seat)
game.player_list = [1, 3, 4, 5, 6]
game.dealer_seat = 3
for (serial, blind_info) in (
(1, ("big", "n/a", False, 0)),
(2, ("late", "n/a", "first_round", 0)),
(3, (False, None, False, 0)),
(4, (False, "n/a", "late", 0)),
(5, (False, "n/a", "late", 0)),
(6, (True, None, False, 0)),
):
player = game.getPlayer(serial)
player.blind, player.missed_blind, player.wait_for, player.missed_big_blind_count = blind_info
game.updateBlinds()
self.check_blinds([
("big", "n/a", False, 0),
("late", "n/a", "first_round", 0),
(False, None, False, 0),
(False, "n/a", "late", 0),
(False, "n/a", "late", 0),
(True, None, False, 0),
])
# --------------------------------------------------------------------------
def test9_fivePlayers_missedBothBlinds_onlyBigRequired(self):
"""
Less than 6 players, player 4 missed the big and small blinds and
must pay the big blind when back in the game. The missed blind
count only ever goes to one, because the player is not passed again.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3), (5, 4)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
(False, None, False, 0), # 5
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0)])
self.game.sitOut(4)
self.game.beginTurn(2)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
(False, None, False, 0), # 2
('small', None, False, 0), # 3
(False, 'big', False, 1), # 4
('big', None, False, 0), # 5
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(3, small, 0), (5, big, 0)])
self.game.beginTurn(3)
# (blind, missed, wait)
self.check_blinds([
('big', None, False, 0), # 1
(False, None, False, 0), # 2
(False, None, False, 0), # 3
(False, 'big', False, 1), # 4
('small', None, False, 0), # 5
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(5, small, 0), (1, big, 0)])
self.assertEquals(self.game.serial2player[4].getMissedRoundCount(), 1)
self.game.sit(4)
self.game.beginTurn(4)
# (blind, missed, wait)
self.assertEquals(self.game.serial2player[4].getMissedRoundCount(), 1)
self.check_blinds([
('small', None, False, 0), # 1
('big', None, False, 0), # 2
(False, None, False, 0), # 3
('late', 'big', False, 1), # 4
(False, None, False, 0), # 5
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(1, small, 0), (2, big, 0), (4, big, 0)])
self.assertEquals(self.game.serial2player[4].getMissedRoundCount(), 0)
self.game.beginTurn(5)
# (blind, missed, wait)
self.check_blinds([
(False, None, False, 0), # 1
('small', None, False, 0), # 2
('big', None, False, 0), # 3
(False, None, False, 0), # 4
(False, None, False, 0), # 5
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(2, small, 0), (3, big, 0)])
# --------------------------------------------------------------------------
def test11_sixPlayers_fiveSitsOutForALongTime(self):
"""test11_sixPlayers_fiveSitsOutForALongTime
Tests six players where the fifth sits out for a long time and the counter runs.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((100, 0), (101, 1), (102, 2), (103, 3), (104, 4), (105, 5)):
self.make_new_bot(serial, seat)
turn = 0
missedCounterVerify = 0
missedSoFar = None
self.assertEquals(self.game.sitOut(105), True)
while missedCounterVerify < 4:
for serial in [100, 101, 102, 103, 104, 105]:
amount = self.game.maxBuyIn() - self.game.serial2player[serial].money
self.game.rebuy(serial, amount)
turn += 1
self.game.beginTurn(turn)
self.check_button(100)
self.assertEquals(self.game.isSitOut(105), True)
self.check_blinds([
(False, None, False, 0), # 100
('small', None, False, 0), # 101
('big', None, False, 0), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
(False, missedSoFar, False, missedCounterVerify), # 105
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(101, small, 0), (102, big, 0)])
turn += 1
self.assertEquals(self.game.isSitOut(105), True)
self.game.beginTurn(turn)
self.check_button(101)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
('small', None, False, 0), # 102
('big', None, False, 0), # 103
(False, None, False, 0), # 104
(False, missedSoFar, False, missedCounterVerify), # 105
])
self.pay_blinds(skipSerials = { 105 : 105 })
self.confirm_blind(self.game.turn_history, [(102, small, 0), (103, big, 0)])
turn += 1
self.assertEquals(self.game.isSitOut(105), True)
self.game.beginTurn(turn)
self.check_button(102)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, None, False, 0), # 102
('small', None, False, 0), # 103
('big', None, False, 0), # 104
(False, missedSoFar, False, missedCounterVerify), # 105
])
self.pay_blinds(skipSerials = { 105 : 105 })
self.confirm_blind(self.game.turn_history, [(103, small, 0), (104, big, 0)])
turn += 1
missedCounterVerify += 1
self.assertEquals(self.game.isSitOut(105), True)
self.game.beginTurn(turn)
self.check_button(103)
missedSoFar = 'big'
self.check_blinds([
('big', None, False, 0), # 100
(False, None, False, 0), # 101
(False, None, False, 0), # 102
(False, None, False, 0), # 103
('small', None, False, 0), # 104
(False, missedSoFar, False, missedCounterVerify), # 105
])
self.pay_blinds(skipSerials = { 105 : 105 })
self.confirm_blind(self.game.turn_history, [(104, small, 0), (100, big, 0)])
turn += 1
self.game.beginTurn(turn)
self.check_button(104)
self.assertEquals(self.game.isSitOut(105), True)
self.check_blinds([
('small', None, False, 0), # 100
('big', None, False, 0), # 101
(False, None, False, 0), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
(False, missedSoFar, False, missedCounterVerify), # 105
])
self.pay_blinds(skipSerials = { 105 : 105 })
self.confirm_blind(self.game.turn_history, [(100, small, 0), (101, big, 0)])
# --------------------------------------------------------------------------
def test12_fourPlayers_fourSitsOutForALongTime(self):
"""test12_fourPlayers_fourSitsOutForALongTime
Tests four players where the fourth sits out for a long time and the counter runs.
"""
big = self.amounts['big']
small = self.amounts['small']
for (serial, seat) in ((100, 0), (101, 1), (102, 2), (103, 3)):
self.make_new_bot(serial, seat)
turn = 0
missedCounterVerify = 0
missedSoFar = None
self.assertEquals(self.game.sitOut(103), True)
while missedCounterVerify < 4:
for serial in [100, 101, 102, 103]:
amount = self.game.maxBuyIn() - self.game.serial2player[serial].money
self.game.rebuy(serial, amount)
turn += 1
self.game.beginTurn(turn)
self.check_button(100)
self.assertEquals(self.game.isSitOut(103), True)
self.check_blinds([
(False, None, False, 0), # 100
('small', None, False, 0), # 101
('big', None, False, 0), # 102
(False, missedSoFar, False, missedCounterVerify), # 103
])
self.pay_blinds(skipSerials = { 103 : 103 })
self.confirm_blind(self.game.turn_history, [(101, small, 0), (102, big, 0)])
self.assertEquals(self.game.serial2player[103].getMissedRoundCount(),
missedCounterVerify)
turn += 1
missedCounterVerify += 1
missedSoFar = 'big'
self.assertEquals(self.game.isSitOut(103), True)
self.game.beginTurn(turn)
self.check_button(101)
self.check_blinds([
('big', None, False, 0), # 100
(False, None, False, 0), # 101
('small', None, False, 0), # 102
(False, missedSoFar, False, missedCounterVerify), # 103
])
self.pay_blinds(skipSerials = { 103 : 103 })
self.confirm_blind(self.game.turn_history, [(102, small, 0), (100, big, 0)])
self.assertEquals(self.game.serial2player[103].getMissedRoundCount(),
missedCounterVerify)
turn += 1
self.assertEquals(self.game.isSitOut(103), True)
self.game.beginTurn(turn)
self.check_button(102)
self.check_blinds([
('small', None, False, 0), # 100
('big', None, False, 0), # 101
(False, None, False, 0), # 102
(False, missedSoFar, False, missedCounterVerify), # 103
])
self.pay_blinds(skipSerials = { 103 : 103 })
self.confirm_blind(self.game.turn_history, [(100, small, 0), (101, big, 0)])
self.assertEquals(self.game.serial2player[103].getMissedRoundCount(),
missedCounterVerify)
def helperForTest13and14(self, big, small):
"""This just sets up a situation that can have two outcomes; after
sitting out for a very long time, the 102 player can sit in while
the blinds are being posted, or before they are."""
for (serial, seat) in ((100, 0), (101, 1), (102, 2), (103, 3), (104, 4), (105, 5), (106, 6)):
self.make_new_bot(serial, seat)
turn = 0
missedCounterVerify = 0
missedSoFar = None
turn += 1
self.game.beginTurn(turn)
self.check_button(100)
self.check_blinds([
(False, None, False, 0), # 100
('small', None, False, 0), # 101
('big', None, False, 0), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
(False, missedSoFar, False, missedCounterVerify), # 105
(False, None, False, 0), # 106
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(101, small, 0), (102, big, 0)])
turn += 1
self.game.beginTurn(turn)
self.check_button(101)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
('small', None, False, 0), # 102
('big', None, False, 0), # 103
(False, None, False, 0), # 104
(False, None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(102, small, 0), (103, big, 0)])
turn += 1
self.game.beginTurn(turn)
self.check_button(102)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, None, False, 0), # 102
('small', None, False, 0), # 103
('big', None, False, 0), # 104
(False, None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(103, small, 0), (104, big, 0)])
self.assertEquals(self.game.sitOut(102), True)
missedCounterVerify = 0
missedSoFar = None
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 0)
while missedCounterVerify < 4:
for serial in [100, 101, 102, 103, 104, 105, 106]:
amount = self.game.maxBuyIn() - self.game.serial2player[serial].money
self.game.rebuy(serial, amount)
turn += 1
self.game.beginTurn(turn)
self.check_button(103)
self.assertEquals(self.game.isSitOut(102), True)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, missedSoFar, False, missedCounterVerify), # 102
(False, None, False, 0), # 103
('small', None, False, 0), # 104
('big', None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds(skipSerials = { 102 : 102 })
self.confirm_blind(self.game.turn_history, [(104, small, 0), (105, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
turn += 1
self.assertEquals(self.game.isSitOut(102), True)
self.game.beginTurn(turn)
self.check_button(104)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, missedSoFar, False, missedCounterVerify), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
('small', None, False, 0), # 105
('big', None, False, 0), # 106
])
self.pay_blinds(skipSerials = { 102 : 102 })
self.confirm_blind(self.game.turn_history, [(105, small, 0), (106, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
turn += 1
self.assertEquals(self.game.isSitOut(102), True)
self.game.beginTurn(turn)
self.check_button(105)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.check_blinds([
('big', None, False, 0), # 100
(False, None, False, 0), # 101
(False, missedSoFar, False, missedCounterVerify), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
(False, None, False, 0), # 105
('small', None, False, 0), # 106
])
self.pay_blinds(skipSerials = { 102 : 102 })
self.confirm_blind(self.game.turn_history, [(106, small, 0), (100, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
turn += 1
self.assertEquals(self.game.isSitOut(102), True)
self.game.beginTurn(turn)
self.check_button(106)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.check_blinds([
('small', None, False, 0), # 100
('big', None, False, 0), # 101
(False, missedSoFar, False, missedCounterVerify), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
(False, None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds(skipSerials = { 102 : 102 })
self.confirm_blind(self.game.turn_history, [(100, small, 0), (101, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
turn += 1
missedCounterVerify += 1
missedSoFar = 'big'
self.game.beginTurn(turn)
self.check_button(100)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.assertEquals(self.game.isSitOut(102), True)
self.check_blinds([
(False, None, False, 0), # 100
('small', None, False, 0), # 101
(False, missedSoFar, False, missedCounterVerify), # 102
('big', None, False, 0), # 103
(False, None, False, 0), # 104
(False, None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds(skipSerials = { 102 : 102 })
self.confirm_blind(self.game.turn_history, [(101, small, 0), (103, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
turn += 1
self.game.beginTurn(turn)
self.check_button(101)
self.assertEquals(self.game.isSitOut(102), True)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, missedSoFar, False, missedCounterVerify), # 102
('small', None, False, 0), # 103
('big', None, False, 0), # 104
(False, None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds(skipSerials = { 102 : 102 })
self.confirm_blind(self.game.turn_history, [(103, small, 0), (104, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
return(turn, missedSoFar, missedCounterVerify)
# --------------------------------------------------------------------------
def test13_sevenPlayers_fiveSitsOutForALongTimeAfterInitialPayment_duringBlinds(self):
"""test13_sevenPlayers_fiveSitsOutForALongTimeAfterInitialPayment_duringBlinds
Tests seven players where the fifth sits out for a long time and the counter runs.
"""
big = self.amounts['big']
small = self.amounts['small']
(turn, missedSoFar, missedCounterVerify) = self.helperForTest13and14(big, small)
# end of while, now let's try to sit back in! In this test, we
# sit back in during the blind posting period.
turn += 1
self.game.beginTurn(turn)
self.check_button(103)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.assertEquals(self.game.sit(102), True)
self.check_blinds([(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, 'big', 'first_round', missedCounterVerify), # 102
(False, None, False, 0), # 103
('small', None, False, 0), # 104
('big', None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(104, small, 0), (105, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
turn += 1
self.game.beginTurn(turn)
self.check_button(104)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.assertEquals(self.game.isSit(102), True)
self.check_blinds([(False, None, False, 0), # 100
(False, None, False, 0), # 101
('big_and_dead', 'big', False, missedCounterVerify), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
('small', None, False, 0), # 105
('big', None, False, 0), # 106
])
self.pay_blinds()
# We find 102 has posted big and small, since he can now play again.
self.confirm_blind(self.game.turn_history, [(105, small, 0), (106, big, 0), (102, big, small)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 0)
turn += 1
self.game.beginTurn(turn)
self.check_button(105)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 0)
self.assertEquals(self.game.isSit(102), True)
self.check_blinds([
('big', None, False, 0), # 100
(False, None, False, 0), # 101
(False, None, False, 0), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
(False, None, False, 0), # 105
('small', None, False, 0), # 106
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(106, small, 0), (100, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 0)
# --------------------------------------------------------------------------
def test14_sevenPlayers_fiveSitsOutForALongTimeAfterInitialPayment_beforeBlinds(self):
"""test14_sevenPlayers_fiveSitsOutForALongTimeAfterInitialPayment_beforeBlinds
Tests seven players where the fifth sits out for a long time and
the counter runs. Then, he sits abck but while they are posting
blinds.
"""
big = self.amounts['big']
small = self.amounts['small']
(turn, missedSoFar, missedCounterVerify) = self.helperForTest13and14(big, small)
# end of while, now let's try to sit back in! In this test, we
# sit back in before the blinds are posted
self.assertEquals(self.game.sit(102), True)
turn += 1
self.game.beginTurn(turn)
self.check_button(103)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), missedCounterVerify)
self.assertEquals(self.game.isSit(102), True)
self.check_blinds([(False, None, False, 0), # 100
(False, None, False, 0), # 101
('big_and_dead', 'big', False, missedCounterVerify), # 102
(False, None, False, 0), # 103
('small', None, False, 0), # 104
('big', None, False, 0), # 105
(False, None, False, 0), # 106
])
self.pay_blinds()
# We find 102 has posted big and small, since he can now play again.
self.confirm_blind(self.game.turn_history, [(104, small, 0), (105, big, 0), (102, big, small)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 0)
turn += 1
self.game.beginTurn(turn)
self.check_button(104)
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 0)
self.assertEquals(self.game.isSit(102), True)
self.check_blinds([
(False, None, False, 0), # 100
(False, None, False, 0), # 101
(False, None, False, 0), # 102
(False, None, False, 0), # 103
(False, None, False, 0), # 104
('small', None, False, 0), # 105
('big', None, False, 0), # 106
])
self.pay_blinds()
self.confirm_blind(self.game.turn_history, [(105, small, 0), (106, big, 0)])
self.assertEquals(self.game.serial2player[102].getMissedRoundCount(), 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/20 pot limit
# betting structure. The variant and betting structure descriptions
# will be read from the conf/poker.holdem.xml and conf/poker.10-20-pot-limit.xml
# files.
#
game = PokerGameServer("poker.%s.xml", ['conf', '../conf', '/etc/poker-engine'])
game.verbose = 1
game.setVariant("holdem")
game.setBettingStructure("10-20-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 2000.
# The blinds are posted automatically, no action is required from
class PokerTable:
TIMEOUT_DELAY_COMPENSATION = 2
log = log.get_child('PokerTable')
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()
def _warnLock(self):
self._lock_check_locked = True
game_id = str(self.game.id) if hasattr(self, 'game') else '?'
hand_serial = str(self.game.hand_serial) if hasattr(self, 'game') else '?'
self.log.warn("Table is locked! game_id: %s, hand_serial: %s", game_id, hand_serial)
def isLocked(self):
return self._lock_check_locked
def isValid(self):
"""Returns true if the table has a factory."""
return hasattr(self, "factory")
def destroy(self):
"""Destroys the table and deletes it from factory.tables.Also informs connected avatars."""
self.log.debug("destroy table %d", self.game.id)
#
# cancel DealTimeout timer
self.cancelDealTimeout()
#
# cancel PlayerTimeout timers
self.cancelPlayerTimers()
#
# destroy factory table
if self.transient:
self.factory.destroyTable(self.game.id)
#
# broadcast TableDestroy to connected avatars
self.broadcast(PacketPokerTableDestroy(game_id=self.game.id))
#
# remove table from avatars
for avatars in self.avatar_collection.itervalues():
for avatar in avatars:
del avatar.tables[self.game.id]
#
# remove table from oberservers
for observer in self.observers:
del observer.tables[self.game.id]
#
# cut connection from and to factory
self.factory.deleteTable(self)
del self.factory
#
# kill lock check timer
self._stopLockCheck()
def getName(self, serial):
"""Returns the name to the given serial"""
avatars = self.avatar_collection.get(serial)
return avatars[0].getName() if avatars else self.factory.getName(serial)
def getPlayerInfo(self, serial):
"""Returns a PacketPlayerInfo to the given serial"""
avatars = self.avatar_collection.get(serial)
return avatars[0].getPlayerInfo() if avatars and avatars[0].user.isLogged() else self.factory.getPlayerInfo(serial)
def listPlayers(self):
"""Returns a list of names of all Players in game"""
return [
(self.getName(serial), self.game.getPlayerMoney(serial), 0,)
for serial in self.game.serialsAll()
]
def cancelDealTimeout(self):
"""If there is a dealTimeout timer in timer_info cancel and delete it"""
info = self.timer_info
if 'dealTimeout' in info:
if info["dealTimeout"].active():
info["dealTimeout"].cancel()
del info["dealTimeout"]
def beginTurn(self):
self._startLockCheck()
self.cancelDealTimeout()
if self.game.isEndOrNull():
self.historyReset()
hand_serial = self.factory.getHandSerial()
self.log.debug("Dealing hand %s/%d", self.game.name, hand_serial)
self.game.setTime(seconds())
self.game.beginTurn(hand_serial)
for player in self.game.playersAll():
player.getUserData()['ready'] = True
def historyReset(self):
self.history_index = 0
self.cache = createCache()
def toPacket(self):
return PacketPokerTable(
id=self.game.id,
name = self.game.name,
variant = self.game.variant,
betting_structure = self.game.betting_structure,
seats = self.game.max_players,
players = self.game.allCount(),
hands_per_hour = self.game.stats["hands_per_hour"],
average_pot = self.game.stats["average_pot"],
percent_flop = self.game.stats["percent_flop"],
player_timeout = self.playerTimeout,
muck_timeout = self.muckTimeout,
observers = len(self.observers),
waiting = len(self.waiting),
skin = self.skin,
currency_serial = self.currency_serial,
tourney_serial = self.tourney and self.tourney.serial or 0
)
def broadcast(self, packets):
"""Broadcast a list of packets to all connected avatars on this table."""
if type(packets) is not list:
packets = [packets]
for packet in packets:
keys = self.game.serial2player.keys()
self.log.debug("broadcast%s %s ", keys, packet)
for serial in keys:
#
# player may be in game but disconnected.
for avatar in self.avatar_collection.get(serial):
avatar.sendPacket(self.private2public(packet, serial))
for avatar in self.observers:
avatar.sendPacket(self.private2public(packet, 0))
self.factory.eventTable(self)
def private2public(self, packet, serial):
#
# cards private to each player are shown only to the player
if packet.type == PACKET_POKER_PLAYER_CARDS and packet.serial != serial:
return PacketPokerPlayerCards(
game_id = packet.game_id,
serial = packet.serial,
cards = PokerCards(packet.cards).tolist(False)
)
else:
return packet
def syncDatabase(self):
updates = {}
serial2rake = {}
reset_bet = False
for event in self.game.historyGet()[self.history_index:]:
event_type = event[0]
if event_type == "game":
pass
elif event_type == "wait_for":
pass
elif event_type == "rebuy":
pass
elif event_type == "player_list":
pass
elif event_type == "round":
pass
elif event_type == "showdown":
pass
elif event_type == "rake":
serial2rake = event[2]
elif event_type == "muck":
pass
elif event_type == "position":
pass
elif event_type == "blind_request":
pass
elif event_type == "wait_blind":
pass
elif event_type == "blind":
serial, amount, dead = event[1:]
if serial not in updates:
updates[serial] = 0
updates[serial] -= amount + dead
elif event_type == "ante_request":
pass
elif event_type == "ante":
serial, amount = event[1:]
if serial not in updates:
updates[serial] = 0
updates[serial] -= amount
elif event_type == "all-in":
pass
elif event_type == "call":
serial, amount = event[1:]
if serial not in updates:
updates[serial] = 0
updates[serial] -= amount
elif event_type == "check":
pass
elif event_type == "fold":
pass
elif event_type == "raise":
serial, amount = event[1:]
if serial not in updates:
updates[serial] = 0
updates[serial] -= amount
elif event_type == "canceled":
serial, amount = event[1:]
if serial > 0 and amount > 0:
if serial not in updates:
updates[serial] = 0
updates[serial] += amount
elif event_type == "end":
showdown_stack = event[2]
game_state = showdown_stack[0]
for (serial, share) in game_state['serial2share'].iteritems():
if serial not in updates:
updates[serial] = 0
updates[serial] += share
reset_bet = True
elif event_type == "sitOut":
pass
elif event_type == "sit":
pass
elif event_type == "leave":
pass
elif event_type == "finish":
hand_serial = event[1]
self.factory.saveHand(self.compressedHistory(self.game.historyGet()), hand_serial)
self.factory.updateTableStats(self.game, len(self.observers), len(self.waiting))
transient = 1 if self.transient else 0
self.factory.databaseEvent(event=PacketPokerMonitorEvent.HAND, param1=hand_serial, param2=transient, param3=self.game.id)
else:
self.log.warn("syncDatabase: unknown history type %s", event_type)
for (serial, amount) in updates.iteritems():
self.factory.updatePlayerMoney(serial, self.game.id, amount)
for (serial, rake) in serial2rake.iteritems():
self.factory.updatePlayerRake(self.currency_serial, serial, rake)
if reset_bet:
self.factory.resetBet(self.game.id)
def compressedHistory(self, history):
new_history = []
cached_pockets = None
cached_board = None
for event in history:
event_type = event[0]
if event_type in (
'all-in', 'wait_for','blind_request',
'muck','finish', 'leave','rebuy'
):
pass
elif event_type == 'game':
new_history.append(event)
elif event_type == 'round':
name, board, pockets = event[1:]
if pockets != cached_pockets: cached_pockets = pockets
else: pockets = None
if board != cached_board: cached_board = board
else: board = None
new_history.append((event_type, name, board, pockets))
elif event_type == 'showdown':
board, pockets = event[1:]
if pockets != cached_pockets: cached_pockets = pockets
else: pockets = None
if board != cached_board: cached_board = board
else: board = None
new_history.append((event_type, board, pockets))
elif event_type in (
'call', 'check', 'fold',
'raise', 'canceled', 'position',
'blind', 'ante', 'player_list',
'rake', 'end', 'sitOut',
):
new_history.append(event)
else:
self.log.warn("compressedHistory: unknown history type %s ", event_type)
return new_history
def delayedActions(self):
for event in self.game.historyGet()[self.history_index:]:
event_type = event[0]
if event_type == "game":
self.game_delay = {
"start": seconds(),
"delay": float(self.delays["autodeal"])
}
elif event_type in ('round', 'position', 'showdown', 'finish'):
self.game_delay["delay"] += float(self.delays[event_type])
self.log.debug("delayedActions: game estimated duration is now %s "
"and is running since %.02f seconds",
self.game_delay["delay"],
seconds() - self.game_delay["start"],
)
elif event_type == "leave":
quitters = event[1]
for serial, seat in quitters: # @UnusedVariable
self.factory.leavePlayer(serial, self.game.id, self.currency_serial)
for avatar in self.avatar_collection.get(serial)[:]:
self.seated2observer(avatar, serial)
def cashGame_kickPlayerSittingOutTooLong(self, historyToSearch):
if self.tourney: return
handIsFinished = False
# Go through the history backwards, stopping at
# self.history_index, since we expect finish to be at the end if
# it is there, and we don't want to consider previously reduced
# history.
for event in reversed(historyToSearch):
if event[0] == "finish":
handIsFinished = True
break
if handIsFinished:
for player in self.game.playersAll():
if player.getMissedRoundCount() >= self.max_missed_round:
self.kickPlayer(player.serial)
def tourneyEndTurn(self):
if not self.tourney: return
for event in self.game.historyGet()[self.history_index:]:
if event[0] == "end":
self.factory.tourneyEndTurn(self.tourney, self.game.id)
def tourneyUpdateStats(self):
if self.tourney:
self.factory.tourneyUpdateStats(self.tourney, self.game.id)
def autoDeal(self):
self.cancelDealTimeout()
if not self.allReadyToPlay():
#
# All avatars that fail to send a PokerReadyToPlay packet
# within imposed delays after sending a PokerProcessingHand
# are marked as bugous and their next PokerProcessingHand
# request will be ignored.
#
for player in self.game.playersAll():
if player.getUserData()['ready'] == False:
for avatar in self.avatar_collection.get(player.serial):
self.log.warn("Player %d marked as having a bugous "
"PokerProcessingHand protocol",
player.serial
)
avatar.bugous_processing_hand = True
self.beginTurn()
self.update()
def autoDealCheck(self, autodeal_check, delta):
self.log.debug("autoDealCheck")
self.cancelDealTimeout()
if autodeal_check > delta:
self.log.debug("Autodeal for %d scheduled in %f seconds", self.game.id, delta)
self.timer_info["dealTimeout"] = reactor.callLater(delta, self.autoDeal)
return
#
# Issue a poker message to all players that are ready
# to play.
#
serials = []
for player in self.game.playersAll():
if player.getUserData()['ready'] == True:
serials.append(player.serial)
if serials:
self.broadcastMessage(PacketPokerMessage, "Waiting for players.\nNext hand will be dealt shortly.\n(maximum %d seconds)" % int(delta), serials)
self.log.debug("AutodealCheck(2) for %d scheduled in %f seconds", self.game.id, delta)
self.timer_info["dealTimeout"] = reactor.callLater(autodeal_check, self.autoDealCheck, autodeal_check, delta - autodeal_check)
def broadcastMessage(self, message_type, message, serials=None):
if serials == None:
serials = self.game.serialsAll()
connected_serials = [serial for serial in serials if self.avatar_collection.get(serial)]
if not connected_serials:
return False
packet = message_type(game_id = self.game.id, string = message)
for serial in connected_serials:
for avatar in self.avatar_collection.get(serial):
avatar.sendPacket(packet)
return True
def scheduleAutoDeal(self):
self.cancelDealTimeout()
if self.factory.shutting_down:
self.log.debug("Not autodealing because server is shutting down")
return False
if not self.autodeal:
self.log.debug("No autodeal")
return False
if self.isRunning():
self.log.debug("Not autodealing %d because game is running", self.game.id)
return False
if self.game.state == pokergame.GAME_STATE_MUCK:
self.log.debug("Not autodealing %d because game is in muck state", self.game.id)
return False
if self.game.sitCount() < 2:
self.log.debug("Not autodealing %d because less than 2 players willing to play", self.game.id)
return False
if self.game.isTournament():
if self.tourney:
if self.tourney.state != pokertournament.TOURNAMENT_STATE_RUNNING:
self.log.debug("Not autodealing %d because in tournament state %s", self.game.id, self.tourney.state)
if self.tourney.state == pokertournament.TOURNAMENT_STATE_BREAK_WAIT:
self.broadcastMessage(PacketPokerGameMessage, "Tournament will break when the other tables finish their hand")
return False
elif not self.autodeal_temporary:
#
# Do not auto deal a table where there are only temporary
# users (i.e. bots)
#
only_temporary_users = True
for serial in self.game.serialsSit():
if not self.factory.isTemporaryUser(serial):
only_temporary_users = False
break
if only_temporary_users:
self.log.debug("Not autodealing because players are categorized as temporary")
return False
delay = self.game_delay["delay"]
if not self.allReadyToPlay() and delay > 0:
delta = (self.game_delay["start"] + delay) - seconds()
autodeal_max = float(self.delays.get("autodeal_max", 120))
delta = min(autodeal_max, max(0, delta))
self.game_delay["delay"] = (seconds() - self.game_delay["start"]) + delta
elif self.transient:
delta = int(self.delays.get("autodeal_tournament_min", 15))
if seconds() - self.game_delay["start"] > delta:
delta = 0
else:
delta = 0
self.log.debug("AutodealCheck scheduled in %f seconds", delta)
autodeal_check = max(0.01, float(self.delays.get("autodeal_check", 15)))
self.timer_info["dealTimeout"] = reactor.callLater(min(autodeal_check, delta), self.autoDealCheck, autodeal_check, delta)
return True
def updatePlayerUserData(self, serial, key, value):
if self.game.isSeated(serial):
player = self.game.getPlayer(serial)
user_data = player.getUserData()
if user_data[key] != value:
user_data[key] = value
self.update()
def allReadyToPlay(self):
status = True
notready = []
for player in self.game.playersAll():
if player.getUserData()['ready'] == False:
notready.append(str(player.serial))
status = False
if notready:
self.log.debug("allReadyToPlay: waiting for %s", ",".join(notready))
return status
def readyToPlay(self, serial):
self.updatePlayerUserData(serial, 'ready', True)
return PacketAck()
def processingHand(self, serial):
self.updatePlayerUserData(serial, 'ready', False)
return PacketAck()
def update(self):
if self.update_recursion:
self.log.warn("unexpected recursion (ignored)", exc_info=1)
return "recurse"
self.update_recursion = True
if not self.isValid():
return "not valid"
history = self.game.historyGet()
history_len = len(history)
history_tail = history[self.history_index:]
try:
self.updateTimers(history_tail)
packets, self.previous_dealer, errors = history2packets(history_tail, self.game.id, self.previous_dealer, self.cache)
for error in errors: self.log.warn("%s", error)
self.syncDatabase()
self.delayedActions()
if len(packets) > 0:
self.broadcast(packets)
self.tourneyEndTurn()
if self.isValid():
self.cashGame_kickPlayerSittingOutTooLong(history_tail)
self.scheduleAutoDeal()
finally:
if history_len != len(history):
self.log.error("%s length changed from %d to %d (i.e. %s was added)",
history,
history_len,
len(history),
history[history_len:]
)
if self.game.historyCanBeReduced():
try:
self.game.historyReduce()
except Exception:
self.log.error('history reduce error', exc_info=1)
self.history_index = len(self.game.historyGet())
self.update_recursion = False
return "ok"
def handReplay(self, avatar, hand):
history = self.factory.loadHand(hand)
if not history:
return
event_type, level, hand_serial, hands_count, time, variant, betting_structure, player_list, dealer, serial2chips = history[0] # @UnusedVariable
for player in self.game.playersAll():
avatar.sendPacketVerbose(PacketPokerPlayerLeave(
game_id = self.game.id,
serial = player.serial,
seat = player.seat
))
self.game.reset()
self.game.name = "*REPLAY*"
self.game.setVariant(variant)
self.game.setBettingStructure(betting_structure)
self.game.setTime(time)
self.game.setHandsCount(hands_count)
self.game.setLevel(level)
self.game.hand_serial = hand
for serial in player_list:
self.game.addPlayer(serial)
self.game.getPlayer(serial).money = serial2chips[serial]
self.game.sit(serial)
if self.isJoined(avatar):
avatar.join(self, reason=PacketPokerTable.REASON_HAND_REPLAY)
else:
self.joinPlayer(avatar, avatar.getSerial(), reason = PacketPokerTable.REASON_HAND_REPLAY)
serial = avatar.getSerial()
cache = createCache()
packets, previous_dealer, errors = history2packets(history, self.game.id, -1, cache) #@UnusedVariable
for packet in packets:
if packet.type == PACKET_POKER_PLAYER_CARDS and packet.serial == serial:
packet.cards = cache["pockets"][serial].toRawList()
if packet.type == PACKET_POKER_PLAYER_LEAVE:
continue
avatar.sendPacketVerbose(packet)
def isJoined(self, avatar):
serial = avatar.getSerial()
return avatar in self.observers or avatar in self.avatar_collection.get(serial)
def isSeated(self, avatar):
return self.isJoined(avatar) and self.game.isSeated(avatar.getSerial())
def isSit(self, avatar):
return self.isSeated(avatar) and self.game.isSit(avatar.getSerial())
def isSerialObserver(self, serial):
return serial in [avatar.getSerial() for avatar in self.observers]
def isOpen(self):
return self.game.is_open
def isRunning(self):
return self.game.isRunning()
def seated2observer(self, avatar, serial):
if avatar.getSerial() != serial:
self.log.warn("pokertable.seated2observer: avatar.user.serial (%d) "
"doesn't match serial argument (%d)",
avatar.getSerial(),
serial
)
self.avatar_collection.remove(serial, avatar)
self.observers.append(avatar)
def observer2seated(self, avatar):
self.observers.remove(avatar)
self.avatar_collection.add(avatar.getSerial(), avatar)
def quitPlayer(self, avatar, serial):
if self.isSit(avatar):
if self.isOpen():
self.game.sitOutNextTurn(serial)
self.game.autoPlayer(serial)
self.update()
if self.isSeated(avatar):
#
# If not on a closed table, stand up
#
if self.isOpen():
if avatar.removePlayer(self, serial):
self.seated2observer(avatar, serial)
self.factory.leavePlayer(serial, self.game.id, self.currency_serial)
self.factory.updateTableStats(self.game, len(self.observers), len(self.waiting))
else:
self.update()
else:
avatar.log.inform("cannot quit a closed table, request ignored")
return False
if self.isJoined(avatar):
#
# The player is no longer connected to the table
#
self.destroyPlayer(avatar, serial)
return True
def kickPlayer(self, serial):
player = self.game.getPlayer(serial)
seat = player and player.seat
if not self.game.removePlayer(serial):
self.log.warn("kickPlayer did not succeed in removing player %d from game %d",
serial,
self.game.id
)
return
self.factory.leavePlayer(serial, self.game.id, self.currency_serial)
self.factory.updateTableStats(self.game, len(self.observers), len(self.waiting))
for avatar in self.avatar_collection.get(serial)[:]:
self.seated2observer(avatar, serial)
self.broadcast(PacketPokerPlayerLeave(
game_id = self.game.id,
serial = serial,
seat = seat
))
def disconnectPlayer(self, avatar, serial):
if self.isSeated(avatar):
self.game.getPlayer(serial).getUserData()['ready'] = True
if self.isOpen():
#
# If not on a closed table, stand up.
#
if avatar.removePlayer(self, serial):
self.seated2observer(avatar, serial)
self.factory.leavePlayer(serial, self.game.id, self.currency_serial)
self.factory.updateTableStats(self.game, len(self.observers), len(self.waiting))
else:
self.update()
else:
#
# If on a closed table, the player
# will stay at the table, he does not
# have the option to leave.
#
pass
if self.isJoined(avatar):
#
# The player is no longer connected to the table
#
self.destroyPlayer(avatar, serial)
return True
def leavePlayer(self, avatar, serial):
if self.isSit(avatar):
if self.isOpen():
self.game.sitOutNextTurn(serial)
self.game.autoPlayer(serial)
self.update()
if self.isSeated(avatar):
#
# If not on a closed table, stand up
#
if self.isOpen():
if avatar.removePlayer(self, serial):
self.seated2observer(avatar, serial)
self.factory.leavePlayer(serial, self.game.id, self.currency_serial)
self.factory.updateTableStats(self.game, len(self.observers), len(self.waiting))
else:
self.update()
else:
self.log.warn("cannot leave a closed table")
avatar.sendPacketVerbose(PacketPokerError(
game_id = self.game.id,
serial = serial,
other_type = PACKET_POKER_PLAYER_LEAVE,
code = PacketPokerPlayerLeave.TOURNEY,
message = "Cannot leave tournament table"
))
return False
return True
def movePlayer(self, avatars, serial, to_game_id, reason=""):
avatars = avatars[:]
#
# We are safe because called from within the server under
# controlled circumstances.
#
money = self.game.serial2player[serial].money
name = self.game.serial2player[serial].name
sit_out = self.movePlayerFrom(serial, to_game_id)
for avatar in avatars:
self.destroyPlayer(avatar, serial)
other_table = self.factory.getTable(to_game_id)
for avatar in avatars:
other_table.observers.append(avatar)
other_table.observer2seated(avatar)
money_check = self.factory.movePlayer(serial, self.game.id, to_game_id)
if money_check != money:
self.log.warn("movePlayer: player %d money %d in database, %d in memory", serial, money_check, money)
for avatar in avatars:
avatar.join(other_table, reason=reason)
other_table.movePlayerTo(serial, name, money, sit_out)
other_table.sendNewPlayerInformation(serial)
if not other_table.update_recursion:
other_table.scheduleAutoDeal()
self.log.debug("player %d moved from table %d to table %d", serial, self.game.id, to_game_id)
def sendNewPlayerInformation(self, serial):
packets = self.newPlayerInformation(serial)
self.broadcast(packets)
def newPlayerInformation(self, serial):
player_info = self.getPlayerInfo(serial)
player = self.game.getPlayer(serial)
nochips = 0
packets = []
packets.append(PacketPokerPlayerArrive(
game_id = self.game.id,
serial = serial,
name = player_info.name,
url = player_info.url,
outfit = player_info.outfit,
blind = player.blind,
remove_next_turn = player.remove_next_turn,
sit_out = player.sit_out,
sit_out_next_turn = player.sit_out_next_turn,
auto = player.auto,
auto_blind_ante = player.auto_blind_ante,
wait_for = player.wait_for,
seat = player.seat
))
if self.factory.has_ladder:
packet = self.factory.getLadder(self.game.id, self.currency_serial, player.serial)
if packet.type == PACKET_POKER_PLAYER_STATS:
packets.append(packet)
packets.append(PacketPokerSeats(game_id = self.game.id, seats = self.game.seats()))
packets.append(PacketPokerPlayerChips(
game_id = self.game.id,
serial = serial,
bet = nochips,
money = self.game.getPlayer(serial).money
))
return packets
def movePlayerTo(self, serial, name, money, sit_out):
self.game.open()
self.game.addPlayer(serial,name=name)
player = self.game.getPlayer(serial)
player.setUserData(pokeravatar.DEFAULT_PLAYER_USER_DATA.copy())
player.money = money
player.buy_in_payed = True
self.game.sit(serial)
self.game.autoBlindAnte(serial)
if sit_out:
self.game.sitOut(serial)
self.game.close()
def movePlayerFrom(self, serial, to_game_id):
game = self.game
player = game.getPlayer(serial)
self.broadcast(PacketPokerTableMove(
game_id = game.id,
serial = serial,
to_game_id = to_game_id,
seat = player.seat)
)
sit_out = game.isSitOut(serial)
game.removePlayer(serial)
return sit_out
def possibleObserverLoggedIn(self, avatar, serial):
if not self.game.getPlayer(serial):
return False
self.observer2seated(avatar)
self.game.comeBack(serial)
return True
def joinPlayer(self, avatar, serial, reason=""):
#
# Nothing to be done except sending all packets.
# Useful in disconnected mode to resume a session.
if self.isJoined(avatar):
avatar.join(self, reason=reason)
return True
#
# Next, test to see if we have reached the server-wide maximum for
# seated/observing players.
if not self.game.isSeated(avatar.getSerial()) and self.factory.joinedCountReachedMax():
self.log.crit("joinPlayer: %d cannot join game %d because the server is full", serial, self.game.id)
avatar.sendPacketVerbose(PacketPokerError(
game_id = self.game.id,
serial = serial,
other_type = PACKET_POKER_TABLE_JOIN,
code = PacketPokerTableJoin.FULL,
message = "This server has too many seated players and observers."
))
return False
#
# Next, test to see if joining this table will cause the avatar to
# exceed the maximum permitted by the server.
if len(avatar.tables) >= self.factory.simultaneous:
self.log.crit("joinPlayer: %d seated at %d tables (max %d)" % (serial, len(avatar.tables), self.factory.simultaneous))
return False
#
# Player is now an observer, unless he is seated
# at the table.
self.factory.joinedCountIncrease()
if not self.game.isSeated(avatar.getSerial()):
self.observers.append(avatar)
else:
self.avatar_collection.add(serial, avatar)
#
# If it turns out that the player is seated
# at the table already, presumably because he
# was previously disconnected from a tournament
# or an ongoing game.
came_back = False
if self.isSeated(avatar):
#
# Sit back immediately, as if we just seated
came_back = self.game.comeBack(serial)
avatar.join(self, reason=reason)
if came_back:
#
# it does not hurt to re-sit the avatar
# but is needed for other clients to notice
# the arrival
avatar.sitPlayer(self, serial)
return True
def seatPlayer(self, avatar, serial, seat):
if not self.isJoined(avatar):
self.log.error("player %d can't seat before joining", serial)
return False
if self.isSeated(avatar):
self.log.inform("player %d is already seated", serial)
return False
if not self.game.canAddPlayer(serial):
self.log.warn("table refuses to seat player %d", serial)
return False
if seat != -1 and seat not in self.game.seats_left:
self.log.warn("table refuses to seat player %d at seat %d", serial, seat)
return False
amount = self.game.buyIn() if self.transient else 0
minimum_amount = (self.currency_serial, self.game.buyIn())
if not self.factory.seatPlayer(serial, self.game.id, amount, minimum_amount):
return False
self.observer2seated(avatar)
avatar.addPlayer(self, seat)
if amount > 0:
avatar.setMoney(self, amount)
self.factory.updateTableStats(self.game, len(self.observers), len(self.waiting))
return True
def sitOutPlayer(self, avatar, serial):
if not self.isSeated(avatar):
self.log.warn("player %d can't sit out before getting a seat", serial)
return False
#
# silently do nothing if already sit out
if not self.isSit(avatar):
return True
avatar.sitOutPlayer(self, serial)
return True
def chatPlayer(self, avatar, serial, message):
if not self.isJoined(avatar):
self.log.error("player %d can't chat before joining", serial)
return False
message = self.chatFilter(message)
self.broadcast(PacketPokerChat(
game_id = self.game.id,
serial = serial,
message = message+"\n"
))
self.factory.chatMessageArchive(serial, self.game.id, message)
def chatFilter(self, message):
return self.factory.chat_filter.sub('poker', message) \
if self.factory.chat_filter \
else message
def autoBlindAnte(self, avatar, serial, auto):
if not self.isSeated(avatar):
self.log.warn("player %d can't set auto blind/ante before getting a seat", serial)
return False
return avatar.autoBlindAnte(self, serial, auto)
def muckAccept(self, avatar, serial):
if not self.isSeated(avatar):
self.log.warn("player %d can't accept muck before getting a seat", serial)
return False
return self.game.muck(serial, want_to_muck=True)
def muckDeny(self, avatar, serial):
if not self.isSeated(avatar):
self.log.warn("player %d can't deny muck before getting a seat", serial)
return False
return self.game.muck(serial, want_to_muck=False)
def sitPlayer(self, avatar, serial):
if not self.isSeated(avatar):
self.log.warn("player %d can't sit before getting a seat", serial)
return False
return avatar.sitPlayer(self, serial)
def destroyPlayer(self, avatar, serial):
self.factory.joinedCountDecrease()
if avatar in self.observers:
self.observers.remove(avatar)
else:
self.avatar_collection.remove(serial, avatar)
del avatar.tables[self.game.id]
def buyInPlayer(self, avatar, amount):
if not self.isSeated(avatar):
self.log.warn("player %d can't bring money to a table before getting a seat", avatar.getSerial())
return False
if avatar.getSerial() in self.game.serialsPlaying():
self.log.warn("player %d can't bring money while participating in a hand", avatar.getSerial())
return False
if self.transient:
self.log.warn("player %d can't bring money to a transient table", avatar.getSerial())
return False
player = self.game.getPlayer(avatar.getSerial())
if player and player.isBuyInPayed():
self.log.warn("player %d already payed the buy-in", avatar.getSerial())
return False
amount = self.factory.buyInPlayer(avatar.getSerial(), self.game.id, self.currency_serial, max(amount, self.game.buyIn()))
return avatar.setMoney(self, amount)
def rebuyPlayerRequest(self, avatar, amount):
if not self.isSeated(avatar):
self.log.warn("player %d can't rebuy to a table before getting a seat", avatar.getSerial())
return False
serial = avatar.getSerial()
player = self.game.getPlayer(serial)
if not player.isBuyInPayed():
self.log.warn("player %d can't rebuy before paying the buy in", serial)
return False
maximum = self.game.maxBuyIn() - self.game.getPlayerMoney(serial)
if maximum <= 0:
self.log.warn("player %d can't bring more money to the table", serial)
return False
if amount == 0:
amount = self.game.buyIn()
amount = self.factory.buyInPlayer(serial, self.game.id, self.currency_serial, min(amount, maximum))
if amount == 0:
self.log.warn("player %d is broke and cannot rebuy", serial)
return False
if self.tourney and not self.tourney.isRebuyAllowed(serial):
return False
if not self.game.rebuy(serial, amount):
self.log.warn("player %d rebuy denied", serial)
return False
if self.tourney:
self.tourney.reenterGame(self.game.id, serial)
self.broadcast(PacketPokerRebuy(
game_id = self.game.id,
serial = serial,
amount = amount
))
return True
def playerWarningTimer(self, serial):
info = self.timer_info
if self.game.isRunning() and serial == self.game.getSerialInPosition():
timeout = self.playerTimeout / 2
#
# Compensate the communication lag by always giving the avatar
# an extra 2 seconds to react. The warning says that there only is
# N seconds left but the server will actually timeout after N + TIMEOUT_DELAY_COMPENSATION
# seconds.
self.broadcast(PacketPokerTimeoutWarning(
game_id = self.game.id,
serial = serial,
timeout = timeout
))
info["playerTimeout"] = reactor.callLater(timeout+self.TIMEOUT_DELAY_COMPENSATION, self.playerTimeoutTimer, serial)
else:
self.updatePlayerTimers()
def playerTimeoutTimer(self, serial):
self.log.debug("player %d times out" % serial)
if self.game.isRunning() and serial == self.game.getSerialInPosition():
if self.timeout_policy == "sitOut":
self.game.sitOutNextTurn(serial)
self.game.autoPlayer(serial)
elif self.timeout_policy == "fold":
self.game.autoPlayerFoldNextTurn(serial)
self.game.autoPlayer(serial)
self.broadcast(PacketPokerAutoFold(
game_id=self.game.id,
serial=serial
))
else:
self.log.error("unknown timeout_policy %s", self.timeout_policy)
self.broadcast(PacketPokerTimeoutNotice(
game_id=self.game.id,
serial=serial
))
self.update()
else:
self.updatePlayerTimers()
def muckTimeoutTimer(self):
self.log.debug("muck timed out")
# timer expires, force muck on muckables not responding
for serial in self.game.muckable_serials[:]:
self.game.muck(serial, want_to_muck=True)
self.cancelMuckTimer()
self.update()
def cancelMuckTimer(self):
info = self.timer_info
timer = info["muckTimeout"]
if timer != None:
if timer.active(): timer.cancel()
info["muckTimeout"] = None
def cancelPlayerTimers(self):
info = self.timer_info
timer = info["playerTimeout"]
if timer != None:
if timer.active(): timer.cancel()
info["playerTimeout"] = None
info["playerTimeoutSerial"] = 0
info["playerTimeoutTime"] = None
def updateTimers(self, history=()):
self.updateMuckTimer(history)
self.updatePlayerTimers()
def updateMuckTimer(self, history):
for event in reversed(history):
if event[0] == "muck":
self.cancelMuckTimer()
self.timer_info["muckTimeout"] = reactor.callLater(self.muckTimeout, self.muckTimeoutTimer)
return
def updatePlayerTimers(self):
info = self.timer_info
if self.game.isRunning():
serial = self.game.getSerialInPosition()
#
# any event in the game resets the player timeout
if (
info["playerTimeoutSerial"] != serial or
len(self.game.historyGet()) > self.history_index
):
timer = info["playerTimeout"]
if timer != None and timer.active(): timer.cancel()
timer = reactor.callLater(self.playerTimeout / 2, self.playerWarningTimer, serial)
info["playerTimeout"] = timer
info["playerTimeoutSerial"] = serial
info["playerTimeoutTime"] = self.playerTimeout + seconds()
else:
#
# if the game is not running, cancel the previous timeout
self.cancelPlayerTimers()
def getCurrentTimeoutWarning(self):
info = self.timer_info
packet = None
if (
self.game.isRunning() and
info["playerTimeout"] is not None and
info["playerTimeoutSerial"] != 0 and
info["playerTimeoutTime"] is not None and
info["playerTimeout"].active()
):
serial = info["playerTimeoutSerial"]
timeout = int(info["playerTimeoutTime"] - seconds())
packet = PacketPokerTimeoutWarning(
game_id = self.game.id,
serial = serial,
timeout = timeout
)
return packet
def _gameCallbackTourneyEndTurn(self,game_id,game_type,*args):
if game_type == 'end':
self.tourneyEndTurn()
def _gameCallbackTourneyUpdateStats(self,game_id,game_type,*args):
if game_type == 'end':
self.tourneyUpdateStats()
def _initLockCheck(self):
self._lock_check = LockCheck(20 * 60, self._warnLock)
self.game.registerCallback(self.__lockCheckEndCallback)
self._lock_check_locked = False
def _startLockCheck(self):
if self._lock_check:
self._lock_check.start()
def _stopLockCheck(self):
if self._lock_check:
self._lock_check.stop()
def __lockCheckEndCallback(self, game_id, event_type, *args):
if event_type == 'end':
self._stopLockCheck()
class TestSit(unittest.TestCase):
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")
def tearDown(self):
del self.game
def log(self, string):
print string
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
def pay_blinds(self):
game = self.game
for serial in game.serialsAll():
game.autoBlindAnte(serial)
for serial in game.serialsAll():
game.noAutoBlindAnte(serial)
def bot_players(self):
game = self.game
for serial in game.serialsAll():
game.botPlayer(serial)
def check_blinds(self, descriptions):
players = self.game.playersAll()
players.sort(key=lambda i: i.seat)
for player in players:
(blind, missed, wait) = descriptions.pop(0)
if(blind != player.blind or missed != player.missed_blind or wait != player.wait_for):
print "check_blinds FAILED actual %s != from expected %s" % ( (player.blind, player.missed_blind, player.wait_for), (blind, missed, wait) )
self.fail()
def test1_player_arrive_during_blinds(self):
for (serial, seat) in ((1, 0), (2, 1)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
#
# New player comes in while others are paying the blinds.
# He does not participate in the game.
#
for (serial, seat) in ((3, 2),):
self.make_new_player(serial, seat)
self.pay_blinds()
self.assertEqual(self.game.player_list, [1,2])
self.bot_players()
#
# Next round the new player is waiting for the late blind, and pays it
#
self.game.beginTurn(2)
self.assertEqual(self.game.player_list, [1,2,3])
self.pay_blinds()
def test2_player_sitout_during_blinds(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
#
# player 1 deals
# player 2 small blind
# player 3 big blind
#
# player 3 sits out while player 2 is in position : she is
# marked as sit_out_next_turn because she is not in position
#
self.assertEqual(2, self.game.getSerialInPosition())
self.game.sitOutNextTurn(3)
player3 = self.game.getPlayer(3)
self.assertEqual("big", player3.blind)
self.failUnless(player3.isSit())
self.assertEqual(True, player3.sit_out_next_turn)
#
# player 3 sits back and because she is sit_out_next_turn,
# which can only happen in the blind/ante round if she
# sat out after being included in the player list for the
# turn, she is sit. By contrast, if she had been sit
# during the blind/ante turn, she would have been marked
# wait_for = "first_round"
#
self.game.sit(3)
self.assertEqual(False, player3.sit_out_next_turn)
self.assertEqual(False, player3.wait_for)
class TestSit(unittest.TestCase):
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")
def tearDown(self):
del self.game
def log(self, string):
print string
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
def pay_blinds(self):
game = self.game
for serial in game.serialsAll():
game.autoBlindAnte(serial)
for serial in game.serialsAll():
game.noAutoBlindAnte(serial)
def bot_players(self):
game = self.game
for serial in game.serialsAll():
game.botPlayer(serial)
def check_blinds(self, descriptions):
players = self.game.playersAll()
players.sort(key=lambda i: i.seat)
for player in players:
(blind, missed, wait) = descriptions.pop(0)
if blind != player.blind or missed != player.missed_blind or wait != player.wait_for:
print "check_blinds FAILED actual %s != from expected %s" % (
(player.blind, player.missed_blind, player.wait_for),
(blind, missed, wait),
)
self.fail()
def test1_player_arrive_during_blinds(self):
for (serial, seat) in ((1, 0), (2, 1)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
#
# New player comes in while others are paying the blinds.
# He does not participate in the game.
#
for (serial, seat) in ((3, 2),):
self.make_new_player(serial, seat)
self.pay_blinds()
self.assertEqual(self.game.player_list, [1, 2])
self.bot_players()
#
# Next round the new player is waiting for the late blind
#
self.game.beginTurn(2)
self.assertEqual(self.game.player_list, [1, 2])
self.pay_blinds()
#
# This round the new player is in
#
self.game.beginTurn(3)
self.assertEqual(self.game.player_list, [1, 2, 3])
self.pay_blinds()
def test2_player_sitout_during_blinds(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
#
# player 1 deals
# player 2 small blind
# player 3 big blind
#
# player 3 sits out while player 2 is in position : she is
# marked as sit_out_next_turn because she is not in position
#
self.assertEqual(2, self.game.getSerialInPosition())
self.game.sitOutNextTurn(3)
player3 = self.game.getPlayer(3)
self.assertEqual("big", player3.blind)
self.failUnless(player3.isSit())
self.assertEqual(True, player3.sit_out_next_turn)
#
# player 3 sits back and because she is sit_out_next_turn,
# which can only happen in the blind/ante round if she
# sat out after being included in the player list for the
# turn, she is sit. By contrast, if she had been sit
# during the blind/ante turn, she would have been marked
# wait_for = "first_round"
#
self.game.sit(3)
self.assertEqual(False, player3.sit_out_next_turn)
self.assertEqual(False, player3.wait_for)
#
# 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
class TestBuyIn(unittest.TestCase):
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")
def tearDown(self):
del self.game
def log(self, string):
print string
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.noAutoBlindAnte(serial)
def pay_blinds(self):
game = self.game
for serial in game.serialsAll():
game.autoBlindAnte(serial)
for serial in game.serialsAll():
game.noAutoBlindAnte(serial)
def test1(self):
game = self.game
self.failUnless(game.addPlayer(1))
self.failIf(game.payBuyIn(1, game.buyIn() - 1))
self.failIf(game.getPlayer(1).buy_in_payed)
self.failIf(game.payBuyIn(1, game.maxBuyIn() + 1))
self.failIf(game.getPlayer(1).buy_in_payed)
self.failUnless(game.payBuyIn(1, game.bestBuyIn()))
self.failUnless(game.getPlayer(1).buy_in_payed)
self.failUnless(game.addPlayer(2))
self.failUnless(game.payBuyIn(2, game.maxBuyIn()))
self.failUnless(game.getPlayer(2).buy_in_payed)
def test2(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
self.failIf(self.game.rebuy(300000, self.game.bestBuyIn()))
self.failUnless(self.game.rebuy(1, 1))
self.assertEqual(self.game.getPlayer(1).rebuy, 1)
self.failIf(self.game.rebuy(1, self.game.maxBuyIn()))
self.assertEqual(self.game.getPlayer(1).rebuy, 1)
self.failUnless(self.game.rebuy(1, 1))
self.assertEqual(self.game.getPlayer(1).rebuy, 2)
self.pay_blinds()
self.assertEqual(self.game.getPlayer(1).rebuy, 0)
money = self.game.getPlayerMoney(1)
self.failUnless(self.game.rebuy(1, 1))
self.assertEqual(self.game.getPlayerMoney(1), money + 1)
class TestMuck(unittest.TestCase):
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 6d Ah 6d 3h 8s As", # distributed from the end
]
self.game.shuffler = PokerPredefinedDecks(
map(lambda deck: self.game.eval.string2card(split(deck)),
predefined_decks))
def tearDown(self):
del self.game
def log(self, string):
print string
def make_new_bot(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.autoMuck(serial, pokergame.AUTO_MUCK_NEVER)
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
self.game.autoBlindAnte(serial)
def check_blinds(self, descriptions):
players = self.game.playersAll()
players.sort(key=lambda i: i.seat)
fail = False
for player in players:
(blind, missed, wait) = descriptions.pop(0)
if (blind != player.blind or missed != player.missed_blind
or wait != player.wait_for):
print "check_blinds FAILED actual %s != from expected %s" % (
(player.blind, player.missed_blind, player.wait_for),
(blind, missed, wait))
fail = True
else:
print "check_blinds %s == %s" % (
(player.blind, player.missed_blind, player.wait_for),
(blind, missed, wait))
if fail:
self.fail()
def test1(self):
"""
won fold, auto_muck always
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
self.game.fold(4)
self.game.fold(1)
self.game.fold(2)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 3)
self.failUnless(self.game.isWinnerBecauseFold())
self.failUnless(self.game.getPlayer(3).hand.areHidden())
def test2(self):
"""
won fold, auto_muck lose, decided to muck
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.autoMuck(3, pokergame.AUTO_MUCK_LOSE)
self.game.beginTurn(1)
self.game.fold(4)
self.game.fold(1)
self.game.fold(2)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 3)
self.failUnless(self.game.isWinnerBecauseFold())
self.assertEqual(self.game.muckable_serials, [3])
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial=3, want_to_muck=True)
self.failUnless(self.game.getPlayer(3).hand.areHidden())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test3(self):
"""
won fold, auto_muck lose, decided not to muck (ie show)
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.autoMuck(3, pokergame.AUTO_MUCK_LOSE)
self.game.beginTurn(1)
self.game.fold(4)
self.game.fold(1)
self.game.fold(2)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 3)
self.failUnless(self.game.isWinnerBecauseFold())
self.assertEqual(self.game.muckable_serials, [3])
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial=3, want_to_muck=False)
self.failUnless(self.game.getPlayer(3).hand.areVisible())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test4(self):
"""
fake deck
player p2 wins against p1, p1 is muckable, auto_muck_never, p1 mucks
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial=1, want_to_muck=True)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 2)
self.failUnless(self.game.getPlayer(1).hand.areHidden())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test5(self):
"""
fake deck
player p2 wins against p1, p1 is muckable, auto_muck_never, p1 does not muck
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial=1, want_to_muck=False)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 2)
self.failUnless(self.game.getPlayer(1).hand.areVisible())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test6(self):
"""
game canceled because blind not payed, player p2 get her/his blind back
"""
for (serial, seat) in ((1, 0), (2, 1)):
self.make_new_player(serial, seat)
self.game.noAutoBlindAnte(serial)
self.game.beginTurn(1)
self.game.blind(2)
self.game.sitOut(1)
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
self.assertEqual(len(self.game.winners), 0)
def test0(self):
"""
game canceled explicitly, player p2 get her/his blind back
"""
for (serial, seat) in ((1, 0), (2, 1)):
self.make_new_player(serial, seat)
self.game.noAutoBlindAnte(serial)
self.game.beginTurn(1)
self.game.blind(2)
self.game.is_directing = False
self.game.sitOut(1)
self.game.canceled(2, self.game.smallBlind())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
self.assertEqual(len(self.game.winners), 0)
class TestMuck(unittest.TestCase):
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 6d Ah 6d 3h 8s As", # distributed from the end
]
self.game.shuffler = PokerPredefinedDecks(map(lambda deck: self.game.eval.string2card(split(deck)), predefined_decks))
def tearDown(self):
del self.game
def log(self, string):
print string
def make_new_bot(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.autoMuck(serial, pokergame.AUTO_MUCK_NEVER)
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
self.game.autoBlindAnte(serial)
def check_blinds(self, descriptions):
players = self.game.playersAll()
players.sort(key=lambda i: i.seat)
fail = False
for player in players:
(blind, missed, wait) = descriptions.pop(0)
if(blind != player.blind or missed != player.missed_blind or wait != player.wait_for):
print "check_blinds FAILED actual %s != from expected %s" % ( (player.blind, player.missed_blind, player.wait_for), (blind, missed, wait) )
fail = True
else:
print "check_blinds %s == %s" % ( (player.blind, player.missed_blind, player.wait_for), (blind, missed, wait) )
if fail:
self.fail()
def test1(self):
"""
won fold, auto_muck always
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
self.game.fold(4)
self.game.fold(1)
self.game.fold(2)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 3)
self.failUnless(self.game.isWinnerBecauseFold())
self.failUnless(self.game.getPlayer(3).hand.areHidden())
def test2(self):
"""
won fold, auto_muck lose, decided to muck
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.autoMuck(3, pokergame.AUTO_MUCK_LOSE)
self.game.beginTurn(1)
self.game.fold(4)
self.game.fold(1)
self.game.fold(2)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 3)
self.failUnless(self.game.isWinnerBecauseFold())
self.assertEqual(self.game.muckable_serials, [3])
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial = 3, want_to_muck = True)
self.failUnless(self.game.getPlayer(3).hand.areHidden())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test3(self):
"""
won fold, auto_muck lose, decided not to muck (ie show)
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.autoMuck(3, pokergame.AUTO_MUCK_LOSE)
self.game.beginTurn(1)
self.game.fold(4)
self.game.fold(1)
self.game.fold(2)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 3)
self.failUnless(self.game.isWinnerBecauseFold())
self.assertEqual(self.game.muckable_serials, [3])
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial = 3, want_to_muck = False)
self.failUnless(self.game.getPlayer(3).hand.areVisible())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test4(self):
"""
fake deck
player p2 wins against p1, p1 is muckable, auto_muck_never, p1 mucks
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial = 1, want_to_muck = True)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 2)
self.failUnless(self.game.getPlayer(1).hand.areHidden())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test5(self):
"""
fake deck
player p2 wins against p1, p1 is muckable, auto_muck_never, p1 does not muck
"""
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_bot(serial, seat)
self.game.beginTurn(1)
self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
self.game.muck(serial = 1, want_to_muck = False)
self.assertEqual(len(self.game.winners), 1)
self.assertEqual(self.game.winners[0], 2)
self.failUnless(self.game.getPlayer(1).hand.areVisible())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
def test6(self):
"""
game canceled because blind not payed, player p2 get her/his blind back
"""
for (serial, seat) in ((1, 0), (2, 1)):
self.make_new_player(serial, seat)
self.game.noAutoBlindAnte(serial)
self.game.beginTurn(1)
self.game.blind(2)
self.game.sitOut(1)
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
self.assertEqual(len(self.game.winners), 0)
def test0(self):
"""
game canceled explicitly, player p2 get her/his blind back
"""
for (serial, seat) in ((1, 0), (2, 1)):
self.make_new_player(serial, seat)
self.game.noAutoBlindAnte(serial)
self.game.beginTurn(1)
self.game.blind(2)
self.game.is_directing = False
self.game.sitOut(1)
self.game.canceled(2, self.game.smallBlind())
self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
self.assertEqual(len(self.game.winners), 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")
class TestPosition(unittest.TestCase):
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 tearDown(self):
del self.game
def log(self, string):
print string
def make_cards(self, *args):
return PokerCards(poker_eval.string2card(args))
def make_new_player(self, i, initial_money=_initial_money):
self.assert_(self.game.addPlayer(i))
player = self.game.serial2player[i]
player.money = initial_money
player.auto_play = 0
player.buy_in_payed = True
self.assert_(self.game.sit(i))
player.auto_blind_ante = True
def test1(self):
"""
Five players, they check/call during rounds and start over.
Players
serials 1 2 3 4 5
seats 0 1 2 3 4
positions 0 1 2 3 4
"""
game = self.game
player = {}
for serial in xrange(1, 6):
player[serial] = serial - 1
self.make_new_player(serial)
#
# First turn, everyone checks and stays in game
#
game.beginTurn(1)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[1]) # dealer
self.assertEqual(game.last_to_talk, player[3]) # big blind
for serial in (4, 5, 1, 2):
self.assertEqual(game.position, player[serial])
game.call(serial)
self.assertEqual(game.position, player[3])
game.check(3) # big blind
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
for serial in (2, 3, 4, 5, 1):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Second turn, everyone folds games end prematurely
#
game.beginTurn(2)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[2]) # dealer
self.assertEqual(game.last_to_talk, player[4]) # big blind
for serial in (5, 1, 2, 3):
self.assertEqual(game.position, player[serial])
self.assertEqual(game.fold(serial), True)
self.assertEqual(game.state, "end")
#
# Third turn, a new player comes in during the turn, two
# players in game. The new player is ignored.
#
game.beginTurn(3)
self.make_new_player(6)
player[6] = 5
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[3]) # dealer
self.assertEqual(game.last_to_talk, player[5]) # big blind
self.assertEqual(game.position, player[1])
game.call(1)
for serial in (2, 3, 4):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.position, player[5])
game.check(5)
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
self.assertEqual(
game.position, player[5]
) # next to the dealer is gone, therefore it's the next to him
for serial in (5, 1):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Fourth turn, we now have six players in game, the
# newcomer pays the big blind
#
game.beginTurn(4)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[4]) # dealer
self.assertEqual(game.last_to_talk, player[6]) # big blind
self.assertEqual(game.position, player[1])
game.call(1)
for serial in (2, 3, 4, 5):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.position, player[6])
game.check(6)
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
self.assertEqual(
game.position, player[6]
) # next to the dealer is gone, therefore it's the next to him
for serial in (6, 1):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Fifth turn, a player (the dealer) leaves in the middle
# of the game, auto_play takes over.
#
game.beginTurn(5)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[5]) # dealer
self.assertEqual(game.last_to_talk, player[1]) # big blind
for serial in (2, 3):
self.assertEqual(game.position, player[serial])
game.fold(serial)
game.removePlayer(5)
game.autoPlayer(5)
for serial in (4, 6):
self.assertEqual(game.position, player[serial])
game.call(serial)
self.assertEqual(game.position, player[1])
game.check(1)
for stage in ("flop", "turn", "river"):
self.assertEqual(game.state, stage)
self.assertEqual(game.last_to_talk, player[4])
self.assertEqual(
game.position, player[6]
) # next to the dealer is gone, therefore it's the next to him
for serial in (6, 1, 4):
self.assertEqual(game.position, player[serial])
game.check(serial)
self.assertEqual(game.state, "end")
#
# Sixth turn, everyone folds and game ends prematurely.
# player[5] is gone for good, discarded at the end of the
# previous turn.
#
player[6] -= 1
game.beginTurn(6)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[6]) # dealer
self.assertEqual(game.last_to_talk, player[2]) # big blind
for serial in (3, 4, 6, 1):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.state, "end")
#
# Seventh turn, the dealer passes to player[1] again
#
game.beginTurn(7)
self.assertEqual(game.state, "pre-flop")
self.assertEqual(game.dealer, player[1]) # dealer
self.assertEqual(game.last_to_talk, player[3]) # big blind
for serial in (4, 6, 1, 2):
self.assertEqual(game.position, player[serial])
game.fold(serial)
self.assertEqual(game.state, "end")
def test2(self):
"""
getRequestedAction and setPlayerBlind tests
"""
game = self.game
for serial in xrange(1, 5):
self.failUnless(game.addPlayer(serial))
self.failUnless(game.payBuyIn(serial, game.maxBuyIn()))
self.failUnless(game.sit(serial))
self.failUnless(game.addPlayer(5))
self.assertEqual(game.getRequestedAction(5), "buy-in")
self.failUnless(game.payBuyIn(5, game.maxBuyIn()))
self.assertEqual(game.getRequestedAction(5), None)
game.getPlayer(5).money = 1
self.assertEqual(game.getRequestedAction(5), "rebuy")
self.failUnless(game.rebuy(5, game.bestBuyIn()))
self.assertEqual(game.getRequestedAction(5), None)
self.failUnless(game.sit(5))
#
# turn 1
#
game.beginTurn(8)
self.assertEqual(game.state, "blindAnte")
self.assertEqual(game.getRequestedAction(2), "blind_ante")
(amount, dead, state) = game.blindAmount(2)
game.blind(2, amount, dead)
self.assertEqual(game.getRequestedAction(3), "blind_ante")
(amount, dead, state) = game.blindAmount(3)
game.blind(3, amount, dead)
self.assertEqual(game.getRequestedAction(4), "play")
for serial in xrange(1, 6):
game.botPlayer(serial)
#
# turn 2,3,4
#
self.failUnless(game.sitOut(4))
game.beginTurn(9)
game.beginTurn(10)
game.beginTurn(11)
for serial in xrange(1, 6):
game.interactivePlayer(serial)
#
# player 4 back in the game must pay the big blind
#
self.failUnless(game.sit(4))
game.beginTurn(12)
self.assertEqual(game.state, "blindAnte")
self.assertEqual(game.getRequestedAction(2), "blind_ante")
(amount, dead, state) = game.blindAmount(2)
game.blind(2, amount, dead)
self.assertEqual(game.getRequestedAction(3), "blind_ante")
(amount, dead, state) = game.blindAmount(3)
game.blind(3, amount, dead)
self.assertEqual(game.getRequestedAction(4), "blind_ante")
game.setPlayerBlind(4, "big_and_dead")
self.assertEqual(game.getRequestedAction(4), "blind_ante")
class TestBuyIn(unittest.TestCase):
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")
def tearDown(self):
del self.game
def log(self, string):
print string
def make_new_player(self, serial, seat):
game = self.game
self.failUnless(game.addPlayer(serial, seat))
self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
self.failUnless(game.sit(serial))
game.botPlayer(serial)
game.noAutoBlindAnte(serial)
def pay_blinds(self):
game = self.game
for serial in game.serialsAll():
game.autoBlindAnte(serial)
for serial in game.serialsAll():
game.noAutoBlindAnte(serial)
def test1(self):
game = self.game
self.failUnless(game.addPlayer(1))
self.failIf(game.payBuyIn(1, game.buyIn() - 1))
self.failIf(game.getPlayer(1).buy_in_payed)
self.failIf(game.payBuyIn(1, game.maxBuyIn() + 1))
self.failIf(game.getPlayer(1).buy_in_payed)
self.failUnless(game.payBuyIn(1, game.bestBuyIn()))
self.failUnless(game.getPlayer(1).buy_in_payed)
self.failUnless(game.addPlayer(2))
self.failUnless(game.payBuyIn(2, game.maxBuyIn()))
self.failUnless(game.getPlayer(2).buy_in_payed)
def test2(self):
for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
self.make_new_player(serial, seat)
self.game.beginTurn(1)
self.failIf(self.game.rebuy(300000, self.game.bestBuyIn()))
self.failUnless(self.game.rebuy(1, 1))
self.assertEqual(self.game.getPlayer(1).rebuy, 1)
self.failIf(self.game.rebuy(1, self.game.maxBuyIn()))
self.assertEqual(self.game.getPlayer(1).rebuy, 1)
self.failUnless(self.game.rebuy(1, 1))
self.assertEqual(self.game.getPlayer(1).rebuy, 2)
self.pay_blinds()
self.assertEqual(self.game.getPlayer(1).rebuy, 0)
money = self.game.getPlayerMoney(1)
self.failUnless(self.game.rebuy(1, 1))
self.assertEqual(self.game.getPlayerMoney(1), money + 1)
def setUp(self):
self.game = PokerGameServer("poker.%s.xml", [ "../conf", "../conf" ])
self.game.verbose = 3
self.game.setVariant("holdem")
self.game.setBettingStructure(".10-.25-no-limit")
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")
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)
def setUp(self, variant, betting):
self.game = PokerGameServer("poker.%s.xml", [path.join(TESTS_PATH, '../conf')])
self.game.setVariant(variant)
self.game.setBettingStructure(betting)
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
