def __init__(self, starting_stack, small_blind):
self.pok = PokerUtils()
self.starting_stack = starting_stack
self.small_blind = 10
self.emulator = Emulator()
self.emulator.set_game_rule(player_num=2,
max_round=10,
small_blind_amount=small_blind,
ante_amount=0)
self.hole_cards = {}
self.players_info = {
"bb_player": {
"name": "bb_player",
"stack": starting_stack
},
"sb_player": {
"name": "sb_player",
"stack": starting_stack
},
}
self.initial_game_state = self.emulator.generate_initial_game_state(
self.players_info)
self.players_cards = [np.zeros(13), np.zeros(13)]
self.suited = [0, 0]
self.street = 'preflop'
self.events = []
self.game_state = []
def __init__(self):
self.emulator = Emulator()
#try:
self._sigma = pickle.load(open("strategy.pickle", "rb"))
#except (OSError, IOError, EOFError) as e:
#self._sigma = {}
#pickle.dump(self._sigma, open("strategy.pickle", "wb"))
self.cumulative_regrets = {}
self.cumulative_sigma = {}
class Game:
def __init__(self, game_state, hole_card, player):
self.player = player
self.initial_state = game_state
self.hole_card = hole_card
self.emulator = Emulator()
self.emulator.set_game_rule(2, 10, 10, 0)
def actions(self, state):
"""Return a list of the allowable moves at this point."""
return list(
map(lambda x: x['action'],
self.emulator.generate_possible_actions(state)))
def result(self, state, move):
"""Return the state that results from making a move from a state."""
return self.emulator.apply_action(state, move)[0]
def utility(self, state, player):
"""Return the value of this final state to player."""
score = estimate_hole_card_win_rate(100, 2, self.hole_card,
state['table']._community_card)
# 1 is MAX player
if self.player == player:
return score
else:
return -score
def terminal_test(self, state):
"""Return True if this is a final state for the game."""
return self.emulator._is_last_round(state, self.emulator.game_rule)
def to_move(self, state):
"""Return the player whose move it is in this state."""
return state['next_player']
def display(self, state):
"""Print or otherwise display the state."""
print(state)
def __repr__(self):
return '<{}>'.format(self.__class__.__name__)
def play_game(self, *players):
"""Play an n-person, move-alternating game."""
state = self.initial_state
while True:
for player in players:
move = player(self, state)
state = self.result(state, move)
if self.terminal_test(state):
self.display(state)
return self.utility(state,
self.to_move(self.initial_state))
def receive_game_start_message(self, game_info):
player_num = game_info["player_num"]
max_round = game_info["rule"]["max_round"]
small_blind_amount = game_info["rule"]["small_blind_amount"]
ante_amount = game_info["rule"]["ante"]
blind_structure = game_info["rule"]["blind_structure"]
self.emulator = Emulator()
self.emulator.set_game_rule(player_num, max_round, small_blind_amount,
ante_amount)
self.emulator.set_blind_structure(blind_structure)
def __init__(self, hole_card, player, state, num_rounds, valid_actions,
round_state, weights):
self.hole_card = hole_card
self.player = player
self.init_state = state
self.emulator = Emulator()
self.num_rounds = num_rounds
self.valid_actions = valid_actions
self.weights = weights
self.round_state = round_state
self.emulator.set_game_rule(2, self.num_rounds, 10, 0)
def __init__(self):
self.table = {}
self.table1 = {}
self.belief = {}
# self.opponent_belief ={}
self.uuid = None
self.opponent = None
self.emulator = Emulator()
self.emulator.set_game_rule(2, 1, 10, 0)
self.current_cost = 10
self.random_game_state = None
def receive_game_start_message(self, game_info):
self.my_model = MyModel()
nb_player = game_info['player_num']
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
self.emulator = Emulator()
self.emulator.set_game_rule(nb_player, max_round, sb_amount, ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else self.opponents_model
self.emulator.register_player(uuid, player_model)
def receive_game_start_message(self, game_info):
player_num = game_info["player_num"]
max_round = game_info["rule"]["max_round"]
small_blind_amount = game_info["rule"]["small_blind_amount"]
ante_amount = game_info["rule"]["ante"]
blind_structure = game_info["rule"]["blind_structure"]
self.emulator = Emulator()
self.emulator.set_game_rule(player_num, max_round, small_blind_amount,
ante_amount)
self.emulator.set_blind_structure(blind_structure)
# Register algorithm of each player which used in the simulation.
for player_info in game_info["seats"]["players"]:
self.emulator.register_player(player_info["uuid"], RandomPlayer())
def receive_game_start_message(self, game_info):
self.my_model = MyModel()
self.n
community_card = round_state['community_card']b_player = game_info['player_num']
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
self.emulator = Emulator()
self.emulator.set_game_rule(nb_player, max_round, sb_amount, ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else FishPlayer()
#
#for player_info in game_info["seats"]["players"]:
# self.emulator.register_player(player_info["uuid"], HonestPlayer())
self.emulator.register_player(uuid, player_model)
def receive_game_start_message(self, game_info):
self.nb_player = game_info['player_num']
global PLAYER_NUM
PLAYER_NUM = game_info["player_num"]
max_round = game_info["rule"]["max_round"]
small_blind_amount = game_info["rule"]["small_blind_amount"]
ante_amount = game_info["rule"]["ante"]
blind_structure = game_info["rule"]["blind_structure"]
for i in range(0, len(game_info['seats'])):
if (game_info['seats'][i]['name'] == 'q-learning'):
self._uuid = game_info['seats'][i]['uuid']
self.emulator = Emulator()
self.emulator.set_game_rule(PLAYER_NUM, max_round, small_blind_amount,
ante_amount)
self.emulator.set_blind_structure(blind_structure)
class GenPlayer(BasePokerPlayer):
# Setup Emulator object by registering game information
def receive_game_start_message(self, game_info):
player_num = game_info["player_num"]
max_round = game_info["rule"]["max_round"]
small_blind_amount = game_info["rule"]["small_blind_amount"]
ante_amount = game_info["rule"]["ante"]
blind_structure = game_info["rule"]["blind_structure"]
self.emulator = Emulator()
self.emulator.set_game_rule(player_num, max_round, small_blind_amount,
ante_amount)
self.emulator.set_blind_structure(blind_structure)
# Register algorithm of each player which used in the simulation.
for player_info in game_info["seats"]["players"]:
self.emulator.register_player(player_info["uuid"], RandomPlayer())
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 emulate(hole_card, round_state):
# 1. Set game settings in Emulator
emulator = Emulator()
sb_amount = round_state['small_blind_amount']
# emulator(nb_player,max_rounds,sb_amount,ante)
emulator.set_game_rule(2, 10, sb_amount, 1)
# 2. Setup Gamestate object
game_state = restore_game_state(round_state)
# Attach hole_cards for each player (at random for opponent)
game_state = attach_hole_card(game_state,round_state['seats'][0]['uuid'], gen_cards(hole_card))
game_state = attach_hole_card_from_deck(game_state,round_state['seats'][1]['uuid'])
# 3. Run simulation and get updated GameState object
# updated_state, events = emulator.apply_action(game_state, "call", 10)
return game_state, emulator
def __init__(self,
final_round=max_round,
scale_reward=False,
lose_penalty=False,
shuffle_position=False,
action_record=False):
self.final_round = final_round
self.scale_reward = scale_reward
self.lose_penalty = lose_penalty
self.shuffle_position = shuffle_position
self.action_record = action_record
self.emulator = Emulator()
self.emulator.set_game_rule(nb_player, final_round, sb_amount, ante)
self.emulator.set_blind_structure(blind_structure)
self.opponent_value_functions = {}
if shuffle_position:
print "Warning: shuffle_position is set True. Are you sure?"
for uuid in players_info:
self.emulator.register_player(uuid, DummyPlayer())
if uuid != my_uuid: self.opponent_value_functions[uuid] = None
def receive_game_start_message(self, game_info):
self.my_model = MyModel()
nb_player = game_info['player_num']
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
self.emulator = Emulator()
self.emulator.set_game_rule(nb_player, max_round, sb_amount, ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else self.opponents_model
self.emulator.register_player(uuid, player_model)
def receive_game_start_message(self, game_info):
# self.my_name = game_info['seats'][self.my_seat]['name']
if self.study_mode:
self.uuid = game_info["seats"][self.my_seat]['uuid']
self.stats.init_player_names(game_info)
self.player_num = game_info["player_num"]
self.max_round = game_info["rule"]["max_round"]
self.small_blind_amount = game_info["rule"]["small_blind_amount"]
self.ante_amount = game_info["rule"]["ante"]
# self.blind_structure = game_info["rule"]["blind_structure"]
self.emulator = Emulator()
self.emulator.set_game_rule(self.player_num, self.max_round,
self.small_blind_amount, self.ante_amount)
# self.emulator.set_blind_structure(blind_structure)
if self.study_mode:
# Register algorithm of each player which used in the simulation.
for i in np.arange(self.player_num):
self.emulator.register_player(
uuid=game_info["seats"][i]["uuid"],
player=self.players[i]
if self.players[i] is not None else self)
def receive_game_start_message(self, game_info):
self.nb_player = game_info['player_num']
self.small_blind_amount = game_info['rule']['small_blind_amount']
self.Opponent_Model.set_nb_player(self.nb_player)
self.my_model = MyModel()
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
for player in game_info['seats']:
if player['uuid'] == self.uuid:
self.seat = game_info['seats'].index(player)
break
else:
raise ('not participating!')
self.emulator = Emulator()
self.emulator.set_game_rule(self.nb_player, max_round, sb_amount,
ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else self.Opponent_Model
self.emulator.register_player(uuid, player_model)
def initialize_new_emulator(player_num, max_round, small_blind_amount, ante_amount):
emulator = Emulator()
emulator.set_game_rule(player_num=player_num, max_round=max_round, small_blind_amount=small_blind_amount, ante_amount=ante_amount)
return emulator
class ModelPlayer(BasePokerPlayer):
table_name = "gameinfotbl"
standard_insert = "Player_name, win_rate, hole_cards, community_cards, action, stack, small_blind_amount"
db_name = "game_information.db"
street = ['preflop', 'flop', 'turn', 'river', 'showdown']
def __init__(self, name):
self.name = name
self.seat = None
self.raise_amount = 0
self.win_rate = None
self.stack = None
self.small_blind_amount = None
self.hole_card = None
self.community_card = None
self.action = None
self.opponent_raise_threshold = 0.7
self.opponent_bluffing_ratio = 0.5
self.__init_database()
self.Opponent_Model = OpponentModel("Opponent", 0.5, 0.5)
self.my_model = MyModel()
def declare_action(self, valid_actions, hole_card, round_state):
# try_actions = [MyModel.FOLD, MyModel.CALL, MyModel.RAISE]
# community_card = round_state['community_card']
pot = round_state['pot']['main']['amount']
call_amount = valid_actions[1]['amount']
self.raise_amount = valid_actions[2]['amount']['min']
# round_strategy = {'preflop' : 0, 'flop' : 0, 'turn' : 0, 'river' : 0, 'showdown' : 0}
# street_now = round_state['street']
# # self.win_rate = estimate_hole_card_win_rate(nb_simulation = NB_SIMULATION,
# # nb_player = self.nb_player,
# # hole_card=gen_cards(hole_card),
# # community_card=gen_cards(community_card))
# action_results = [0 for i in range(len(try_actions))]
# # win_rate = calculate_win_rate_with_model(hole_card, community_card)
# log("hole_card of emulator player is %s" % hole_card)
# for action_now in try_actions:
# round_strategy[round_state['street']] = action_now
# for street in enumerate(self.street, self.street.index(street_now) + 1):
# for action_later in try_actions:
# round_strategy[street] = action_later
# self.my_model.set_round_strategy(round_strategy)
# simulation_results = []
# for _ in range(NB_SIMULATION):
# game_state = self._setup_game_state(round_state, hole_card)
# round_finished_state, _events = self.emulator.run_until_round_finish(game_state)
# new_winner_uuid = _events[-1]['winners'][-1]['uuid']
# my_stack = [player for player in round_finished_state['table'].seats.players if player.uuid == self.uuid][0].stack
# simulation_results.append(my_stack)
# if action_results[action_now] < 1.0 * sum(simulation_results) / NB_SIMULATION:
# action_results[action_now] = 1.0 * sum(simulation_results) / NB_SIMULATION
# log("average stack after simulation when declares %s : %s" % (
# {0:'FOLD', 1:'CALL', 2:'RAISE'}[action_now], action_results[action_now])
# )
# best_action = max(zip(action_results, try_actions))[1]
# round_strategy[round_state['street']] = best_action
# self.my_model.set_round_strategy(round_strategy)
# declare_action, amount = self.my_model.declare_action(valid_actions, hole_card, round_state)
# if declare_action == "FOLD":
# self.action = 0
# elif declare_action == "CALL":
# self.action = 1
# else:
# self.action = 2
# self.record_action()
win_rate_with_model = self.estimate_win_rate_with_model_to_convergent(
hole_card, round_state)
print(win_rate_with_model)
ev = self.ev_calculation(win_rate_with_model, pot, call_amount)
if ev.index(max(ev)) == 0:
return valid_actions[0]['action'], valid_actions[0]['amount']
elif ev.index(max(ev)) == 1:
return valid_actions[1]['action'], valid_actions[1]['amount']
else:
return valid_actions[2]['action'], valid_actions[2]['amount'][
'min']
def receive_game_start_message(self, game_info):
self.nb_player = game_info['player_num']
self.small_blind_amount = game_info['rule']['small_blind_amount']
self.Opponent_Model.set_nb_player(self.nb_player)
self.my_model = MyModel()
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
for player in game_info['seats']:
if player['uuid'] == self.uuid:
self.seat = game_info['seats'].index(player)
break
else:
raise ('not participating!')
self.emulator = Emulator()
self.emulator.set_game_rule(self.nb_player, max_round, sb_amount,
ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else self.Opponent_Model
self.emulator.register_player(uuid, player_model)
def receive_round_start_message(self, round_count, hole_card, seats):
self.self_bet = 0
self.hole_card = hole_card
def receive_street_start_message(self, street, round_state):
self.community_card = round_state['community_card']
def receive_game_update_message(self, action, round_state):
if action['player_uuid'] == self.uuid:
self.self_bet = self.self_bet + action['amount']
Opponent_bet = round_state['pot']['main']['amount'] - self.self_bet
self.Opponent_Model.set_bet(Opponent_bet)
self.stack = round_state['seats'][self.seat]['stack']
def receive_round_result_message(self, winners, hand_info, round_state):
pass
def record_action(self):
msg_record = self.__make_message()
con = lite.connect(self.db_name)
with con:
cur = con.cursor()
cur.execute(
"INSERT INTO gameinfotbl(Player_name, win_rate, hole_cards, community_cards, action, stack, small_blind_amount) VALUES(?,?,?,?,?,?,?)",
msg_record)
#######################################################################
def ev_calculation(self, win_rate, pot, call_amount):
ev = [0 for i in range(3)]
ev[0] = -self.self_bet
ev[1] = win_rate * (pot - self.self_bet) - (1 - win_rate) * (
self.self_bet + call_amount)
ev[2] = win_rate * (pot - self.self_bet + self.raise_amount) - \
(1 - win_rate) * (self.self_bet + self.raise_amount + call_amount)
return ev
# def choose_action(self, win_rate, pot, valid_actions):
# r = rand.random()
# ev = self.ev_calculation(win_rate, pot, valid_actions[1]['amount'])
# if win_rate >= self.raise_threshold:
# return valid_actions[2]['action'], 2 * self.small_blind_amount
# elif r >= self.bluffing_ratio:
# return valid_actions[2]['action'], 2 * self.small_blind_amount
# elif ev[1] >= ev[0]:
# return valid_actions[1]['action'], valid_actions[1]['amount']
# else:
# return valid_actions[0]['action'], valid_actions[0]['amount']
def _setup_game_state(self, round_state, my_hole_card):
game_state = restore_game_state(round_state)
game_state['table'].deck.shuffle()
community_card = round_state['community_card']
current_street = round_state['street']
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:
while True:
opponent_card = assuming_card(gen_cards(my_hole_card))
if not self.is_already_fold(opponent_card, current_street,
community_card):
break
game_state = attach_hole_card(
game_state, uuid,
opponent_card) # attach opponents holecard at random
return game_state
def __make_message(self):
msg = []
msg.append(self.name)
msg.append(self.win_rate)
msg.append(str(self.hole_card))
msg.append(str(self.community_card))
msg.append(self.action)
msg.append(self.stack)
msg.append(self.small_blind_amount)
return msg
def __init_database(self):
con = lite.connect(self.db_name)
with con:
cur = con.cursor()
cur.execute(
"CREATE TABLE IF NOT EXISTS {tbl_name}(_Id INTEGER PRIMARY KEY, Player_name TEXT, win_rate REAL, \
hole_cards TEXT, community_cards TEXT, action INT, stack INT, small_blind_amount INT)"
.format(tbl_name=self.table_name))
def _modify_round_strategy_list(self, action, street, round_strategy):
round_strategy['street'] = action
def is_already_fold(self, opponent_card, current_street, community_card):
win_rate = 0
r = rand.random()
str_card = [str(a) for a in opponent_card]
for street in street_table.keys():
win_rate = get_broad_win_rate(
str_card, community_card[0:street_table[street]])
if win_rate < self.opponent_raise_threshold and r < self.opponent_bluffing_ratio:
return True
if street == current_street or street == 'river':
break
return False
def simulate_one_time(self, round_state, hole_card):
game_state = self._setup_game_state(round_state, hole_card)
_round_finished_state, _events = self.emulator.run_until_round_finish(
game_state)
if _events[-1]['type'] == 'event_game_finish':
return 0 #if not 0, the last round will report a error
new_winner_uuid = _events[-1]['winners'][-1]['uuid']
# my_stack = [player for player in round_finished_state['table'].seats.players if player.uuid == self.uuid][0].stack
# simulation_results.append(my_stack)
return 1 if new_winner_uuid == self.uuid else 0
def calculate_win_rate_with_model_serval_time(self, round_state, hole_card,
nb_simulation):
win_count = sum([
self.simulate_one_time(round_state, hole_card)
for _ in range(nb_simulation)
])
return 1.0 * win_count / nb_simulation
def estimate_win_rate_with_model_to_convergent(self, hole_card,
round_state):
ls_win_rate = [.0 for _ in range(10)]
rpt_times = 50
counter = 0 ##the newer calculated win percentage must be the avarage number
while True:
newer_win_rate = self.calculate_win_rate_with_model_serval_time(
round_state, hole_card, rpt_times)
ls_win_rate.pop(0)
itered_win_rate = (ls_win_rate[-1] * counter +
newer_win_rate) / (counter + 1)
ls_win_rate.append(itered_win_rate)
if (np.max(ls_win_rate) - np.min(ls_win_rate)) < 0.1:
break
counter = counter + 1
return ls_win_rate[-1]
class Game:
def __init__(self, hole_card, player, state, num_rounds, valid_actions,
round_state, weights):
self.hole_card = hole_card
self.player = player
self.init_state = state
self.emulator = Emulator()
self.num_rounds = num_rounds
self.valid_actions = valid_actions
self.weights = weights
self.round_state = round_state
self.emulator.set_game_rule(2, self.num_rounds, 10, 0)
def terminal_test(self, state):
""" Check if game tree ends """
return self.emulator._is_last_round(state, self.emulator.game_rule)
def actions(self, state):
""" generate legal moves at this state """
temp = list(
map(lambda x: x['action'],
self.emulator.generate_possible_actions(state)))
return temp
def eval_heuristics(self, player, state, win_rate):
if isDebug:
print("Evaluating heuristics")
if isHeuristicTimed:
start = time.time()
print(time.time())
amount_in_pot = float(self.round_state['pot']['main']['amount']) / 8.8
EHS = (EffectiveHandStrength(
self.hole_card, state['table']._community_card) + 10) / 20 * 100
if isDebug:
print("=======Got heuristics")
if isHeuristicTimed:
end = start = time.time()
print("==========Got heuristics in time: " + str(end - start) +
" secs")
heuristics = [win_rate, amount_in_pot, EHS]
res = np.dot(self.weights, heuristics)
return res
def future_move(self, state):
return state['next_player']
def project(self, curr_state, move):
""" projects what happens when making a move from current state """
return self.emulator.apply_action(curr_state, move)[0]
def minimax(self, newState, max_depth, hole_cards, community_cards):
""" MiniMax decision strategy """
player = self.future_move(newState)
inf = float('inf')
if (community_cards == []): # Preflop
win_rate = eval_pre_flop.eval_pre_flop(hole_cards) / 100 * 50 + 50
else:
win_rate = eval_post_flop.eval_post_flop_rank(
hole_cards, community_cards) / 100 * 50 + 50
def min_value(newState, alpha, beta, depth):
""" determines what the strategy of the Min palyer should be. It is limited by max depth"""
if isDebug:
print("In MIN")
if depth == max_depth or self.terminal_test(newState):
return self.eval_heuristics(player, newState, win_rate)
v = inf
for a in self.actions(newState):
v = min(
max_value(self.project(newState, a), alpha, beta,
depth + 1), v)
if v <= alpha:
return v
beta = min(beta, v)
return v
def max_value(newState, alpha, beta, depth):
""" determines what the strategy of the Max palyer should be. It is limited by max depth"""
if isDebug:
print("In MAX")
if depth == max_depth or self.terminal_test(newState):
return self.eval_heuristics(player, newState, win_rate)
v = -inf
for a in self.actions(newState):
v = max(
min_value(self.project(newState, a), alpha, beta,
depth + 1), v)
if (v >= beta):
return v
alpha = max(alpha, v)
return v
# alpha-beta pruning code
# considers the next best action to take by starting off the Minimax recursion
# and pruning out the nodes that no longer need to be considered
best_score = -inf
beta = inf
best_action = None
for a in self.actions(newState):
v = min_value(self.project(newState, a), best_score, beta, 0)
if v > best_score:
best_score = v
best_action = a
# TODO: Since our player folds a lot. Please update/remove as required
if best_action == 'fold':
# print('fold')
return 'call'
else:
# print(best_action)
return best_action
return best_action
class Alpha0Regret(BasePokerPlayer):
def __init__(self,
mccfr_simulations,
model,
exp=0,
uuid=None,
emulator=None,
memory=None):
super().__init__()
self.MCCFR_simulations = mccfr_simulations
self.model = model
self.mccfr = None
self.intial_round_stack = 0
self.total_round_money = 0
self.emulator = emulator
self.memory = memory
if uuid is not None:
self.uuid = uuid
self.exp = exp
# Setup Emulator object by registering game information
def declare_action(self, valid_actions, hole_card, round_state):
state = GameState(self.uuid, round_state, gen_cards(hole_card),
self.emulator)
if self.mccfr == None or state.id not in self.mccfr.tree:
self.buildMCCFR(state)
else:
self.changeRootMCCFR(state)
[self.simulate() for sim in range(self.MCCFR_simulations)]
#for sim in range(self.MCCFR_simulations):
# self.simulate()
pi = self.getAV()
action = self.chooseAction(pi)
if self.memory is not None:
self.memory.commit_stmemory(self.uuid,
state.convertStateToModelInput(), pi,
np.zeros((1, )))
return list(state.get_action_list()[action].values())
def receive_game_start_message(self, game_info):
player_num = game_info["player_num"]
max_round = game_info["rule"]["max_round"]
small_blind_amount = game_info["rule"]["small_blind_amount"]
ante_amount = game_info["rule"]["ante"]
blind_structure = game_info["rule"]["blind_structure"]
self.emulator = Emulator()
self.emulator.set_game_rule(player_num, max_round, small_blind_amount,
ante_amount)
self.emulator.set_blind_structure(blind_structure)
def receive_round_start_message(self, round_count, hole_card, seats):
pass
def receive_street_start_message(self, street, round_state):
pass
def receive_game_update_message(self, action, round_state):
pass
def receive_round_result_message(self, winners, hand_info, round_state):
pass
def buildMCCFR(self, state):
self.root = mc.Node(state)
self.mccfr = mc.MCCFR(self.root, self.uuid)
def changeRootMCCFR(self, state):
self.mccfr.root = self.mccfr.tree[state.id]
def simulate(self):
leaf, value, done, breadcrumbs = self.mccfr.moveToLeaf(self.model)
value, breadcrumbs = self.evaluateLeaf(leaf, value, done, breadcrumbs)
self.mccfr.backFill(value, breadcrumbs)
def evaluateLeaf(self, leaf, value, done, breadcrumbs):
if done == 0:
value, probs, allowedActions = self.get_preds(leaf.state)
probs = probs[allowedActions]
for idx, action in enumerate(allowedActions):
newState, _, _ = leaf.state.takeAction(action)
if newState.id not in self.mccfr.tree:
node = mc.Node(newState)
self.mccfr.addNode(node)
else:
node = self.mccfr.tree[newState.id]
newEdge = mc.Edge(leaf, node, probs[idx], action)
leaf.edges.append((action, newEdge))
return ((value, breadcrumbs))
def get_preds(self, state):
# predict the leaf
main_input, my_info, my_history, adv_info, adv_history = state.convertStateToModelInput(
)
preds = self.model.predict(
[main_input, my_info, my_history, *adv_info, *adv_history])
value_array = preds[0]
logits_array = preds[1]
value = value_array[0][0]
logits = logits_array[0]
allowedActions = state.allowed_action
mask = np.ones(logits.shape, dtype=bool)
mask[allowedActions] = False
logits[mask] = float('-inf')
probs = stable_softmax(logits)
return ((value, probs, allowedActions))
def getAV(self):
edges = self.mccfr.root.edges
pi = np.zeros(config.game_param['RAISE_PARTITION_NUM'] + 2,
dtype=np.float32)
for action, edge in edges:
pi[action] = max(0, edge.stats['R'])
if np.sum(pi) == 0:
for action, edge in edges:
pi[action] = edge.stats['N']
pi = pi / np.sum(pi)
return pi
def chooseAction(self, pi):
pi = np.asarray([truncate_float(x, 7) for x in pi])
if self.exp == 0:
actions = np.argwhere(pi == max(pi))
action = random.choice(actions)[0]
else:
action_idx = np.random.multinomial(1, pi)
action = np.where(action_idx == 1)[0][0]
return action
def setUp(self):
self.emu = Emulator()
class EmulatorPlayer(BasePokerPlayer):
def set_opponents_model(self, model_player):
self.opponents_model = model_player
# setup Emulator with passed game information
def receive_game_start_message(self, game_info):
self.my_model = MyModel()
nb_player = game_info['player_num']
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
self.emulator = Emulator()
self.emulator.set_game_rule(nb_player, max_round, sb_amount, ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else self.opponents_model
self.emulator.register_player(uuid, player_model)
def declare_action(self, valid_actions, hole_card, round_state):
try_actions = [MyModel.FOLD, MyModel.CALL, MyModel.MIN_RAISE, MyModel.MAX_RAISE]
action_results = [0 for i in range(len(try_actions))]
log("hole_card of emulator player is %s" % hole_card)
for action in try_actions:
self.my_model.set_action(action)
simulation_results = []
for i in range(NB_SIMULATION):
game_state = self._setup_game_state(round_state, hole_card)
round_finished_state, _events = self.emulator.run_until_round_finish(game_state)
my_stack = [player for player in round_finished_state['table'].seats.players if player.uuid == self.uuid][0].stack
simulation_results.append(my_stack)
action_results[action] = 1.0 * sum(simulation_results) / NB_SIMULATION
log("average stack after simulation when declares %s : %s" % (
{0:'FOLD', 1:'CALL', 2:'MIN_RAISE', 3:'MAX_RAISE'}[action], action_results[action])
)
best_action = max(zip(action_results, try_actions))[1]
self.my_model.set_action(best_action)
return self.my_model.declare_action(valid_actions, hole_card, round_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 receive_round_start_message(self, round_count, hole_card, seats):
pass
def receive_street_start_message(self, street, round_state):
pass
def receive_game_update_message(self, new_action, round_state):
pass
def receive_round_result_message(self, winners, hand_info, round_state):
pass
from pypokerengine.engine.card import Card
from pypokerengine.utils.card_utils import estimate_hole_card_win_rate, gen_cards
from pypokerengine.engine.poker_constants import PokerConstants as Const
from pypokerengine.engine.hand_evaluator import HandEvaluator
# from My_utils import hand_strength_with_belief, hand_strength, win_rate
import itertools
import numpy as np
from time import time, sleep
import pprint
import copy
from CardProbability import CardDeck
# In[ ]:
PREFLOP_HAND_STRENGTH = np.load('preflop_hand_strength.npy').item()
emulator = Emulator()
emulator.set_game_rule(2, 1, 20, 0)
# In[115]:
# heuristic_weights for[HC,LP,MP,HP,2P,3C,Straight,flush,FH,4C,SF]
# heuristic_weights = np.array([1,1.5,2.5,4,10,20,40,80,160,320,640])
heuristic_weights = np.array([0.1, 1, 2, 3, 7, 14, 28, 56, 112, 224, 448])
# heuristic_weights = heuristic_weights/np.sum(heuristic_weights)
# print(heuristic_weights)
#quantiles = [1,8,20]
QUANTILE = [0.4, 0.6, 0.75]
def heuristic1(hole, community_card, heuristic_weights=heuristic_weights):
cards = hole + community_card
class EventTest(BaseUnitTest):
def setUp(self):
self.emu = Emulator()
def test_create_new_street_event(self):
message = {
"message_type": "street_start_message",
"street": "preflop",
"round_state": 1
}
event = self.emu.create_event(message)
self.eq("event_new_street", event["type"])
self.eq("preflop", event["street"])
self.eq(1, event["round_state"])
def test_create_ask_player_event(self):
message = {
"message_type": "ask_message",
"hole_card": 1,
"valid_actions": 2,
"round_state": TwoPlayerSample.round_state,
"action_histories": [4,5]
}
event = self.emu.create_event(message)
self.eq("event_ask_player", event["type"])
self.eq(2, event["valid_actions"])
self.eq(TwoPlayerSample.round_state, event["round_state"])
self.eq("pwtwlmfciymjdoljkhagxa", event["uuid"])
def test_create_round_finish_event(self):
message = {
"message_type": "round_result_message",
"round_count": 2,
"round_state": TwoPlayerSample.round_state,
"hand_info": [],
"winners": [{'stack': 105, 'state': 'participating', 'name': 'p2', 'uuid': 'pwtwlmfciymjdoljkhagxa'}]
}
event = self.emu.create_event(message)
self.eq("event_round_finish", event["type"])
self.eq(TwoPlayerSample.round_state, event["round_state"])
self.eq("pwtwlmfciymjdoljkhagxa", event["winners"][0]["uuid"])
self.eq(105, event["winners"][0]["stack"])
def test_create_game_finish_event(self):
message = {
'message_type': 'game_result_message',
'game_information': {
'player_num': 2,
'rule': {'max_round': 10, 'initial_stack': 100, 'small_blind_amount': 5},
"seats": [
{'stack': 0, 'state': 'folded', 'name': 'p1', 'uuid': 'tojrbxmkuzrarnniosuhct'},
{'stack': 200, 'state': 'participating', 'name': 'p2', 'uuid': 'pwtwlmfciymjdoljkhagxa'}
]
}
}
event = self.emu.create_event(message)
self.eq("event_game_finish", event["type"])
self.eq("tojrbxmkuzrarnniosuhct", event["players"][0]["uuid"])
self.eq(0, event["players"][0]["stack"])
self.eq("pwtwlmfciymjdoljkhagxa", event["players"][1]["uuid"])
self.eq(200, event["players"][1]["stack"])
from pypokerengine.api.emulator import Emulator
from players.honest_player_og import HonestPlayer
from players.qlearner import RLPlayer
from players.random_player import RandomPlayer
from players.risky_player import RiskyPlayer
import pandas as pd
# 1. Set game settings on emulator
n_players = 4
j=0
emulator = Emulator()
#quuid = "uuid-q"
p_uuid=["high-iq","low-iq","low-iq2","low-iq3"]
#qlearner_player = RLPlayer(n_players, quuid)
monte_carlos_tries=[[10,10],[10,20],[10,30],[10,50],[10,100],[10,200],[10,400],[10,800],[10,1000],[10,1500]]
for tryM in monte_carlos_tries:
df = pd.DataFrame(columns = ['uuid', 'stack', 'game'])
for i in range(0,2):
print("starting game " + str(i) + " from try " + str(j))
df1 = pd.DataFrame(columns = ['uuid', 'stack', 'round'])
df2 = pd.DataFrame(columns = ['uuid', 'stack', 'round'])
df3 = pd.DataFrame(columns = ['uuid', 'stack', 'round'])
df4 = pd.DataFrame(columns = ['uuid', 'stack', 'round'])
emulator.register_player(uuid=p_uuid[0], player=RiskyPlayer(n_players,tryM[1],0.7))
emulator.register_player(uuid=p_uuid[1], player=RiskyPlayer(n_players,tryM[0],0.7))
emulator.register_player(uuid=p_uuid[2], player=RiskyPlayer(n_players,tryM[0],0.7))
emulator.register_player(uuid=p_uuid[3], player=RiskyPlayer(n_players,tryM[0],0.7))
emulator.set_game_rule(player_num=4, max_round=1000, small_blind_amount=20, ante_amount=0)
# 2. Setup GameState object
players_info = {
p_uuid[0]: { "name": "player1", "stack": 10000 },
class EmulatorTest(BaseUnitTest):
def setUp(self):
self.emu = Emulator()
def test_set_game_rule(self):
self.emu.set_game_rule(2, 8, 5, 3)
self.eq(2, self.emu.game_rule["player_num"])
self.eq(8, self.emu.game_rule["max_round"])
self.eq(5, self.emu.game_rule["sb_amount"])
self.eq(3, self.emu.game_rule["ante"])
def test_register_and_fetch_player(self):
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("uuid-1", p1)
self.emu.register_player("uuid-2", p2)
self.eq(p1, self.emu.fetch_player("uuid-1"))
self.eq(p2, self.emu.fetch_player("uuid-2"))
@raises(TypeError)
def test_register_invalid_player(self):
self.emu.register_player("uuid", "hoge")
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_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_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_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)
@raises(Exception)
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(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_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_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_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_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_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_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_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_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_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_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_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 run_episode(agents):
emulator = Emulator()
temp_final_state = {}
winner_counts = [0] * N_AGENTS
n_games_played = 0
for game in range(GAMES_PER_EPISODE):
wrappers = []
player_info = {}
for i, agent in enumerate(agents):
if PERSISTENT_STACKS:
if temp_final_state:
for seat in temp_final_state:
player_info[seat.uuid] = {'name': 'Player ' + str(seat.uuid),
'stack': seat.stack if seat.stack else STACK_SIZE}
else:
player_info[i] = {'name': 'Player ' + str(i), 'stack': STACK_SIZE}
else:
player_info[i] = {'name': 'Player ' + str(i), 'stack': STACK_SIZE}
wrappers.append(DQNAgentWrapper(agent, STACK_SIZE))
emulator.register_player(uuid=i, player=wrappers[-1])
emulator.set_game_rule(N_AGENTS, 2, BB_SIZE / 2, 0)
initial_game_state = emulator.generate_initial_game_state(player_info)
game_state, events = emulator.start_new_round(initial_game_state)
game_finish_state, events = emulator.run_until_round_finish(game_state)
# import json
# if game == 0 or game == 1:
# print('dumping')
# with open('event_dump_' + str(game), 'w') as f:
# json.dump(events, f, indent=2)
if 'winners' not in events[-1]:
events.pop()
winner = events[-1]['winners'][0]['uuid']
winner_counts[winner] += 1
n_games_played += 1
for i in range(N_AGENTS):
new_stack_size = game_finish_state['table'].seats.players[i].stack
reward = (new_stack_size - wrappers[i].prev_stack_size) / BB_SIZE
#print('Remembering {} reward for {} action'.format(reward, wrappers[i].prev_action))
wrappers[i].agent.remember(wrappers[i].prev_state, wrappers[i].prev_action, reward, None, 1)
temp_final_state = game_finish_state['table'].seats.players
# print('====')
print('\rGame:{}, epsilon:{}'.format(game, wrappers[0].agent.epsilon), end='')
# print(game_finish_state)
# print('\n')
# print(events[-5:])
# print('====')
if (game % REPLAY_EVERY_N_GAMES == 0) or (game == GAMES_PER_EPISODE - 1):
# replay memory for every agent
# for agent in agents:
# agent.replay(BATCH_SIZE)
agents[0].replay(BATCH_SIZE)
for i in range(N_AGENTS):
agents[i].model.reset_states()
clear_memory()
return agents[0], temp_final_state, winner_counts, n_games_played
def setUp(self):
self.emu = Emulator()
class EmulatorTest(BaseUnitTest):
def setUp(self):
self.emu = Emulator()
def test_set_game_rule(self):
self.emu.set_game_rule(2, 8, 5, 3)
self.eq(2, self.emu.game_rule["player_num"])
self.eq(8, self.emu.game_rule["max_round"])
self.eq(5, self.emu.game_rule["sb_amount"])
self.eq(3, self.emu.game_rule["ante"])
def test_register_and_fetch_player(self):
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player("uuid-1", p1)
self.emu.register_player("uuid-2", p2)
self.eq(p1, self.emu.fetch_player("uuid-1"))
self.eq(p2, self.emu.fetch_player("uuid-2"))
@raises(TypeError)
def test_register_invalid_player(self):
self.emu.register_player("uuid", "hoge")
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_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_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_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)
@raises(Exception)
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(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_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_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_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_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_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_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_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_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_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_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_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))
class EmulatorPlayer(BasePokerPlayer):
def set_opponents_model(self, model_player):
self.opponents_model = model_player
# setup Emulator with passed game information
def receive_game_start_message(self, game_info):
self.my_model = MyModel()
nb_player = game_info['player_num']
max_round = game_info['rule']['max_round']
sb_amount = game_info['rule']['small_blind_amount']
ante_amount = game_info['rule']['ante']
self.emulator = Emulator()
self.emulator.set_game_rule(nb_player, max_round, sb_amount, ante_amount)
for player_info in game_info['seats']:
uuid = player_info['uuid']
player_model = self.my_model if uuid == self.uuid else self.opponents_model
self.emulator.register_player(uuid, player_model)
def declare_action(self, valid_actions, hole_card, round_state):
try_actions = [MyModel.FOLD, MyModel.CALL, MyModel.MIN_RAISE, MyModel.MAX_RAISE]
action_results = [0 for i in range(len(try_actions))]
log("hole_card of emulator player is %s" % hole_card)
for action in try_actions:
self.my_model.set_action(action)
simulation_results = []
for i in range(NB_SIMULATION):
game_state = self._setup_game_state(round_state, hole_card)
round_finished_state, _events = self.emulator.run_until_round_finish(game_state)
my_stack = [player for player in round_finished_state['table'].seats.players if player.uuid == self.uuid][0].stack
simulation_results.append(my_stack)
action_results[action] = 1.0 * sum(simulation_results) / NB_SIMULATION
log("average stack after simulation when declares %s : %s" % (
{0:'FOLD', 1:'CALL', 2:'MIN_RAISE', 3:'MAX_RAISE'}[action], action_results[action])
)
best_action = max(zip(action_results, try_actions))[1]
self.my_model.set_action(best_action)
return self.my_model.declare_action(valid_actions, hole_card, round_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 receive_round_start_message(self, round_count, hole_card, seats):
pass
def receive_street_start_message(self, street, round_state):
pass
def receive_game_update_message(self, new_action, round_state):
pass
def receive_round_result_message(self, winners, hand_info, round_state):
pass
class EventTest(BaseUnitTest):
def setUp(self):
self.emu = Emulator()
def test_create_new_street_event(self):
message = {
"message_type": "street_start_message",
"street": "preflop",
"round_state": 1
}
event = self.emu.create_event(message)
self.eq("event_new_street", event["type"])
self.eq("preflop", event["street"])
self.eq(1, event["round_state"])
def test_create_ask_player_event(self):
message = {
"message_type": "ask_message",
"hole_card": 1,
"valid_actions": 2,
"round_state": TwoPlayerSample.round_state,
"action_histories": [4, 5]
}
event = self.emu.create_event(message)
self.eq("event_ask_player", event["type"])
self.eq(2, event["valid_actions"])
self.eq(TwoPlayerSample.round_state, event["round_state"])
self.eq("pwtwlmfciymjdoljkhagxa", event["uuid"])
def test_create_round_finish_event(self):
message = {
"message_type":
"round_result_message",
"round_count":
2,
"round_state":
TwoPlayerSample.round_state,
"hand_info": [],
"winners": [{
'stack': 105,
'state': 'participating',
'name': 'p2',
'uuid': 'pwtwlmfciymjdoljkhagxa'
}]
}
event = self.emu.create_event(message)
self.eq("event_round_finish", event["type"])
self.eq(TwoPlayerSample.round_state, event["round_state"])
self.eq("pwtwlmfciymjdoljkhagxa", event["winners"][0]["uuid"])
self.eq(105, event["winners"][0]["stack"])
def test_create_game_finish_event(self):
message = {
'message_type': 'game_result_message',
'game_information': {
'player_num':
2,
'rule': {
'max_round': 10,
'initial_stack': 100,
'small_blind_amount': 5
},
"seats": [{
'stack': 0,
'state': 'folded',
'name': 'p1',
'uuid': 'tojrbxmkuzrarnniosuhct'
}, {
'stack': 200,
'state': 'participating',
'name': 'p2',
'uuid': 'pwtwlmfciymjdoljkhagxa'
}]
}
}
event = self.emu.create_event(message)
self.eq("event_game_finish", event["type"])
self.eq("tojrbxmkuzrarnniosuhct", event["players"][0]["uuid"])
self.eq(0, event["players"][0]["stack"])
self.eq("pwtwlmfciymjdoljkhagxa", event["players"][1]["uuid"])
self.eq(200, event["players"][1]["stack"])
class PushFoldEmulator:
def __init__(self, starting_stack, small_blind):
self.pok = PokerUtils()
self.starting_stack = starting_stack
self.small_blind = 10
self.emulator = Emulator()
self.emulator.set_game_rule(player_num=2,
max_round=10,
small_blind_amount=small_blind,
ante_amount=0)
self.hole_cards = {}
self.players_info = {
"bb_player": {
"name": "bb_player",
"stack": starting_stack
},
"sb_player": {
"name": "sb_player",
"stack": starting_stack
},
}
self.initial_game_state = self.emulator.generate_initial_game_state(
self.players_info)
self.players_cards = [np.zeros(13), np.zeros(13)]
self.suited = [0, 0]
self.street = 'preflop'
self.events = []
self.game_state = []
def is_round_finished(self):
for e in self.events:
if (e['type'] == 'event_round_finish'):
return True
return False
def new_street(self):
for e in self.events:
if (e['type'] == 'event_new_street'):
self.street = e['street']
return self.street
return False
def save_cards(self):
for player in self.game_state['table'].seats.players:
self.hole_cards[player.uuid] = [
card.__str__() for card in player.hole_card
]
def get_hand_feature(self):
if (self.street == 'preflop'):
self.save_cards()
for i in range(2):
self.players_cards[i][self.pok.get_card_value_index(
self.game_state['table'].seats.players[i].hole_card[0].
__str__())] = 1
self.players_cards[i][self.pok.get_card_value_index(
self.game_state['table'].seats.players[i].hole_card[1].
__str__())] = 1
if self.pok.is_suited([
self.game_state['table'].seats.players[i].hole_card[0].
__str__(), self.game_state['table'].seats.players[i].
hole_card[1].__str__()
]):
self.suited[i] = 1
else:
self.suited[i] = 0
def get_all_in_amount(self):
for e in self.events:
if (e['type'] == 'event_ask_player'):
return e['valid_actions'][2]['amount']['max']
def get_call_amount(self):
for e in self.events:
if (e['type'] == 'event_ask_player'):
return e['valid_actions'][1]['amount']
def get_sb_reward(self):
for e in self.events:
if (e['type'] == 'event_round_finish'):
if (e['winners'][0]['uuid'] == 'sb_player'):
return (e['winners'][0]['stack'] - self.starting_stack)
else:
return -(e['winners'][0]['stack'] - self.starting_stack)
def play_action(self, action):
if (action == 0):
self.game_state, self.events = self.emulator.apply_action(
self.game_state, 'fold', 0)
elif (action == 1):
if self.get_all_in_amount() == -1:
self.game_state, self.events = self.emulator.apply_action(
self.game_state, 'call', self.get_call_amount())
else:
self.game_state, self.events = self.emulator.apply_action(
self.game_state, 'raise', self.get_all_in_amount())
def new_hand(self, starting_stack):
self.initial_game_state = self.emulator.generate_initial_game_state(
self.players_info)
self.street = 'preflop'
self.hole_cards = {}
self.starting_stack = starting_stack
self.players_info = {
"bb_player": {
"name": "bb_player",
"stack": starting_stack
},
"sb_player": {
"name": "sb_player",
"stack": starting_stack
},
}
self.initial_game_state = self.emulator.generate_initial_game_state(
self.players_info)
self.game_state, self.events = self.emulator.start_new_round(
self.initial_game_state)
self.players_cards = [np.zeros(13), np.zeros(13)]
self.get_hand_feature()
def get_action_histories_text(self, hole_cards=False):
if (hole_cards == True):
print(self.hole_cards)
histo = self.events[0]['round_state']['action_histories']
hand_text = ""
for k, v in histo.items():
if (len(v) > 0):
hand_text += k + '\n'
for a in v:
if (a['action'] == 'RAISE'):
hand_text += a['uuid'] + \
' raises to ' + str(a['amount']) + '\n'
elif (a['action'] == 'FOLD'):
hand_text += a['uuid'] + ' folds\n'
elif (a['action'] == 'CALL' and a['amount'] == 0):
hand_text += a['uuid'] + ' checks\n'
else:
hand_text += a['uuid'] + ' ' + \
a['action'] + ' ' + str(a['amount']) + '\n'
return hand_text
class EmulatorTest(BaseUnitTest):
def setUp(self):
self.emu = Emulator()
def test_set_game_rule(self):
self.emu.set_game_rule(2, 8, 5, 3)
self.eq(2, self.emu.game_rule['player_num'])
self.eq(8, self.emu.game_rule['max_round'])
self.eq(5, self.emu.game_rule['sb_amount'])
self.eq(3, self.emu.game_rule['ante'])
def test_register_and_fetch_player(self):
p1, p2 = FoldMan(), FoldMan()
self.emu.register_player('uuid-1', p1)
self.emu.register_player('uuid-2', p2)
self.eq(p1, self.emu.fetch_player('uuid-1'))
self.eq(p2, self.emu.fetch_player('uuid-2'))
@raises(TypeError)
def test_register_invalid_player(self):
self.emu.register_player('uuid', 'hoge')
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_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_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_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)
@raises(Exception)
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(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_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_game_finish_detect(self):
uuids = ['tojrbxmkuzrarnniosuhct', 'pwtwlmfciymjdoljkhagxa']
holecards = [[Card.from_str(s) for s in ss]
for ss in [['Ac', '2d'], ['8c', '5h']]]
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('7c'))
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_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_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_run_until_game_finish_when_final_round(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)
[self.emu.register_player(uuid, FoldMan()) for uuid in uuids]
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(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_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_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_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.PLAY_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_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_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_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))
from pypokerengine.api.emulator import Emulator
from honest_player_og import HonestPlayer
from random_player import RandomPlayer
from risky_player import RiskyPlayer
from qlearner import RLPlayer
import pandas as pd
import numpy as np
# 1. Set game settings on emulator
n_players = 2
emulator = Emulator()
quuid = "uuid-q"
qlearner_player = RLPlayer(n_players, quuid)
df1 = pd.DataFrame(columns=['uuid', 'win_ratio', 'stack-diff'])
df2 = pd.DataFrame(columns=['uuid', 'win_ratio', 'stack-diff'])
df3 = pd.DataFrame(columns=['uuid', 'win_ratio', 'stack-diff'])
df4 = pd.DataFrame(columns=['uuid', 'win_ratio', 'stack-diff'])
max_round = 50
learning_rates = np.arange(0.1, 1, 0.1)
#learning_rates = [0.3]
for j in learning_rates:
qlearner_player = RLPlayer(n_players, quuid, j)
for i in range(0, 150):
emulator.register_player(uuid="uuid-1", player=HonestPlayer(n_players))
#emulator.register_player(uuid="uuid-2", player=RiskyPlayer(n_players))
emulator.register_player(uuid=quuid, player=qlearner_player)
emulator.set_game_rule(player_num=n_players,
max_round=max_round,
small_blind_amount=20,
ante_amount=0)
players_info = {
class EventTest(BaseUnitTest):
def setUp(self):
self.emu = Emulator()
def test_create_new_street_event(self):
message = {
'message_type': 'street_start_message',
'street': 'preflop',
'round_state': 1
}
event = self.emu.create_event(message)
self.eq('event_new_street', event['type'])
self.eq('preflop', event['street'])
self.eq(1, event['round_state'])
def test_create_ask_player_event(self):
message = {
'message_type': 'ask_message',
'hole_card': 1,
'valid_actions': 2,
'round_state': TwoPlayerSample.round_state,
'action_histories': [4, 5]
}
event = self.emu.create_event(message)
self.eq('event_ask_player', event['type'])
self.eq(2, event['valid_actions'])
self.eq(TwoPlayerSample.round_state, event['round_state'])
self.eq('pwtwlmfciymjdoljkhagxa', event['uuid'])
def test_create_round_finish_event(self):
message = {
'message_type':
'round_result_message',
'round_count':
2,
'round_state':
TwoPlayerSample.round_state,
'hand_info': [],
'winners': [{
'stack': 105,
'state': 'participating',
'name': 'p2',
'uuid': 'pwtwlmfciymjdoljkhagxa'
}]
}
event = self.emu.create_event(message)
self.eq('event_round_finish', event['type'])
self.eq(TwoPlayerSample.round_state, event['round_state'])
self.eq('pwtwlmfciymjdoljkhagxa', event['winners'][0]['uuid'])
self.eq(105, event['winners'][0]['stack'])
def test_create_game_finish_event(self):
message = {
'message_type': 'game_result_message',
'game_information': {
'player_num':
2,
'rule': {
'max_round': 10,
'initial_stack': 100,
'small_blind_amount': 5
},
'seats': [{
'stack': 0,
'state': 'folded',
'name': 'p1',
'uuid': 'tojrbxmkuzrarnniosuhct'
}, {
'stack': 200,
'state': 'participating',
'name': 'p2',
'uuid': 'pwtwlmfciymjdoljkhagxa'
}]
}
}
event = self.emu.create_event(message)
self.eq('event_game_finish', event['type'])
self.eq('tojrbxmkuzrarnniosuhct', event['players'][0]['uuid'])
self.eq(0, event['players'][0]['stack'])
self.eq('pwtwlmfciymjdoljkhagxa', event['players'][1]['uuid'])
self.eq(200, event['players'][1]['stack'])