def _test_print_jump_table():
my_board = board.board()
p1 = player(my_board, my_board.player_1, my_board.mark_player_1)
p1.dump_jump_table()
print("********** player move ************")
p1.move()
p1.dump_jump_table()
def _test_play():
n_times = 1
for trial in range(n_times):
# as we use go_board, we need to use its size 19x19
my_board = board.board(size=19)
my_board.verbose = False
gui_go_board = go_board(None)
# wire gui click to board
# player 1: auto_player, white
# player 2: gui, black
evaluators = [
{
'fn': eval_func.own_bingo,
'weight': 5.0
},
{
'fn': eval_func.opp_bingo,
'weight': 5.0
},
{
'fn': eval_func.own_almost_bingo,
'weight': 2.0
},
{
'fn': eval_func.opp_almost_bingo,
'weight': 2.0
},
#{'fn': eval_func.freedom, 'weight': 1.0},
{
'fn': eval_func.center,
'weight': 1.0
},
]
auto_player = player(my_board, my_board.player_1,
my_board.mark_player_1, evaluators)
def move_auto_player(board, gui_board):
if auto_player.move():
player, (row, col) = board.get_last_move()
# print(player, col, row)
gui_board.put_stone(row, col, "white")
# board.print_board() # uncomment to see if gui and board are in synch
# move_auto_player(my_board, gui_board) # uncomment to have computer play first
def on_gui_move(board, move, gui_board):
# register gui move to board
col, row = move
board.player_2((row, col))
if board.finished() is False:
move_auto_player(board, gui_board)
if board.finished() is True:
gui_board.set_move_allowed(False)
# on put stone, call my_board's player 2
put_stone_fn = lambda event: gui_go_board.put_black_on_click(
event,
callback_fn=lambda col, row: on_gui_move(my_board,
(col, row), gui_go_board))
gui_go_board.set_on_click_callback(put_stone_fn)
gui_go_board.pack()
gui_go_board.mainloop()
def _test_play(n_times):
my_board = board.board()
my_board.verbose = False
fin_moves = []
wins = {}
wins[my_board.mark_player_1] = 0
wins[my_board.mark_player_2] = 0
last_finished_board = None
for trial in range(n_times):
my_board.reset()
evaluators1 = [
{'fn': eval_func.own_bingo, 'weight': 5.0},
{'fn': eval_func.opp_bingo, 'weight': 5.0},
{'fn': eval_func.own_almost_bingo, 'weight': 2.0},
{'fn': eval_func.opp_almost_bingo, 'weight': 2.0},
#{'fn': eval_func.freedom, 'weight': 1.0},
{'fn': eval_func.center, 'weight': 1.0},
]
p1 = player(my_board, my_board.player_1, my_board.mark_player_1, evaluators1)
evaluators2 = [
{'fn': eval_func.own_bingo, 'weight': 5.0},
{'fn': eval_func.opp_bingo, 'weight': 5.0},
{'fn': eval_func.own_almost_bingo, 'weight': 2.0},
{'fn': eval_func.opp_almost_bingo, 'weight': 2.0},
#{'fn': eval_func.freedom, 'weight': 1.0},
{'fn': eval_func.center, 'weight': 1.0},
]
p2 = player(my_board, my_board.player_2, my_board.mark_player_2, evaluators2)
# interesting fact: this monte carlo shows first player have an edge
players = [p1, p2]
winner = " "
num_moves = -1
for i in range(my_board.board_size() ** 2):
p = players[i % 2]
p.move()
if my_board.finished():
#board.print_board()
fin_moves.append(i)
wins[p.mark()] += 1
last_finished_board = copy.deepcopy(my_board)
winner = p.mark()
num_moves = i
break
print("{} === PLAYER {} WINS === # moves [{}]".format(trial, winner, num_moves))
if last_finished_board is None:
my_board.print_board()
else:
last_finished_board.print_board()
avg_moves = 0
if len(fin_moves) > 0:
avg_moves = sum(fin_moves) / float(len(fin_moves))
print("avg moves: {:.3f}, wins: {}".format(avg_moves, wins))
args = vars(parser.parse_args())
if args['log']=='y':
toLog=True
else:
toLog=False
if args['seed'] == "":
val = None
elif args['seed'] != "":
val = args['seed']
gameboard = board("Red", toLog)
trainee = opponent('Red', seed(None), toLog)
trainer = opponent('Black', seed(val), toLog)
trainer.genPieceProgram()
trainer.genMoveProgram()
trainee.genPieceProgram()
trainee.genMoveProgram()
winStatus =trainGame()
points = score(gameboard.Red, gameboard.Black, winStatus)
print points
gameboard.moveCount +=1
if gameboard.moveCount == 60:
log('Draw')
break
gameLoop = gameboard.win()
parser = argparse.ArgumentParser(description='Input commands.')
parser.add_argument('-color', default='Red', choices=['Red', 'Black'], help='Select a color you wish to play agaisnt the computer r or b')
parser.add_argument('-seed', default='', help='Seed value to generate the opponent')
args = vars(parser.parse_args())
gameboard = board(args['color'], True)
if args['seed'] == "":
val = None
elif args['seed'] != "":
val = args['seed']
if args['color']=='Red':
comp = opponent('Black', seed(val), True)
elif args['color']=='Black':
comp = opponent('Red', seed(val), True)
comp.genPieceProgram()
comp.genMoveProgram()
