def test(size=5):
game = UI(win, size=size)
game.grid(sticky='nesw')
ai = RandomPlayer(size)
while not game.is_game_over():
game.move(ai.choose_move(game.board))
game.after(250)
def testperf(agent_name1, agent1, agent_name2, agent2):
# Init to play 500 games of 1000 rounds
num_game = 100
max_round = 1000
initial_stack = 10000
smallblind_amount = 20
# Init pot of players
agent1_pot = 0
agent2_pot = 0
# Setting configuration
config = setup_config(max_round=max_round,
initial_stack=initial_stack,
small_blind_amount=smallblind_amount)
# Register players
config.register_player(name=agent_name1, algorithm=RandomPlayer())
config.register_player(name=agent_name2, algorithm=RandomPlayer())
# Start playing num_game games
for game in range(1, num_game + 1):
print("Game number: ", game)
game_result = start_poker(config, verbose=0)
agent1_pot = game_result['players'][0]['stack']
agent2_pot = game_result['players'][1]['stack']
pprint.pprint(game_result)
print("Finished Game : " + str(game) + "\n\n")
if (agent1_pot + agent2_pot != 2 * initial_stack):
raise ValueError("Missing Money !!!")
def parse_arguments():
parser = ArgumentParser()
parser.add_argument('-n1', '--agent_name1', help="Name of agent 1", default="Your agent", type=str)
parser.add_argument('-a1', '--agent1', help="Agent 1", default=RandomPlayer())
parser.add_argument('-n2', '--agent_name2', help="Name of agent 2", default="Your agent", type=str)
parser.add_argument('-a2', '--agent2', help="Agent 2", default=RandomPlayer())
args = parser.parse_args()
return args.agent_name1, args.agent1, args.agent_name2, args.agent2
def main():
checkers_model = DeepCheckersHandler()
if os.path.isfile(os.getcwd() + "/modelweights_move_mc.ckpt.data-00000-of-00001"):
checkers_model.model.built = True
checkers_model.model.load_weights(os.getcwd() + "/modelweights_move_mc.ckpt")
print("Loaded weights")
test_p1_loss = tf.keras.metrics.Mean('p1_random_losses', dtype=tf.float32)
test_p2_loss = tf.keras.metrics.Mean('p2_random_losses', dtype=tf.float32)
test_writer = tf.summary.create_file_writer(os.getcwd() + '/logs/test')
p1 = ANNPlayer(1,checkers_model)
p2 = ANNPlayer(2,checkers_model)
validation_player1 = RandomPlayer(1)
validation_player2 = RandomPlayer(2)
test_epoch = 0
turns = 0
for g in range(100000):
print("Game " + str(g))
if g % 20 == 0:
p1.train_mode = False
p2.train_mode = False
winner1 = []
winner2 = []
for i in range(10):
res1,_ = play_game(p1,validation_player2,False)
res2,_ = play_game(validation_player1, p2,False)
winner1.append(0 if res1 == 1 else 1)
winner2.append(0 if res2 == 2 else 1)
test_p1_loss(winner1)
test_p2_loss(winner2)
with test_writer.as_default():
tf.summary.scalar('p1_random_losses', test_p1_loss.result(), step=test_epoch)
tf.summary.scalar('p2_random_losses', test_p2_loss.result(), step=test_epoch)
tf.summary.scalar('game_train_turns', turns/20.0, step=test_epoch)
turns = 0
p1.train_mode = True
p2.train_mode = True
test_epoch += 1
w, t = play_game(p1,p2,False)
turns += t
p1.game_nr += 1
p2.game_nr += 1
p1.result(1 if w == 1 else -1)
p2.result(1 if w == 2 else -1)
def simulate(self, nGames, nRounds, initial_stack, small_blind_amount):
# since no api is provided for simulate games with known hole_card value, we just simulate nRounds using random player for convenience purpose
results = []
config = setup_config(max_round=nRounds, initial_stack=initial_stack, small_blind_amount=small_blind_amount)
config.register_player(name="f1", algorithm=RandomPlayer())
config.register_player(name="FT2", algorithm=RandomPlayer())
for i in range(nGames):
game_result = start_poker(config, verbose=0)
results.append(game_result['players'][0]['stack'] - game_result['rule']['initial_stack'])
print(sum(results)/len(results))
def __init__(self):
self.games_board = Board(8)
self.game_view = View(self.games_board)
self.rules_game = Rules(self.games_board)
self.player_one = HumanPlayer(Disk.DARK)
self.player_two = RandomPlayer(Disk.LIGHT)
def testperf(agent_name1, agent1, agent_name2, agent2):
# Init to play 500 games of 1000 rounds
num_game = 500
max_round = 1000
initial_stack = 10000
smallblind_amount = 20
# Init pot of players
agent1_pot = 0
agent2_pot = 0
# Setting configuration
config = setup_config(max_round=max_round,
initial_stack=initial_stack,
small_blind_amount=smallblind_amount)
# Register players
config.register_player(name=agent_name1, algorithm=RandomPlayer())
config.register_player(name=agent_name2, algorithm=RandomPlayer())
# config.register_player(name=agent_name1, algorithm=agent1())
# config.register_player(name=agent_name2, algorithm=agent2())
# Start playing num_game games
for game in range(1, num_game + 1):
print("Game number: ", game)
game_result = start_poker(config, verbose=0)
agent1_pot = agent1_pot + game_result['players'][0]['stack']
agent2_pot = agent2_pot + game_result['players'][1]['stack']
print("\n After playing {} games of {} rounds, the results are: ".format(
num_game, max_round))
# print("\n Agent 1's final pot: ", agent1_pot)
print("\n " + agent_name1 + "'s final pot: ", agent1_pot)
print("\n " + agent_name2 + "'s final pot: ", agent2_pot)
# print("\n ", game_result)
# print("\n Random player's final stack: ", game_result['players'][0]['stack'])
# print("\n " + agent_name + "'s final stack: ", game_result['players'][1]['stack'])
if (agent1_pot < agent2_pot):
print("\n Congratulations! " + agent_name2 + " has won.")
elif (agent1_pot > agent2_pot):
print("\n Congratulations! " + agent_name1 + " has won.")
# print("\n Random Player has won!")
else:
print("\n It's a draw!")
def initialize_players(self):
self.players = [UserPlayer()]
self.players.extend(
[RandomPlayer() for _ in range(self.num_players - 1)])
for i, player in enumerate(self.players, 1):
player.num = i
last_player = self.players[0]
for player in reversed(self.players):
player.next_player = last_player
last_player = player
def main():
tokens = {
'Red': isolation.Board.RED_TOKEN,
'Blue': isolation.Board.BLUE_TOKEN
}
exceptions = []
scores = {"aqua": 0, "random": 0}
for i in range(10):
us = random.choice(list(tokens.keys()))
them = 'Red' if us == 'Blue' else 'Blue'
try:
if us == 'Red':
isolation.Board.set_dimensions(6, 8)
our_player = aqua.Aqua('Red', isolation.Board.RED_TOKEN)
match = isolation.Match(
RandomPlayer('Blue', isolation.Board.BLUE_TOKEN),
our_player, isolation.Board())
else:
isolation.Board.set_dimensions(6, 8)
our_player = aqua.Aqua('Blue', isolation.Board.BLUE_TOKEN)
match = isolation.Match(
our_player, RandomPlayer('Red', isolation.Board.RED_TOKEN),
isolation.Board())
match.start_play()
if match.winner() == our_player:
scores["aqua"] = scores["aqua"] + 1
else:
scores["random"] = scores["random"] + 1
except Exception as e:
exceptions.append(e)
print("Aqua's Score: ", scores["aqua"])
print("Enemy Score: ", scores["random"])
print("Error count: ", len(exceptions))
class SmartMinimax(Player):
logger = logging.getLogger(__name__)
def __init__(self, name="Smart Minimax"):
super().__init__(name)
self.random_player = RandomPlayer("Utility Random")
self.minimax_payer = Minimax("Utility Minimax")
def play(self, tc):
if len(tc.remaining_pieces) > 10:
SmartMinimax.logger.debug(
f"{self.name} plays random - {len(tc.remaining_pieces)} remaining pieces."
)
return self.random_player.play(tc)
SmartMinimax.logger.debug(
f"{self.name} plays optimal - {len(tc.remaining_pieces)} remaining pieces."
)
return self.minimax_payer.play(tc)
from randomplayer import RandomPlayer
import numpy as np
class Game:
def __init__(self, p1, p2):
self.discount = 0.8
self.field = Field()
self.player1 = p1
self.player2 = p2
def play(self):
self.field.reset()
first_player = np.random.randint(2)
for turn in range(6 * 7 + 7):
current_player = 1 if (turn + first_player) % 2 else -1
if current_player == -1:
take_turn = self.player1.take_turn(self.field)
else:
take_turn = self.player2.take_turn(self.field)
_field, x, done, player = self.field.put(take_turn, current_player)
if done:
print("Turns " + str(turn))
print(x)
print(player)
return self.field
g = Game(RandomPlayer(), RandomPlayer())
print(g.play().getField())
def setup_ai():
return RandomPlayer()
continue
nHistory = history + [tile]
nHeuristic = self.hCalc(tile, targetLocation, len(nHistory),
board)
nElement = (nHeuristic, tile, nHistory)
heappush(myHeap, (nHeuristic, tile, nHistory))
if __name__ == '__main__':
# Create a match
isolation.Board.set_dimensions(6, 8)
red_wins = 0
wins = {}
for i in range(500):
ref = isolation.Match(RandomPlayer('Blue', isolation.Board.BLUE_TOKEN),
PlayerAgent('Red', isolation.Board.RED_TOKEN),
isolation.Board())
ref.start_play()
if ref.winner() is None:
continue
if ref.winner().name() not in wins:
wins[ref.winner().name()] = 0
wins[ref.winner().name()] += 1
print(wins)
# print(red_wins)
from pypokerengine.api.game import setup_config, start_poker from randomplayer import RandomPlayer from raise_player import RaisedPlayer #TODO:config the config as our wish config = setup_config(max_round=10, initial_stack=10000, small_blind_amount=10) config.register_player(name="FT1", algorithm=RaisedPlayer()) config.register_player(name="FT2", algorithm=RandomPlayer()) game_result = start_poker(config, verbose=0)
def makeRandomPlayer(playerNumber): p = RandomPlayer(playerNumber) p.rollouts = 0 p.message = "" return p
if not replay:
# randomly initialize opponent weights if not replaying
agent_weights = []
for x in range(NUMBER_OF_WEIGHTS):
agent_weights.append(random.random())
# max_round: number of times players can play against each. set to be the same as number of rounds in actual assessment
# initial_stack: starting money. set to be 1000 as per assessment
# small_blind_amount: set to be 10 as per assessment
config = setup_config(
max_round=500, initial_stack=10000, small_blind_amount=20)
config.register_player(
name="my_agent", algorithm=MinimaxPlayer(agent_weights))
config.register_player(name="opponent_agent",
algorithm=RandomPlayer())
print("agent: ", agent_weights)
game_result = start_poker(config, verbose=1)
my_agent_end_stack = game_result["players"][0]["stack"]
opponent_end_stack = game_result["players"][1]["stack"]
print("agent stack: ", my_agent_end_stack)
print("opponent stack: ", opponent_end_stack)
if my_agent_end_stack > opponent_end_stack:
# agent won so weights remains unchanged
number_of_iterations = number_of_iterations + 1
replay = False
from pypokerengine.api.game import setup_config, start_poker from fishplayer import FishPlayer from consoleplayer import ConsolePlayer from randomplayer import RandomPlayer from honestplayer import HonestPlayer ''' The random player, well, performs random decisions. The fish player always calls. The console player let you participate using the console. 10 players in total ''' config = setup_config(max_round=2, initial_stack=10000, small_blind_amount=20) config.register_player(name="Fish1", algorithm=FishPlayer()) config.register_player(name="Fish2", algorithm=FishPlayer()) config.register_player(name="Fish3", algorithm=FishPlayer()) config.register_player(name="Fish4", algorithm=FishPlayer()) config.register_player(name="Random1", algorithm=RandomPlayer()) config.register_player(name="Random2", algorithm=RandomPlayer()) config.register_player(name="Random3", algorithm=RandomPlayer()) config.register_player(name="Random4", algorithm=RandomPlayer()) config.register_player(name="Random5", algorithm=RandomPlayer()) #config.register_player(name="h1", algorithm=HonestPlayer()) config.register_player(name="DrDram", algorithm=ConsolePlayer()) game_result = start_poker(config, verbose=1)
def __init__(self, name="Smart Minimax"):
super().__init__(name)
self.random_player = RandomPlayer("Utility Random")
self.minimax_payer = Minimax("Utility Minimax")
opts, args = getopt.getopt(sys.argv[1:], 'n:r:i:s')
except getopt.GetoptError:
usage()
sys.exit(2)
for o, a in opts:
if o == '-n': # number of games
num_game = int(a)
elif o == '-r': # max round for each game
num_round = int(a)
elif o == '-i': # initial stackss
initial_stack = int(a)
elif o == '-s': # small blind
small_blind = int(a)
else:
usage()
sys.exit(2)
smartPlayer = SmartPlayer()
randomPlayer = RandomPlayer()
config = set_config(smartPlayer, randomPlayer)
print 'Start training with: \nNo. of games: %d\nMax rounds: %d\nInitial stack: %d\nSmall blind amount: %d' % (
num_game, num_round, initial_stack, small_blind)
for game_batch in range(0, num_game):
win_cnt = initiate_game(config)
smartPlayer.exp_replay()
smartPlayer.save("dqn_model.h5")
if game_batch > 0:
smartPlayer.load("dqn_model.h5")
from pypokerengine.api.game import setup_config, start_poker import pypokerengine from fishplayer import FishPlayer from consoleplayer import ConsolePlayer from randomplayer import RandomPlayer from honestplayer import HonestPlayer config = setup_config(max_round=100, initial_stack=1000, small_blind_amount=20) config.register_player(name="f1", algorithm=FishPlayer()) config.register_player(name="f2", algorithm=FishPlayer()) config.register_player(name="f3", algorithm=FishPlayer()) config.register_player(name="f4", algorithm=FishPlayer()) config.register_player(name="f5", algorithm=RandomPlayer()) config.register_player(name="r1", algorithm=RandomPlayer()) config.register_player(name="r2", algorithm=RandomPlayer()) config.register_player(name="r3", algorithm=RandomPlayer()) config.register_player(name="r4", algorithm=RandomPlayer()) config.register_player(name="r5", algorithm=RandomPlayer()) #config.register_player(name="h1", algorithm=HonestPlayer()) game_result = start_poker(config, verbose=1)
#!/usr/bin/python
from game import Game
from player import Player
from randomplayer import RandomPlayer
from student import StudentPlayer
if __name__ == '__main__':
players = [RandomPlayer("EU", 100)]
for i in range(100):
#print players
g = Game(players, shoe_size=4, min_bet=1, max_bet=5)
#g = Game(players, debug=True)
g.run()
print "OVERALL: ", players
