def genmove_cmd(self, args):
"""
Generate a move for the color args[0] in {'b', 'w'}, for the game of gomoku.
"""
board_color = args[0].lower()
color = color_to_int(board_color)
game_end, winner = self.board.check_game_end_gomoku()
########### find_winner = ALPHABETA #### (Need Solver method)
if game_end:
if winner == color:
self.respond("pass")
else:
self.respond("resign")
return
else:
############## get the possible winning moves in the minimax solver################ (Need solver method)
solveAnswer = solve_in(self)
returnSA = solveAnswer.split(" ")
if returnSA[0] == 'b' or returnSA[0] == 'w':
if returnSA[0] != args[0].lower():
#toplay is losing so play a random move
move = GoBoardUtil.generate_random_move_gomoku(
self.board
) # generate random move if we cannot get it on time
move = self.go_engine.get_move(self.board, color)
else:
#play a move on the track to a bol_return
coord = move_to_coord(returnSA[1], self.board.size)
move = coord_to_point(coord[0], coord[1], self.board.size)
else:
#unknown or draw state so play a random move
move = GoBoardUtil.generate_random_move_gomoku(
self.board
) # generate random move if we cannot get it on time
move = self.go_engine.get_move(self.board, color)
move_coord = point_to_coord(move, self.board.size)
move_as_string = format_point(move_coord)
if self.board.is_legal_gomoku(move, color):
self.board.play_move_gomoku(move, color)
self.toPlay = switchToPlay(args[0].lower())
self.respond(move_as_string)
else:
move = self.go_engine.get_move(self.board, color)
if move == PASS:
self.respond("pass")
return
move_coord = point_to_coord(move, self.board.size)
move_as_string = format_point(move_coord)
if self.board.is_legal_gomoku(move, color):
self.board.play_move_gomoku(move, color)
self.respond(move_as_string)
else:
self.respond("illegal move: {}".format(move_as_string))
def get_move(self, board, color):
# """
# The genmove function called by gtp_connection
# """
# moves=GoBoardUtil.generate_legal_moves_gomoku(board)
# toplay=board.current_player
# best_result, best_move=-1.1, None
# best_move=moves[0]
# wins = np.zeros(len(moves))
# visits = np.zeros(len(moves))
# while True:
# for i, move in enumerate(moves):
# play_move(board, move, toplay)
# res=game_result(board)
# if res == toplay:
# undo(board, move)
# #This move is a immediate win
# self.best_move=move
# return move
# ret=self._do_playout(board, toplay)
# wins[i] += ret
# visits[i] += 1
# win_rate = wins[i] / visits[i]
# if win_rate > best_result:
# best_result=win_rate
# best_move=move
# self.best_move=best_move
# undo(board, move)
# assert(best_move is not None)
# return best_move
return GoBoardUtil.generate_random_move_gomoku(board)
def playGame(board, toPlay):
"""
run simulation game
"""
limit = 1000
simulation_moves = []
#cboard = board.copy()
nuPasses = 0
for _ in range(limit):
#while True:
color = board.current_player
playout_move = GoBoardUtil.generate_random_move_gomoku(board)
if playout_move != None:
if_legal = board.play_move_gomoku(playout_move, color)
#simulation_moves.append(playout_move)
#_, res = board.check_game_end_gomoku()
#print(if_legal)
if not if_legal:
print("illegal move#")
#assert if_legal
else:
#board.play_move_gomoku(playout_move, color)
if playout_move == PASS:
break
#nuPasses +=1
#else nuPasses = 0
#if nuPasses >= 2:
# break
color = GoBoardUtil.opponent(color)
_, winner = board.check_game_end_gomoku()
return winner
def simulate_iter(self, board, player, mode):
is_end, win = board.check_game_end_gomoku()
if is_end:
if win == player:
return 2
else:
return 0
if mode == "random":
move = GoBoardUtil.generate_random_move_gomoku(board)
else:
legalmoves = self.rulebased(board, player)
if legalmoves:
move = legalmoves[:1]
move = move[0]
else:
move = GoBoardUtil.generate_random_move_gomoku(board)
if move == None:
return 1
board.play_move_gomoku(move, board.current_player)
return self.simulate_iter(board, player, mode)
def sim(board, player1, player2):
game_end, winner = board.check_game_end_gomoku()
if game_end == True:
if winner == player1:
return 1
else:
return 0
move = GoBoardUtil.generate_random_move_gomoku(board)
if move == PASS:
return 0
board.play_move_gomoku(move, player2)
return sim(board, player1, GoBoardUtil.opponent(player2))
def random(self, board, original, color):
game_end, winner = self.board.check_game_end_gomoku(
) # check if the game ends or not
if game_end:
if winner == original:
return True
move = GoBoardUtil.generate_random_move_gomoku(board)
if move == PASS:
return False
#play move
self.board.play_move_gomoku(move, color)
status = self.random(self.board, original, GoBoardUtil.opponent(color))
self.board.reset_point_gomoku(move, color)
return status
def _evaluate_rollout(self, board, toplay,ow):
"""
Use the rollout policy to play until the end of the game, returning +1 if the current
player wins, -1 if the opponent wins, and 0 if it is a tie.
"""
end, Winner = board.check_game_end_gomoku()
while not end:
end, Winner = board.check_game_end_gomoku()
move = GoBoardUtil.generate_random_move_gomoku(board)
if move == PASS:
return 0
board.play_move_gomoku(move,board.current_player)
if Winner == ow:
return 1
else:
return 0
def genmove_cmd(self, args):
"""
Generate a move for the color args[0] in {'b', 'w'}, for the game of gomoku.
"""
board_color = args[0].lower()
color = color_to_int(board_color)
game_end, winner = self.board.check_game_end_gomoku()
start = time.clock()
result = self.callAlphabetaDL(4)
end = time.clock() - start
if game_end:
if winner == color:
self.respond("pass")
else:
self.respond("resign")
return
else:
#win_moves is a list. If toplayer is losing or draw, it only has None, else is has moves that lead him to win
#win_moves = self.solve_cmd(args)
win_moves = result[1]
if end > self.time or result[0] == -1:
move = GoBoardUtil.generate_random_move_gomoku(self.board)
if move == PASS:
self.respond("pass")
return
move = win_moves[0]
'''
if result[0] == -1:
#move = self.go_engine.get_move(self.board, color)
move = GoBoardUtil.generate_random_move_gomoku(self.board)
if move == PASS:
self.respond("pass")
return
'''
move_coord = point_to_coord(move, self.board.size)
move_as_string = format_point(move_coord)
if self.board.is_legal_gomoku(move, color):
self.board.play_move_gomoku(move, color)
self.respond(move_as_string)
else:
self.respond("illegal move: {}".format(move_as_string))
def play_game(board, color, **kwargs):
"""
Run a simluation game according to give parameters
"""
random_simulation = kwargs.pop('random_simulation', True)
# use_pattern = kwargs.pop('use_pattern', False)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
while (True):
if random_simulation:
move = GoBoardUtil.generate_random_move_gomoku(board)
else:
move = PatternUtil.generate_policy_move_gomoku(board)
if move == PASS:
return None
board.play_move_gomoku(move, board.current_player)
has_winner, winner = board.check_game_end_gomoku()
if has_winner == True:
return winner
def get_move(self, board, color):
return GoBoardUtil.generate_random_move_gomoku(board)
def Monte_Carlo_Tree(simple_board, player2):
### Start ###
start_move = PASS
start = time.time()
new_move = GoBoardUtil.generate_legal_moves_gomoku(simple_board)
if len(new_move) == 0:
return start_move
test = simple_board.copy()
first = board_num(test)
first_copy = first
monte_tree = {}
try:
signal.alarm(55)
while (time.time() - start) < 56: # 10 second testing
test = simple_board.copy()
if start_move != PASS:
test.play_move_gomoku(start_move, player2)
player2 = GoBoardUtil.opponent(player2)
search = board_num(test)
while search in monte_tree:
move_lists = search2(monte_tree, first)
if len(move_lists) == 0:
print("out of while search in monte_tree")
break
searching_key = GetMAX(
monte_tree,
move_lists) # best key ratio in the list (need it!)
test.play_move_gomoku(monte_tree[searching_key].move,
player2)
player2 = GoBoardUtil.opponent(player2)
new_move = []
all_moves = GoBoardUtil.generate_legal_moves_gomoku(test)
if len(all_moves) == 0:
break
for i in range(5):
new_move.append(random.choice(all_moves))
for move in new_move:
new_search_board = simple_board.copy()
new_search_board.play_move_gomoku(move, player2)
ending = sim_do(new_search_board.copy(), 50, player2)
player1 = GoBoardUtil.opponent(player2)
if (ending > 0 and player2 != player1):
game_ending = 1
#elif (ending == 1 and player2 == player1):
# game_ending = 1
else:
game_ending = 0
print(game_ending, player2)
if game_ending == 0:
# loss move
new_state = state(1, 0, first, move)
BackProp(monte_tree, first, first_copy, False)
else:
print("win state")
print(move)
new_state = state(1, ending, first, move)
BackProp(monte_tree, first, first_copy, True)
spec_key = board_num(new_search_board)
monte_tree[spec_key] = new_state
start_move = best_move(simple_board, monte_tree, first_copy)
#print(start_move)
return start_move
signal.alarm(0)
except Exception as e:
if start_move != None:
return start_move
else:
return GoBoardUtil.generate_random_move_gomoku(simple_board)