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 = {}
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)
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.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_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 __init__(self): self.game_states_ = dict() # maps history to node self.emulator = Emulator()
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
def setUp(self): self.emu = Emulator()
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 __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 __init__(self, model_player, my_model): super(EmulatorPlayer, self).__init__() self.opponents_model = model_player self.my_model = my_model self.emulator = Emulator()
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 = {
from console_player import ConsolePlayer from pypokerengine.api.emulator import Emulator from bot import PGBot from pypokerengine.utils.game_state_utils import attach_hole_card_from_deck, attach_hole_card, replace_community_card from pypokerengine.utils.card_utils import gen_cards SAVE_PATH = 'saved_models/second_test/policy_net_after' STACK = 1000 N_PLAYER = 2 MAX_ROUND = 2 SMALL_BLIND_AMOUNT = 5 ANTE_AMOUNT = 1 if __name__ == '__main__': emul = Emulator() emul.set_game_rule(N_PLAYER, MAX_ROUND, SMALL_BLIND_AMOUNT, ANTE_AMOUNT) console = ConsolePlayer() bot = PGBot("bot", pickle.load(open(SAVE_PATH + "105980", "rb"))) emul.register_player("target", bot) emul.register_player("baseline", console) players_info = { "target": { "name": "PGBot", "stack": STACK }, "baseline": { "name": "console", "stack": STACK } }