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_update(self):
self.emu.set_game_rule(2, 8, 5, 3)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("uuid-1", p1)
self.emu.register_player("uuid-2", p2)
blind_structure = {
3: {"ante": 5, "small_blind": 10},
5: {"ante": 10, "small_blind": 20}
}
self.emu.set_blind_structure(blind_structure)
players_info = {
"uuid-1": {"name": "hoge", "stack": 100},
"uuid-2": {"name": "fuga", "stack": 100}
}
state = self.emu.generate_initial_game_state(players_info)
self.eq(5, state["small_blind_amount"])
state, _ = self.emu.start_new_round(state)
state, _ = self.emu.apply_action(state, "fold")
self.eq(5, state["small_blind_amount"])
state, _ = self.emu.apply_action(state, "fold")
self.eq(5, state["small_blind_amount"])
state, _ = self.emu.apply_action(state, "fold")
self.eq(10, state["small_blind_amount"])
state, _ = self.emu.apply_action(state, "fold")
self.eq(10, state["small_blind_amount"])
state, _ = self.emu.apply_action(state, "fold")
self.eq(20, state["small_blind_amount"])
state, _ = self.emu.apply_action(state, "fold")
self.eq(20, state["small_blind_amount"])
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_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_set_blind_structure(self):
config = G.setup_config(1, 100, 10)
config.register_player("p1", FoldMan())
config.register_player("p2", FoldMan())
config.set_blind_structure({1: {"ante": 5, "small_blind": 10}})
result = G.start_poker(config)
p1, p2 = [result["players"][i] for i in range(2)]
self.eq(115, p1["stack"])
self.eq(85, p2["stack"])
def test_set_blind_structure(self):
config = G.setup_config(1, 100, 10)
config.register_player('p1', FoldMan())
config.register_player('p2', FoldMan())
config.set_blind_structure({1: {'ante': 5, 'small_blind': 10}})
result = G.start_poker(config)
p1, p2 = [result['players'][i] for i in range(2)]
self.eq(115, p1['stack'])
self.eq(85, p2['stack'])
def test_start_poker(self):
config = G.setup_config(1, 100, 10)
config.register_player("p1", FoldMan())
config.register_player("p2", FoldMan())
result = G.start_poker(config)
p1, p2 = [result["players"][i] for i in range(2)]
self.eq("p1", p1["name"])
self.eq(110, p1["stack"])
self.eq("p2", p2["name"])
self.eq(90, p2["stack"])
def test_start_poker(self):
config = G.setup_config(1, 100, 10)
config.register_player('p1', FoldMan())
config.register_player('p2', FoldMan())
result = G.start_poker(config)
p1, p2 = [result['players'][i] for i in range(2)]
self.eq('p1', p1['name'])
self.eq(110, p1['stack'])
self.eq('p2', p2['name'])
self.eq(90, p2['stack'])
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_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_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_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_exclude_short_of_money_player_when_ante_on(self):
dealer = Dealer(5, 100, 20)
blind_structure = {3: {"ante": 30, "small_blind": 10}}
dealer.set_blind_structure(blind_structure)
algos = [FoldMan() for _ in range(5)]
[
dealer.register_player("algo-%d" % idx, algo)
for idx, algo in enumerate(algos)
]
dealer.table.dealer_btn = 3
# initialize stack
for idx, stack in enumerate([1000, 30, 46, 1000, 85]):
dealer.table.seats.players[idx].stack = stack
fetch_stacks = lambda res: [
p["stack"] for p in res["message"]["game_information"]["seats"]
]
result = dealer.start_game(1)
self.eq(fetch_stacks(result), [1085, 10, 26, 980, 60])
result = dealer.start_game(2)
self.eq(fetch_stacks(result), [1060, 0, 0, 1025, 40])
result = dealer.start_game(3)
self.eq(fetch_stacks(result), [1100, 0, 0, 985, 0])
result = dealer.start_game(4)
self.eq(fetch_stacks(result), [1060, 0, 0, 1025, 0])
def test_exclude_short_of_money_player_when_ante_on(self):
dealer = Dealer(5, 100, 20)
blind_structure = {3: {'ante': 30, 'small_blind': 10}}
dealer.set_blind_structure(blind_structure)
algos = [FoldMan() for _ in range(5)]
[
dealer.register_player('algo-%d' % idx, algo)
for idx, algo in enumerate(algos)
]
dealer.table.dealer_btn = 3
# initialize stack
for idx, stack in enumerate([1000, 30, 46, 1000, 85]):
dealer.table.seats.players[idx].stack = stack
def fetch_stacks(res):
return [
p['stack'] for p in res['message']['game_information']['seats']
]
result = dealer.start_game(1)
self.eq(fetch_stacks(result), [1085, 10, 26, 980, 60])
result = dealer.start_game(2)
self.eq(fetch_stacks(result), [1060, 0, 0, 1025, 40])
result = dealer.start_game(3)
self.eq(fetch_stacks(result), [1100, 0, 0, 985, 0])
result = dealer.start_game(4)
self.eq(fetch_stacks(result), [1060, 0, 0, 1025, 0])
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_exclude_short_of_money_player(self):
algos = [FoldMan() for _ in range(7)]
[self.dealer.register_player("algo-%d" % idx, algo) for idx, algo in enumerate(algos)]
self.dealer.table.dealer_btn = 5
# initialize stack
for idx, stack in enumerate([11, 7, 9, 11, 9, 7, 100]):
self.dealer.table.seats.players[idx].stack = stack
fetch_stacks = lambda res: [p["stack"] for p in res["message"]["game_information"]["seats"]]
# -- NOTICE --
# dealer.start_game does not change the internal table.
# So running dealer.start_game twice returns same result
# dealer_btn progress
# round-1 => sb:player6, bb:player0
# round-2 => sb:player0, bb:player3
# round-3 => sb:player3, bb:player6
# round-3 => sb:player6, bb:player0
result = self.dealer.start_game(1)
self.eq(fetch_stacks(result), [16, 7, 9, 11, 9, 7, 95])
result = self.dealer.start_game(2)
self.eq(fetch_stacks(result), [11, 0, 0, 16, 9, 7, 95])
result = self.dealer.start_game(3)
self.eq(fetch_stacks(result), [11, 0, 0, 11, 0, 0, 100])
result = self.dealer.start_game(4)
self.eq(fetch_stacks(result), [16, 0, 0, 11, 0, 0, 95])
def test_set_blind_structure(self):
dealer = Dealer(5, 100, 3)
dealer.table.dealer_btn = 2
blind_structure = {
3: {
'ante': 7,
'small_blind': 11
},
4: {
'ante': 13,
'small_blind': 30
}
}
dealer.set_blind_structure(blind_structure)
algos = [FoldMan() for _ in range(3)]
[
dealer.register_player('algo-%d' % idx, algo)
for idx, algo in enumerate(algos)
]
def fetch_stacks(res):
return [
p['stack'] for p in res['message']['game_information']['seats']
]
result = dealer.start_game(1)
self.eq(fetch_stacks(result), [92, 111, 97])
result = dealer.start_game(2)
self.eq(fetch_stacks(result), [89, 103, 108])
result = dealer.start_game(3)
self.eq(fetch_stacks(result), [114, 96, 90])
result = dealer.start_game(4)
self.eq(fetch_stacks(result), [71, 152, 77])
result = dealer.start_game(5)
self.eq(fetch_stacks(result), [58, 109, 133])
def test_set_blind_structure(self):
dealer = Dealer(5, 100, 3)
dealer.table.dealer_btn = 2
blind_structure = {
3: {
"ante": 7,
"small_blind": 11
},
4: {
"ante": 13,
"small_blind": 30
}
}
dealer.set_blind_structure(blind_structure)
algos = [FoldMan() for _ in range(3)]
[
dealer.register_player("algo-%d" % idx, algo)
for idx, algo in enumerate(algos)
]
fetch_stacks = lambda res: [
p["stack"] for p in res["message"]["game_information"]["seats"]
]
result = dealer.start_game(1)
self.eq(fetch_stacks(result), [92, 111, 97])
result = dealer.start_game(2)
self.eq(fetch_stacks(result), [89, 103, 108])
result = dealer.start_game(3)
self.eq(fetch_stacks(result), [114, 96, 90])
result = dealer.start_game(4)
self.eq(fetch_stacks(result), [71, 152, 77])
result = dealer.start_game(5)
self.eq(fetch_stacks(result), [58, 109, 133])
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_register_poker_player(self):
algo = FoldMan()
with patch.object(self.dealer, '_Dealer__fetch_uuid', return_value="a"):
self.dealer.register_player("hoge", algo)
player = self.dealer.table.seats.players[0]
self.eq("hoge", player.name)
self.eq(100, player.stack)
self.eq(algo, self.mh.algo_owner_map["a"])
def test_play_two_round(self):
algos = [FoldMan() for _ in range(2)]
[self.dealer.register_player(name, algo) for name, algo in zip(["hoge", "fuga"], algos)]
players = self.dealer.table.seats.players
summary = self.dealer.start_game(2)
player_state = summary["message"]["game_information"]["seats"]
self.eq(100, player_state[0]["stack"])
self.eq(100, player_state[1]["stack"])
def test_only_one_player_is_left(self):
algos = [FoldMan() for _ in range(2)]
[
self.dealer.register_player(name, algo)
for name, algo in zip(['hoge', 'fuga'], algos)
]
players = self.dealer.table.seats.players
players[0].stack = 14
summary = self.dealer.start_game(2)
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_play_two_round(self):
algos = [FoldMan() for _ in range(2)]
[
self.dealer.register_player(name, algo)
for name, algo in zip(['hoge', 'fuga'], algos)
]
players = self.dealer.table.seats.players
summary = self.dealer.start_game(2)
player_state = summary['message']['game_information']['seats']
self.eq(100, player_state[0]['stack'])
self.eq(100, player_state[1]['stack'])
def test_blind_structure_update(self):
self.emu.set_game_rule(2, 8, 5, 3)
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player('uuid-1', p1)
self.emu.register_player('uuid-2', p2)
blind_structure = {
3: {
'ante': 5,
'small_blind': 10
},
5: {
'ante': 10,
'small_blind': 20
}
}
self.emu.set_blind_structure(blind_structure)
players_info = {
'uuid-1': {
'name': 'hoge',
'stack': 100
},
'uuid-2': {
'name': 'fuga',
'stack': 100
}
}
state = self.emu.generate_initial_game_state(players_info)
self.eq(5, state['small_blind_amount'])
state, _ = self.emu.start_new_round(state)
state, _ = self.emu.apply_action(state, 'fold')
self.eq(5, state['small_blind_amount'])
state, _ = self.emu.apply_action(state, 'fold')
self.eq(5, state['small_blind_amount'])
state, _ = self.emu.apply_action(state, 'fold')
self.eq(10, state['small_blind_amount'])
state, _ = self.emu.apply_action(state, 'fold')
self.eq(10, state['small_blind_amount'])
state, _ = self.emu.apply_action(state, 'fold')
self.eq(20, state['small_blind_amount'])
state, _ = self.emu.apply_action(state, 'fold')
self.eq(20, state['small_blind_amount'])
def test_exclude_short_of_money_player_when_ante_on2(self):
dealer = Dealer(5, 100, 20)
algos = [FoldMan() for _ in range(3)]
[dealer.register_player("algo-%d" % idx, algo) for idx, algo in enumerate(algos)]
dealer.table.dealer_btn = 2
# initialize stack
for idx, stack in enumerate([30, 25, 19]):
dealer.table.seats.players[idx].stack = stack
fetch_stacks = lambda res: [p["stack"] for p in res["message"]["game_information"]["seats"]]
result = dealer.start_game(1)
self.eq([55, 0, 0], fetch_stacks(result))
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_generate_initial_game_state(self):
self.emu.set_game_rule(2, 8, 5, 3)
p1, p2 = FoldMan(), FoldMan()
players_info = OrderedDict()
players_info["uuid-1"] = {"name": "hoge", "stack": 100}
players_info["uuid-2"] = {"name": "fuga", "stack": 100}
state = self.emu.generate_initial_game_state(players_info)
table = state["table"]
self.eq(0, state["round_count"])
self.eq(5, state["small_blind_amount"])
self.eq(100, table.seats.players[0].stack)
self.eq("uuid-1", table.seats.players[0].uuid)
self.eq(100, table.seats.players[1].stack)
self.eq("uuid-2", table.seats.players[1].uuid)
self.eq(1, table.dealer_btn)
state, events = self.emu.start_new_round(state)
self.eq(0, state["table"].dealer_btn)
self.eq(1, state["table"].sb_pos())
self.eq(0, state["table"].bb_pos())
self.eq(1, state["next_player"])
state, events = self.emu.apply_action(state, "call", 10)
self.eq(1, state["next_player"])
def test_generate_initial_game_state(self):
self.emu.set_game_rule(2, 8, 5, 3)
p1, p2 = FoldMan(), FoldMan()
players_info = OrderedDict()
players_info['uuid-1'] = {'name': 'hoge', 'stack': 100}
players_info['uuid-2'] = {'name': 'fuga', 'stack': 100}
state = self.emu.generate_initial_game_state(players_info)
table = state['table']
self.eq(0, state['round_count'])
self.eq(5, state['small_blind_amount'])
self.eq(100, table.seats.players[0].stack)
self.eq('uuid-1', table.seats.players[0].uuid)
self.eq(100, table.seats.players[1].stack)
self.eq('uuid-2', table.seats.players[1].uuid)
self.eq(1, table.dealer_btn)
state, events = self.emu.start_new_round(state)
self.eq(0, state['table'].dealer_btn)
self.eq(1, state['table'].sb_pos())
self.eq(0, state['table'].bb_pos())
self.eq(1, state['next_player'])
state, events = self.emu.apply_action(state, 'call', 10)
self.eq(1, state['next_player'])