def test_generate_possible_actions(self):
state1 = restore_game_state(TwoPlayerSample.round_state)
self.eq(TwoPlayerSample.valid_actions,
self.emu.generate_possible_actions(state1))
state2 = restore_game_state(ThreePlayerGameStateSample.round_state)
self.eq(ThreePlayerGameStateSample.valid_actions,
self.emu.generate_possible_actions(state2))
def test_restore_game_state_two_players_game(self):
restored = restore_game_state(TwoPlayerSample.round_state)
table = restored['table']
players = restored['table'].seats.players
self.eq(1, restored['next_player'])
self.eq(2, restored['street'])
self.eq(3, restored['round_count'])
self.eq(5, restored['small_blind_amount'])
self.eq(0, table.dealer_btn)
self.eq(0, table.sb_pos())
self.eq(1, table.bb_pos())
self.eq(['5d', '9d', '6h', 'Kc'],
[str(card) for card in table.get_community_card()])
self._assert_deck(table.deck,
[Card.from_str(s) for s in ['5d', '9d', '6h', 'Kc']])
self.eq(2, len(players))
self._assert_player([
'p1', 'tojrbxmkuzrarnniosuhct', [], 65,
TwoPlayerSample.p1_round_action_histories,
TwoPlayerSample.p1_action_histories, 0, 35
], players[0])
self._assert_player([
'p2', 'pwtwlmfciymjdoljkhagxa', [], 80,
TwoPlayerSample.p2_round_action_histories,
TwoPlayerSample.p2_action_histories, 0, 20
], players[1])
def test_apply_action(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
"tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state,
"pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.apply_action(game_state, "call", 15)
self.eq(Const.Street.RIVER, game_state["street"])
self.eq(TwoPlayerSample.p1_action_histories, \
game_state["table"].seats.players[0].round_action_histories[Const.Street.TURN])
self.eq(2, len(events))
self.eq("event_new_street", events[0]["type"])
self.eq("event_ask_player", events[1]["type"])
game_state, events = self.emu.apply_action(game_state, "call", 0)
self.eq(1, len(events))
self.eq("event_ask_player", events[0]["type"])
game_state, events = self.emu.apply_action(game_state, "call", 0)
self.eq(1, len(events))
self.eq("event_round_finish", events[0]["type"])
def test_restore_game_state_three_players_game(self):
restored = restore_game_state(ThreePlayerGameStateSample.round_state)
table = restored['table']
players = restored['table'].seats.players
self.eq(0, restored['next_player'])
self.eq(2, restored['street'])
self.eq(2, restored['round_count'])
self.eq(5, restored['small_blind_amount'])
self.eq(1, table.dealer_btn)
self.eq(1, table.sb_pos())
self.eq(2, table.bb_pos())
self.eq(['Jh', '8c', '2d', '4h'],
[str(card) for card in table.get_community_card()])
self._assert_deck(table.deck,
[Card.from_str(s) for s in ['Jh', '8c', '2d', '4h']])
self.eq(3, len(players))
self._assert_player([
'p1', 'ruypwwoqwuwdnauiwpefsw', [], 35,
ThreePlayerGameStateSample.p1_round_action_histories,
ThreePlayerGameStateSample.p1_action_histories, 0, 60
], players[0])
self._assert_player([
'p2', 'sqmfwdkpcoagzqxpxnmxwm', [], 0,
ThreePlayerGameStateSample.p2_round_action_histories,
ThreePlayerGameStateSample.p2_action_histories, 1, 50
], players[1])
self._assert_player([
'p3', 'uxrdiwvctvilasinweqven', [], 85,
ThreePlayerGameStateSample.p3_round_action_histories,
ThreePlayerGameStateSample.p3_action_histories, 0, 70
], players[2])
def test_replace_community_card(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
to_card = lambda s: Card.from_str(s)
cards = [to_card(c) for c in ['SA', 'DA', 'CA', 'HA']]
processed = replace_community_card(game_state, cards)
self.eq(cards, processed["table"].get_community_card())
self.neq(cards, game_state["table"].get_community_card())
def test_start_new_round_exclude_no_money_players(self):
uuids = ["ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm", "uxrdiwvctvilasinweqven"]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
original = reduce(lambda state, uuid: attach_hole_card_from_deck(state, uuid), uuids, game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
[self.emu.register_player(uuid, FoldMan()) for uuid in uuids]
# case1: second player cannot pay small blind
finish_state, events = self.emu.apply_action(original, "fold")
finish_state["table"].seats.players[0].stack = 11
stacks = [p.stack for p in finish_state["table"].seats.players]
game_state, events = self.emu.start_new_round(finish_state)
self.eq(2, game_state["table"].dealer_btn)
self.eq(1, game_state["next_player"])
self.eq(stacks[1] - sb_amount - ante, game_state["table"].seats.players[1].stack)
self.eq(stacks[2] - sb_amount * 2 - ante, game_state["table"].seats.players[2].stack)
self.eq(PayInfo.FOLDED, game_state["table"].seats.players[0].pay_info.status)
self.eq(sb_amount * 3 + ante * 2, GameEvaluator.create_pot(game_state["table"].seats.players)[0]["amount"])
# case2: third player cannot pay big blind
finish_state, events = self.emu.apply_action(original, "fold")
finish_state["table"].seats.players[1].stack = 16
stacks = [p.stack for p in finish_state["table"].seats.players]
game_state, events = self.emu.start_new_round(finish_state)
self.eq(2, game_state["table"].dealer_btn)
self.eq(0, game_state["next_player"])
self.eq(stacks[0] - sb_amount - ante, game_state["table"].seats.players[0].stack)
self.eq(stacks[2] - sb_amount * 2 - ante, game_state["table"].seats.players[2].stack)
self.eq(PayInfo.FOLDED, game_state["table"].seats.players[1].pay_info.status)
self.eq(PayInfo.PAY_TILL_END, game_state["table"].seats.players[0].pay_info.status)
self.eq(sb_amount * 3 + ante * 2, GameEvaluator.create_pot(game_state["table"].seats.players)[0]["amount"])
def test_restore_game_state_three_players_game(self):
restored = restore_game_state(ThreePlayerGameStateSample.round_state)
table = restored["table"]
players = restored["table"].seats.players
self.eq(0, restored["next_player"])
self.eq(2, restored["street"])
self.eq(2, restored["round_count"])
self.eq(5, restored["small_blind_amount"])
self.eq(1, table.dealer_btn)
self.eq(1, table.sb_pos())
self.eq(2, table.bb_pos())
self.eq(['HJ', 'C8', 'D2', 'H4'],
[str(card) for card in table.get_community_card()])
self._assert_deck(table.deck,
[Card.from_str(s) for s in ['HJ', 'C8', 'D2', 'H4']])
self.eq(3, len(players))
self._assert_player(
["p1", "ruypwwoqwuwdnauiwpefsw", [], 35, ThreePlayerGameStateSample.p1_round_action_histories, \
ThreePlayerGameStateSample.p1_action_histories, 0, 60], players[0])
self._assert_player(
["p2", "sqmfwdkpcoagzqxpxnmxwm", [], 0, ThreePlayerGameStateSample.p2_round_action_histories, \
ThreePlayerGameStateSample.p2_action_histories, 1, 50], players[1])
self._assert_player(
["p3", "uxrdiwvctvilasinweqven", [], 85, ThreePlayerGameStateSample.p3_round_action_histories, \
ThreePlayerGameStateSample.p3_action_histories, 0, 70], players[2])
def test_run_until_game_finish_when_one_player_is_left(self):
uuids = [
"ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm",
"uxrdiwvctvilasinweqven"
]
holecards = [[Card.from_str(s) for s in ss]
for ss in [["C2", "C3"], ["HA", "CA"], ["D5", "H6"]]]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
game_state = reduce(
lambda state, item: attach_hole_card(state, item[0], item[1]),
zip(uuids, holecards), game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
p1_acts = [("fold", 0), ("call", 10), ('call', 0), ('call', 10),
("fold", 0)]
p2_acts = []
p3_acts = [("raise", 10)]
players = [TestPlayer(acts) for acts in [p1_acts, p2_acts, p3_acts]]
[
self.emu.register_player(uuid, player)
for uuid, player in zip(uuids, players)
]
game_state["table"].deck.deck.append(Card.from_str("C7"))
game_state, events = self.emu.run_until_game_finish(game_state)
self.eq("event_game_finish", events[-1]["type"])
self.eq(0, game_state["table"].seats.players[0].stack)
self.eq(0, game_state["table"].seats.players[1].stack)
self.eq(292, game_state["table"].seats.players[2].stack)
def test_attach_hole_card_from_deck(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
self.eq(48, game_state["table"].deck.size())
processed1 = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
processed2 = attach_hole_card_from_deck(processed1, "pwtwlmfciymjdoljkhagxa")
self.eq(44, processed2["table"].deck.size())
self.eq(48, game_state["table"].deck.size())
def test_apply_action(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
'tojrbxmkuzrarnniosuhct')
game_state = attach_hole_card_from_deck(game_state,
'pwtwlmfciymjdoljkhagxa')
self.emu.set_game_rule(2, 10, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player('tojrbxmkuzrarnniosuhct', FoldMan())
self.emu.register_player('pwtwlmfciymjdoljkhagxa', FoldMan())
game_state, events = self.emu.apply_action(game_state, 'call', 15)
self.eq(Const.Street.RIVER, game_state['street'])
self.eq(
TwoPlayerSample.p1_action_histories,
game_state['table'].seats.players[0].round_action_histories[
Const.Street.TURN])
self.eq(2, len(events))
self.eq('event_new_street', events[0]['type'])
self.eq('event_ask_player', events[1]['type'])
game_state, events = self.emu.apply_action(game_state, 'call', 0)
self.eq(1, len(events))
self.eq('event_ask_player', events[0]['type'])
game_state, events = self.emu.apply_action(game_state, 'call', 0)
self.eq(1, len(events))
self.eq('event_round_finish', events[0]['type'])
def test_start_new_round(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
"tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state,
"pwtwlmfciymjdoljkhagxa")
p1, p2 = FoldMan(), FoldMan()
self.emu.set_game_rule(2, 10, 5, 0)
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
# run until round finish
game_state, event = self.emu.apply_action(game_state, "call", 15)
game_state, event = self.emu.apply_action(game_state, "call", 0)
game_state, event = self.emu.apply_action(game_state, "call", 0)
game_state, events = self.emu.start_new_round(game_state)
self.eq(4, game_state["round_count"])
self.eq(1, game_state["table"].dealer_btn)
self.eq(0, game_state["street"])
self.eq(0, game_state["next_player"])
self.eq("event_new_street", events[0]["type"])
self.eq("event_ask_player", events[1]["type"])
self.eq("preflop", events[0]["street"])
self.eq("tojrbxmkuzrarnniosuhct", events[1]["uuid"])
def test_start_new_round(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
'tojrbxmkuzrarnniosuhct')
game_state = attach_hole_card_from_deck(game_state,
'pwtwlmfciymjdoljkhagxa')
p1, p2 = FoldMan(), FoldMan()
self.emu.set_game_rule(2, 10, 5, 0)
self.emu.register_player('tojrbxmkuzrarnniosuhct', FoldMan())
self.emu.register_player('pwtwlmfciymjdoljkhagxa', FoldMan())
# run until round finish
game_state, event = self.emu.apply_action(game_state, 'call', 15)
game_state, event = self.emu.apply_action(game_state, 'call', 0)
game_state, event = self.emu.apply_action(game_state, 'call', 0)
game_state, events = self.emu.start_new_round(game_state)
self.eq(4, game_state['round_count'])
self.eq(1, game_state['table'].dealer_btn)
self.eq(0, game_state['street'])
self.eq(0, game_state['next_player'])
self.eq('event_new_street', events[0]['type'])
self.eq('event_ask_player', events[1]['type'])
self.eq('preflop', events[0]['street'])
self.eq('tojrbxmkuzrarnniosuhct', events[1]['uuid'])
def test_blind_structure(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
'tojrbxmkuzrarnniosuhct')
game_state = attach_hole_card_from_deck(game_state,
'pwtwlmfciymjdoljkhagxa')
self.emu.set_game_rule(2, 10, 5, 0)
self.emu.set_blind_structure({5: {'ante': 5, 'small_blind': 60}})
p1 = TestPlayer([('fold', 0), ('raise', 55), ('call', 0)])
p2 = TestPlayer([('call', 15), ('call', 55), ('fold', 0)])
self.emu.register_player('tojrbxmkuzrarnniosuhct', p1)
self.emu.register_player('pwtwlmfciymjdoljkhagxa', p2)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(65, game_state['table'].seats.players[0].stack)
self.eq(135, game_state['table'].seats.players[1].stack)
game_state, events = self.emu.start_new_round(game_state)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(120, game_state['table'].seats.players[0].stack)
self.eq(80, game_state['table'].seats.players[1].stack)
game_state, events = self.emu.start_new_round(game_state)
self.eq('event_game_finish', events[0]['type'])
self.eq(0, game_state['table'].seats.players[0].stack)
self.eq(80, game_state['table'].seats.players[1].stack)
def test_run_until_game_finish_when_one_player_is_left(self):
uuids = [
'ruypwwoqwuwdnauiwpefsw', 'sqmfwdkpcoagzqxpxnmxwm',
'uxrdiwvctvilasinweqven'
]
holecards = [[Card.from_str(s) for s in ss]
for ss in [['2c', '3c'], ['Ah', 'Ac'], ['5d', '6d']]]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
game_state = reduce(
lambda state, item: attach_hole_card(state, item[0], item[1]),
zip(uuids, holecards), game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
p1_acts = [('fold', 0), ('call', 10), ('call', 0), ('call', 10),
('fold', 0)]
p2_acts = []
p3_acts = [('raise', 10)]
players = [TestPlayer(acts) for acts in [p1_acts, p2_acts, p3_acts]]
[
self.emu.register_player(uuid, player)
for uuid, player in zip(uuids, players)
]
game_state['table'].deck.deck.append(Card.from_str('7c'))
game_state, events = self.emu.run_until_game_finish(game_state)
self.eq('event_game_finish', events[-1]['type'])
self.eq(0, game_state['table'].seats.players[0].stack)
self.eq(0, game_state['table'].seats.players[1].stack)
self.eq(292, game_state['table'].seats.players[2].stack)
def test_replace_community_card(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
to_card = lambda s: Card.from_str(s)
cards = [to_card(c) for c in ['SA', 'DA', 'CA', 'HA']]
processed = replace_community_card(game_state, cards)
self.eq(cards, processed["table"].get_community_card())
self.neq(cards, game_state["table"].get_community_card())
def test_start_new_round_exclude_no_money_players(self):
uuids = ["ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm", "uxrdiwvctvilasinweqven"]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
original = reduce(lambda state, uuid: attach_hole_card_from_deck(state, uuid), uuids, game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
[self.emu.register_player(uuid, FoldMan()) for uuid in uuids]
# case1: second player cannot pay small blind
finish_state, events = self.emu.apply_action(original, "fold")
finish_state["table"].seats.players[0].stack = 11
stacks = [p.stack for p in finish_state["table"].seats.players]
game_state, events = self.emu.start_new_round(finish_state)
self.eq(2, game_state["table"].dealer_btn)
self.eq(1, game_state["next_player"])
self.eq(stacks[1]-sb_amount-ante, game_state["table"].seats.players[1].stack)
self.eq(stacks[2]-sb_amount*2-ante, game_state["table"].seats.players[2].stack)
self.eq(PayInfo.FOLDED, game_state["table"].seats.players[0].pay_info.status)
self.eq(sb_amount*3 + ante*2, GameEvaluator.create_pot(game_state["table"].seats.players)[0]["amount"])
# case2: third player cannot pay big blind
finish_state, events = self.emu.apply_action(original, "fold")
finish_state["table"].seats.players[1].stack = 16
stacks = [p.stack for p in finish_state["table"].seats.players]
game_state, events = self.emu.start_new_round(finish_state)
self.eq(2, game_state["table"].dealer_btn)
self.eq(0, game_state["next_player"])
self.eq(stacks[0]-sb_amount-ante, game_state["table"].seats.players[0].stack)
self.eq(stacks[2]-sb_amount*2-ante, game_state["table"].seats.players[2].stack)
self.eq(PayInfo.FOLDED, game_state["table"].seats.players[1].pay_info.status)
self.eq(PayInfo.PAY_TILL_END, game_state["table"].seats.players[0].pay_info.status)
self.eq(sb_amount*3 + ante*2, GameEvaluator.create_pot(game_state["table"].seats.players)[0]["amount"])
def test_blind_structure(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
"tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state,
"pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
self.emu.set_blind_structure({5: {"ante": 5, "small_blind": 60}})
p1 = TestPlayer([("fold", 0), ('raise', 55), ('call', 0)])
p2 = TestPlayer([("call", 15), ("call", 55), ('fold', 0)])
self.emu.register_player("tojrbxmkuzrarnniosuhct", p1)
self.emu.register_player("pwtwlmfciymjdoljkhagxa", p2)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(65, game_state["table"].seats.players[0].stack)
self.eq(135, game_state["table"].seats.players[1].stack)
game_state, events = self.emu.start_new_round(game_state)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(120, game_state["table"].seats.players[0].stack)
self.eq(80, game_state["table"].seats.players[1].stack)
game_state, events = self.emu.start_new_round(game_state)
self.eq("event_game_finish", events[0]["type"])
self.eq(0, game_state["table"].seats.players[0].stack)
self.eq(80, game_state["table"].seats.players[1].stack)
def restore_state(hole_card, round_state):
game_state = restore_game_state(round_state)
for player in game_state["table"].seats.players:
game_state = attach_hole_card_from_deck(game_state, player.uuid)
my_hole_card = gen_cards(hole_card)
me = game_state["table"].seats.players[game_state["next_player"]]
me.hole_card = my_hole_card
return game_state
def test_attach_hole_card_from_deck(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
self.eq(48, game_state["table"].deck.size())
processed1 = attach_hole_card_from_deck(game_state,
"tojrbxmkuzrarnniosuhct")
processed2 = attach_hole_card_from_deck(processed1,
"pwtwlmfciymjdoljkhagxa")
self.eq(44, processed2["table"].deck.size())
self.eq(48, game_state["table"].deck.size())
def setup_game_state(round_state, my_hole_card):
game_state = restore_game_state(round_state)
for player_info in round_state['seats']:
if uuid == self.uuid:
# Hole card of my player should be fixed. Because we know it.
game_state = attach_hole_card(game_state, uuid, my_hole_card)
else:
# We don't know hole card of opponents. So attach them at random from deck.
game_state = attach_hole_card_from_deck(game_state, uuid)
def get_game_state(round_state, hole_card, uuid):
game_state = restore_game_state(round_state)
for player_info in round_state['seats']:
uuid_new = player_info['uuid']
if uuid_new == uuid:
game_state = attach_hole_card(game_state, uuid, hole_card)
else:
game_state = attach_hole_card_from_deck(game_state, uuid_new)
return game_state
def _setup_game_state(self, round_state):
game_state = restore_game_state(round_state)
for player in game_state['table'].seats.players:
if self.my_uuid == player.uuid:
game_state = attach_hole_card(game_state, player.uuid,
self.my_hole_card)
else:
game_state = attach_hole_card_from_deck(
game_state, player.uuid)
return game_state
def test_last_round_judge(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
self.emu.set_game_rule(2, 3, 5, 0)
self.false(self.emu._is_last_round(game_state, self.emu.game_rule))
game_state['street'] = Const.Street.FINISHED
self.true(self.emu._is_last_round(game_state, self.emu.game_rule))
game_state['round_count'] = 2
self.false(self.emu._is_last_round(game_state, self.emu.game_rule))
game_state['table'].seats.players[0].stack = 0
self.true(self.emu._is_last_round(game_state, self.emu.game_rule))
def do_best_simulation(self, next_state, next_state_vec, next_state_stats):
# pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(next_state)
# pp.pprint('*********************************************')
game_state = restore_game_state(next_state)
possible_actions = self.emulator.generate_possible_actions(game_state)
good_actions = self.good_moves(
possible_actions, next_state['seats'][self.my_seat]['stack'])
best_reward = -1500 * 9
for action in good_actions:
# print(action)
try:
next_next_game_state = self.emulator.apply_action(
game_state, action['action'], action['amount'])
next_next_state = next_next_game_state[1][-1]['round_state']
# next_next_state = next_next_game_state['action_histories']
# pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(next_next_state)
if next_next_state['street'] in ['showdown', 'finished', 4, 5]:
best_reward = max(
best_reward,
next_next_state['seats'][self.my_seat]['stack'] -
self.start_round_stack)
else:
next_next_game_state = restore_game_state(next_next_state)
hole_card = attach_hole_card_from_deck(
next_next_game_state, self.uuid)
next_state_stats.update(hole_card, next_next_state)
next_next_state_vec = self.stats.calc_fine_params(
hole_card, next_next_state)
next_next_actions = self.emulator.generate_possible_actions(
next_next_game_state)
best_reward = max(
best_reward,
self.find_best_strat(
next_next_actions,
next_next_state_vec,
next_next_state['seats'][self.my_seat]['stack'],
)[1])
except:
continue
return best_reward
def test_attach_hole_card(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
to_card = lambda s: Card.from_str(s)
hole1, hole2 = [to_card(c) for c in ["SA", "DA"]], [to_card(c) for c in ["HK", "C2"]]
processed1 = attach_hole_card(game_state, "tojrbxmkuzrarnniosuhct", hole1)
processed2 = attach_hole_card(processed1, "pwtwlmfciymjdoljkhagxa", hole2)
players = processed2["table"].seats.players
self.eq(hole1, players[0].hole_card)
self.eq(hole2, players[1].hole_card)
self.eq([0,0], [len(p.hole_card) for p in game_state["table"].seats.players])
def _setup_game_state(self, round_state, my_hole_card):
game_state = restore_game_state(round_state)
game_state['table'].deck.shuffle()
player_uuids = [player_info['uuid'] for player_info in round_state['seats']]
for uuid in player_uuids:
if uuid == self.uuid:
game_state = attach_hole_card(game_state, uuid, gen_cards(my_hole_card)) # attach my holecard
else:
game_state = attach_hole_card_from_deck(game_state, uuid) # attach opponents holecard at random
return game_state
def declare_action(self, valid_actions, hole_card, round_state):
game_state = restore_game_state(round_state)
# decide action by using some simulation result
updated_state, events = self.emulator.apply_action(game_state, "fold")
# updated_state, events = self.emulator.run_until_round_finish(game_state)
# updated_state, events = self.emulator.run_until_game_finish(game_state)
if self.is_good_simulation_result(updated_state):
return # you would declare CALL or RAISE action
else:
return "fold", 0
def test_replace_community_card(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
def to_card(s):
return Card.from_str(s)
cards = [to_card(c) for c in ['As', 'Ad', 'Ac', 'Ah']]
processed = replace_community_card(game_state, cards)
self.eq(cards, processed['table'].get_community_card())
self.neq(cards, game_state['table'].get_community_card())
def setup_game_state(round_state, my_hole_cards, opponent_hole_cards, my_uuid):
game_state = restore_game_state(round_state)
for player_info in round_state['seats']:
uuid = player_info['uuid']
if uuid == my_uuid:
game_state = attach_hole_card(game_state, uuid, my_hole_cards)
else:
game_state = attach_hole_card(game_state, uuid,
opponent_hole_cards)
return game_state
def _setup_game_state(self, round_state, my_hole_card):
game_state = restore_game_state(round_state)
game_state['table'].deck.shuffle()
player_uuids = [player_info['uuid'] for player_info in round_state['seats']]
for uuid in player_uuids:
if uuid == self.uuid:
game_state = attach_hole_card(game_state, uuid, gen_cards(my_hole_card)) # attach my holecard
else:
game_state = attach_hole_card_from_deck(game_state, uuid) # attach opponents holecard at random
return game_state
def test_last_round_judge(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
self.emu.set_game_rule(2, 3, 5, 0)
self.false(self.emu._is_last_round(game_state, self.emu.game_rule))
game_state["street"] = Const.Street.FINISHED
self.true(self.emu._is_last_round(game_state, self.emu.game_rule))
game_state["round_count"] = 2
self.false(self.emu._is_last_round(game_state, self.emu.game_rule))
game_state["table"].seats.players[0].stack = 0
self.true(self.emu._is_last_round(game_state, self.emu.game_rule))
def test_apply_action_when_game_finished(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 3, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.apply_action(game_state, "fold")
self.emu.apply_action(game_state, "fold")
def test_apply_action_when_game_finished(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 3, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.apply_action(game_state, "fold")
self.emu.apply_action(game_state, "fold")
def test_run_until_round_finish_when_already_finished(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
p1 = TestPlayer([("fold", 0)])
p2 = TestPlayer([("call", 15)])
self.emu.register_player("tojrbxmkuzrarnniosuhct", p1)
self.emu.register_player("pwtwlmfciymjdoljkhagxa", p2)
game_state, events = self.emu.run_until_round_finish(game_state)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(0, len(events))
def test_run_until_round_finish_when_already_finished(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
p1 = TestPlayer([("fold", 0)])
p2 = TestPlayer([("call", 15)])
self.emu.register_player("tojrbxmkuzrarnniosuhct", p1)
self.emu.register_player("pwtwlmfciymjdoljkhagxa", p2)
game_state, events = self.emu.run_until_round_finish(game_state)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(0, len(events))
def test_run_until_game_finish(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 1)
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.run_until_game_finish(game_state)
self.eq("event_game_finish", events[-1]["type"])
self.eq(114, game_state["table"].seats.players[0].stack)
self.eq(86, game_state["table"].seats.players[1].stack)
def test_run_until_game_finish(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 1)
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.run_until_game_finish(game_state)
self.eq("event_game_finish", events[-1]["type"])
self.eq(114, game_state["table"].seats.players[0].stack)
self.eq(86, game_state["table"].seats.players[1].stack)
def _setup_game_state(self, round_state, my_hole_card):
game_state = restore_game_state(round_state)
game_state['table'].deck.shuffle()
players_uuid = [
player_info['uuid'] for player_info in round_state['seats']
]
for uuid in players_uuid:
if uuid == self.uuid:
game_state = attach_hole_card(game_state, uuid,
gen_cards(my_hole_card))
else:
game_state = attach_hole_card_from_deck(game_state, uuid)
return game_state
def test_apply_action_game_finish_detect(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state,
'tojrbxmkuzrarnniosuhct')
game_state = attach_hole_card_from_deck(game_state,
'pwtwlmfciymjdoljkhagxa')
self.emu.set_game_rule(2, 3, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player('tojrbxmkuzrarnniosuhct', FoldMan())
self.emu.register_player('pwtwlmfciymjdoljkhagxa', FoldMan())
game_state, events = self.emu.apply_action(game_state, 'fold')
self.eq('event_game_finish', events[-1]['type'])
def test_run_until_round_finish(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
p1 = TestPlayer([("fold", 0)])
p2 = TestPlayer([("call", 15)])
self.emu.register_player("tojrbxmkuzrarnniosuhct", p1)
self.emu.register_player("pwtwlmfciymjdoljkhagxa", p2)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq("event_new_street", events[0]["type"])
self.eq("event_ask_player", events[1]["type"])
self.eq("event_round_finish", events[2]["type"])
def test_start_new_round_game_finish_judge(self):
uuids = ["ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm", "uxrdiwvctvilasinweqven"]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
original = reduce(lambda state, uuid: attach_hole_card_from_deck(state, uuid), uuids, game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
[self.emu.register_player(uuid, FoldMan()) for uuid in uuids]
finish_state, events = self.emu.apply_action(original, "fold")
finish_state["table"].seats.players[2].stack = 11
finish_state["table"].seats.players[1].stack = 16
game_state, events = self.emu.start_new_round(finish_state)
self.eq(1, len(events))
self.eq("event_game_finish", events[0]["type"])
def test_run_until_game_finish_when_final_round(self):
uuids = ["ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm", "uxrdiwvctvilasinweqven"]
holecards = [[Card.from_str(s) for s in ss] for ss in [["C2","C3"],["HA","CA"],["D5","H6"]]]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
game_state = reduce(lambda state, item: attach_hole_card(state, item[0], item[1]), zip(uuids, holecards), game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
[self.emu.register_player(uuid, FoldMan()) for uuid in uuids]
game_state["table"].deck.deck.append(Card.from_str("C7"))
game_state, events = self.emu.run_until_game_finish(game_state)
self.eq("event_game_finish", events[-1]["type"])
self.eq(10, game_state["round_count"])
self.eq(35, game_state["table"].seats.players[0].stack)
self.eq(0, game_state["table"].seats.players[1].stack)
self.eq(265, game_state["table"].seats.players[2].stack)
def test_start_new_round_exclude_no_money_players2(self):
uuids = ["ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm", "uxrdiwvctvilasinweqven"]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
original = reduce(lambda state, uuid: attach_hole_card_from_deck(state, uuid), uuids, game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
[self.emu.register_player(uuid, FoldMan()) for uuid in uuids]
# case1: second player cannot pay small blind
finish_state, events = self.emu.apply_action(original, "fold")
finish_state["table"].seats.players[2].stack = 6
stacks = [p.stack for p in finish_state["table"].seats.players]
game_state, events = self.emu.start_new_round(finish_state)
self.eq(0, game_state["table"].dealer_btn)
self.eq(1, game_state["table"].sb_pos())
self.eq(1, game_state["next_player"])
def test_apply_action_start_next_round(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 4, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.apply_action(game_state, "fold")
self.eq(120, game_state["table"].seats.players[0].stack)
self.eq(80, game_state["table"].seats.players[1].stack)
game_state, events = self.emu.apply_action(game_state, "raise", 20)
self.eq("event_ask_player", events[-1]["type"])
self.eq(100, game_state["table"].seats.players[0].stack)
self.eq(70, game_state["table"].seats.players[1].stack)
def test_restore_game_state_two_players_game(self):
restored = restore_game_state(TwoPlayerSample.round_state)
table = restored["table"]
players = restored["table"].seats.players
self.eq(1, restored["next_player"])
self.eq(2, restored["street"])
self.eq(3, restored["round_count"])
self.eq(5, restored["small_blind_amount"])
self.eq(0, table.dealer_btn)
self.eq(0, table.sb_pos())
self.eq(1, table.bb_pos())
self.eq(['D5', 'D9', 'H6', 'CK'], [str(card) for card in table.get_community_card()])
self._assert_deck(table.deck, [Card.from_str(s) for s in ['D5', 'D9', 'H6', 'CK']])
self.eq(2, len(players))
self._assert_player(["p1", "tojrbxmkuzrarnniosuhct", [], 65, TwoPlayerSample.p1_round_action_histories,\
TwoPlayerSample.p1_action_histories, 0, 35], players[0])
self._assert_player(["p2", "pwtwlmfciymjdoljkhagxa", [], 80, TwoPlayerSample.p2_round_action_histories,\
TwoPlayerSample.p2_action_histories, 0, 20], players[1])
def test_run_until_game_finish_when_one_player_is_left(self):
uuids = ["ruypwwoqwuwdnauiwpefsw", "sqmfwdkpcoagzqxpxnmxwm", "uxrdiwvctvilasinweqven"]
holecards = [[Card.from_str(s) for s in ss] for ss in [["C2","C3"],["HA","CA"],["D5","H6"]]]
game_state = restore_game_state(ThreePlayerGameStateSample.round_state)
game_state = reduce(lambda state, item: attach_hole_card(state, item[0], item[1]), zip(uuids, holecards), game_state)
sb_amount, ante = 5, 7
self.emu.set_game_rule(3, 10, sb_amount, ante)
p1_acts = [("fold",0), ("call", 10), ('call', 0), ('call', 10), ("fold",0)]
p2_acts = []
p3_acts = [("raise", 10)]
players = [TestPlayer(acts) for acts in [p1_acts, p2_acts, p3_acts]]
[self.emu.register_player(uuid, player) for uuid, player in zip(uuids, players)]
game_state["table"].deck.deck.append(Card.from_str("C7"))
game_state, events = self.emu.run_until_game_finish(game_state)
self.eq("event_game_finish", events[-1]["type"])
self.eq(0, game_state["table"].seats.players[0].stack)
self.eq(0, game_state["table"].seats.players[1].stack)
self.eq(292, game_state["table"].seats.players[2].stack)
def test_restore_game_state_three_players_game(self):
restored = restore_game_state(ThreePlayerGameStateSample.round_state)
table = restored["table"]
players = restored["table"].seats.players
self.eq(0, restored["next_player"])
self.eq(2, restored["street"])
self.eq(2, restored["round_count"])
self.eq(5, restored["small_blind_amount"])
self.eq(1, table.dealer_btn)
self.eq(1, table.sb_pos())
self.eq(2, table.bb_pos())
self.eq(['HJ', 'C8', 'D2', 'H4'], [str(card) for card in table.get_community_card()])
self._assert_deck(table.deck, [Card.from_str(s) for s in ['HJ', 'C8', 'D2', 'H4']])
self.eq(3, len(players))
self._assert_player(["p1", "ruypwwoqwuwdnauiwpefsw", [], 35, ThreePlayerGameStateSample.p1_round_action_histories,\
ThreePlayerGameStateSample.p1_action_histories, 0, 60], players[0])
self._assert_player(["p2", "sqmfwdkpcoagzqxpxnmxwm", [], 0, ThreePlayerGameStateSample.p2_round_action_histories,\
ThreePlayerGameStateSample.p2_action_histories, 1, 50], players[1])
self._assert_player(["p3", "uxrdiwvctvilasinweqven", [], 85, ThreePlayerGameStateSample.p3_round_action_histories,\
ThreePlayerGameStateSample.p3_action_histories, 0, 70], players[2])
def test_run_until_round_finish_game_finish_detect(self):
uuids = ["tojrbxmkuzrarnniosuhct", "pwtwlmfciymjdoljkhagxa"]
holecards = [[Card.from_str(s) for s in ss] for ss in [["CA", "D2"], ["C8", "H5"]]]
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = reduce(lambda a,e: attach_hole_card(a, e[0], e[1]), zip(uuids, holecards), game_state)
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
p1 = TestPlayer([("raise", 65)])
p2 = TestPlayer([("call", 15), ("call", 65)])
self.emu.register_player("tojrbxmkuzrarnniosuhct", p1)
self.emu.register_player("pwtwlmfciymjdoljkhagxa", p2)
game_state["table"].deck.deck.append(Card.from_str("C7"))
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq("event_new_street", events[0]["type"])
self.eq("event_ask_player", events[1]["type"])
self.eq("event_ask_player", events[2]["type"])
self.eq("event_round_finish", events[3]["type"])
self.eq("event_game_finish", events[4]["type"])
self.eq(0, events[4]["players"][0]["stack"])
self.eq(200, events[4]["players"][1]["stack"])
def test_replace_community_card_from_deck(self):
origianl = restore_game_state(TwoPlayerSample.round_state)
origianl["street"] = Const.Street.PREFLOP
game_state = replace_community_card_from_deck(origianl)
self.eq(48, game_state["table"].deck.size())
self.eq(0, len(game_state["table"].get_community_card()))
origianl["street"] = Const.Street.FLOP
game_state = replace_community_card_from_deck(origianl)
self.eq(45, game_state["table"].deck.size())
self.eq(3, len(game_state["table"].get_community_card()))
origianl["street"] = Const.Street.TURN
game_state = replace_community_card_from_deck(origianl)
self.eq(44, game_state["table"].deck.size())
self.eq(4, len(game_state["table"].get_community_card()))
origianl["street"] = Const.Street.RIVER
game_state = replace_community_card_from_deck(origianl)
self.eq(43, game_state["table"].deck.size())
self.eq(5, len(game_state["table"].get_community_card()))
def test_start_new_round(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
p1, p2 = FoldMan(), FoldMan()
self.emu.set_game_rule(2, 10, 5, 0)
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
# run until round finish
game_state, event = self.emu.apply_action(game_state, "call", 15)
game_state, event = self.emu.apply_action(game_state, "call", 0)
game_state, event = self.emu.apply_action(game_state, "call", 0)
game_state, events = self.emu.start_new_round(game_state)
self.eq(4, game_state["round_count"])
self.eq(1, game_state["table"].dealer_btn)
self.eq(0, game_state["street"])
self.eq(0, game_state["next_player"])
self.eq("event_new_street", events[0]["type"])
self.eq("event_ask_player", events[1]["type"])
self.eq("preflop", events[0]["street"])
self.eq("tojrbxmkuzrarnniosuhct", events[1]["uuid"])
def test_blind_structure(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
self.emu.set_blind_structure({5: { "ante": 5, "small_blind": 60 } })
p1 = TestPlayer([("fold", 0), ('raise', 55), ('call', 0)])
p2 = TestPlayer([("call", 15), ("call", 55), ('fold', 0)])
self.emu.register_player("tojrbxmkuzrarnniosuhct", p1)
self.emu.register_player("pwtwlmfciymjdoljkhagxa", p2)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(65, game_state["table"].seats.players[0].stack)
self.eq(135, game_state["table"].seats.players[1].stack)
game_state, events = self.emu.start_new_round(game_state)
game_state, events = self.emu.run_until_round_finish(game_state)
self.eq(120, game_state["table"].seats.players[0].stack)
self.eq(80, game_state["table"].seats.players[1].stack)
game_state, events = self.emu.start_new_round(game_state)
self.eq("event_game_finish", events[0]["type"])
self.eq(0, game_state["table"].seats.players[0].stack)
self.eq(80, game_state["table"].seats.players[1].stack)
def test_apply_action(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
game_state = attach_hole_card_from_deck(game_state, "tojrbxmkuzrarnniosuhct")
game_state = attach_hole_card_from_deck(game_state, "pwtwlmfciymjdoljkhagxa")
self.emu.set_game_rule(2, 10, 5, 0)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("tojrbxmkuzrarnniosuhct", FoldMan())
self.emu.register_player("pwtwlmfciymjdoljkhagxa", FoldMan())
game_state, events = self.emu.apply_action(game_state, "call", 15)
self.eq(Const.Street.RIVER, game_state["street"])
self.eq(TwoPlayerSample.p1_action_histories, \
game_state["table"].seats.players[0].round_action_histories[Const.Street.TURN])
self.eq(2, len(events))
self.eq("event_new_street", events[0]["type"])
self.eq("event_ask_player", events[1]["type"])
game_state, events = self.emu.apply_action(game_state, "call", 0)
self.eq(1, len(events))
self.eq("event_ask_player", events[0]["type"])
game_state, events = self.emu.apply_action(game_state, "call", 0)
self.eq(1, len(events))
self.eq("event_round_finish", events[0]["type"])
def test_attach_hole_card_when_uuid_is_wrong(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
attach_hole_card(game_state, "hoge", "dummy_hole")
def test_restore_game_state_when_ante_is_on(self):
restored = restore_game_state(TwoPlayerSample.round_state_ante_on)
players = restored["table"].seats.players
self.eq(40, players[0].pay_info.amount)
self.eq(25, players[1].pay_info.amount)
def test_attach_hole_card_when_same_uuid_players_exist(self):
game_state = restore_game_state(TwoPlayerSample.round_state)
p1, p2 = game_state["table"].seats.players[:2]
p2.uuid = p1.uuid
attach_hole_card(game_state, p1.uuid, "dummy_hole")
def test_generate_possible_actions(self):
state1 = restore_game_state(TwoPlayerSample.round_state)
self.eq(TwoPlayerSample.valid_actions, self.emu.generate_possible_actions(state1))
state2 = restore_game_state(ThreePlayerGameStateSample.round_state)
self.eq(ThreePlayerGameStateSample.valid_actions, self.emu.generate_possible_actions(state2))
