def generate_moves(board, use_pattern, check_selfatari):
"""
generate a list of policy moves on board for board.current_player.
calls function from util folder for fallback
"""
if use_pattern:
if board.last_move is not None:
# checks if atari capture possible
single_liberty = []
liberty_point = board._single_liberty(
board.last_move, GoBoardUtil.opponent(board.current_player))
if liberty_point is not None and board.check_legal(
liberty_point, board.current_player):
single_liberty.append(liberty_point)
#checks for selfatari
single_liberty = GoBoardUtil.filter_moves(
board, single_liberty, check_selfatari)
if len(single_liberty) > 0:
return single_liberty, "AtariCapture"
#checks for atari defense
defense_points = try_to_defend(board)
defense_points = GoBoardUtil.filter_moves(board, defense_points,
check_selfatari)
if len(defense_points) > 0:
return defense_points, "AtariDefense"
policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves(
board, use_pattern, check_selfatari)
return policy_moves, type_of_move
def policy_moves_cmd(self, args):
"""
Return list of policy moves for the current_player of the board
"""
# policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves(self.board,
# self.go_engine.pattern,
# self.go_engine.selfatari)
policy_moves = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.pattern, self.go_engine.selfatari)
# alphaList = []
# for move, val in policy_moves:
# alphaList.append((self.board.point_to_string(move), val))
# policy_moves = sorted(alphaList, key=lambda x: x[0])
# if len(policy_moves) == 0:
# self.respond("Pass")
# else:
# response = type_of_move + " " + GoBoardUtil.sorted_point_string(policy_moves, self.board.NS)
# self.respond(response)
if len(policy_moves) == 0:
self.respond("pass 1.00000")
else:
response = ""
for move, prob in policy_moves:
probability = "{0:.5f}".format(prob)
response += self.board.point_to_string(
move) + " " + probability + " "
self.respond(response)
def generate_all_policy_moves(board, pattern, check_selfatari):
"""
generate a list of policy moves on board for board.current_player.
Use in UI only. For playing, use generate_move_with_filter
which is more efficient
"""
last_move = board.last_move
if last_move != None:
atari_capture_list = []
atari_capture_point = GoBoardUtil2.generate_atari_capture_move(
board, last_move)
if atari_capture_point != None:
atari_capture_list.append(atari_capture_point)
atari_capture_list = GoBoardUtil2.filter_moves(
board, atari_capture_list, check_selfatari)
if len(atari_capture_list) > 0:
return atari_capture_list, "AtariCapture"
atari_defense_moves = GoBoardUtil2.generate_all_atari_defense_moves(
board, last_move)
atari_defense_moves = GoBoardUtil2.filter_moves(
board, atari_defense_moves, check_selfatari)
if len(atari_defense_moves) > 0:
return atari_defense_moves, "AtariDefense"
return GoBoardUtil.generate_all_policy_moves(board, pattern,
check_selfatari)
def get_move(self, board, toplay):
# return GoBoardUtil.generate_move_with_filter(board, True, True)
policy_moves = GoBoardUtil.generate_all_policy_moves(
board, self.pattern, self.selfatari)
if len(policy_moves) == 0:
return None
moves, probs = zip(*policy_moves)
return np.random.choice(moves, p=probs)
def get_move(self, board, toplay):
# return GoBoardUtil.generate_move_with_filter(board, True, True)
policy_moves = GoBoardUtil.generate_all_policy_moves(
board, self.pattern, self.selfatari)
if len(policy_moves) == 0:
return None
move, _ = policy_moves[0]
return move
def genmove_cmd(self, args):
"""
generate a move for the specified color
Arguments
---------
args[0] : {'b','w'}
the color to generate a move for
it gets converted to Black --> 1 White --> 2
color : {0,1}
board_color : {'b','w'}
"""
try:
board_color = args[0].lower()
color = GoBoardUtil.color_to_int(board_color)
self.debug_msg("Board:\n{}\nko: {}\n".format(
str(self.board.get_twoD_board()), self.board.ko_constraint))
#move = self.go_engine.get_move(self.board, color)
policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.pattern, self.go_engine.selfatari,
color)
if len(policy_moves) == 0:
self.respond("Pass")
else:
#print(policy_moves)
move = policy_moves[randint(0, len(policy_moves) - 1)]
#print(move)
#move = GoBoardUtil.point_to_coord(move)
#move = GoBoardUtil.sorted_point_string(policy_moves[randint(0,len(policy_moves)-1)], self.board.NS)
#print(move)
#print(move)
#response = type_of_move + " " + GoBoardUtil.sorted_point_string(policy_moves, self.board.NS)
#self.respond(response)
if move is None:
self.respond("pass")
return
if not self.board.check_legal(move, color):
move = self.board._point_to_coord(move)
board_move = GoBoardUtil.format_point(move)
self.respond("Illegal move: {}".format(board_move))
raise RuntimeError("Illegal move given by engine")
# move is legal; play it
self.board.move(move, color)
self.debug_msg("Move: {}\nBoard: \n{}\n".format(
move, str(self.board.get_twoD_board())))
move = self.board._point_to_coord(move)
board_move = GoBoardUtil.format_point(move)
self.respond(board_move)
except Exception as e:
self.respond('Error: {}'.format(str(e)))
def policy_moves_cmd(self, args):
"""
Return list of policy moves for the current_player of the board
"""
policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.pattern, self.go_engine.selfatari)
if len(policy_moves) == 0:
self.respond("Pass")
else:
response = type_of_move + " " + GoBoardUtil.sorted_point_string(
policy_moves, self.board.NS)
self.respond(response)
def policy_moves_cmd(self, args):
if self.board.last_move is not None:
if self.atari_cap():
return
if self.atari_def():
return
policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.use_pattern,
self.go_engine.check_selfatari)
if len(policy_moves) == 0:
self.respond('Pass')
else:
response = type_of_move + ' ' + GoBoardUtil.sorted_point_string(
policy_moves, self.board.NS)
self.respond(response)
def get_move(self, board, toplay):
cboard = board.copy()
# emptyPoints = board.get_empty_points()
emptyPoints, _ = GoBoardUtil.generate_all_policy_moves(board, self.pattern, self.selfatari)
moves = []
for p in emptyPoints:
if not GoBoardUtil.filleye_filter(board, p, toplay):
moves.append(p)
if not moves: # pass move only, no need to simulate
return None
moves.append(None) # None for Pass
moveWins = []
for move in moves:
wins = self.simulateMove(board, cboard, move, toplay)
moveWins.append(wins)
writeMoves(board, moves, moveWins, self.num_simulation)
return select_best_move(board, moves, moveWins)
def policy_moves_cmd(self, args):
"""
Return list of policy moves for the current_player of the board
"""
policy_moves = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.pattern, self.go_engine.selfatari)
if len(policy_moves) == 0:
self.respond("pass 1.00000")
else:
response = ''
#for loop that generates the string for gtp via concatenation, list implementation
for i in range(0, len(policy_moves)):
str_float = "%0.5f" % float(policy_moves[i][1])
response = response + ' ' + str(
GoBoardUtil.sorted_point_string(
[policy_moves[i][0]], self.board.NS)) + ' ' + str_float
response = response.lstrip(" ")
self.respond(response)
def policy_moves_cmd(self, args):
"""
Return list of policy moves for the current_player of the board
"""
policy_moves = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.pattern, self.go_engine.selfatari)
# if len(policy_moves) == 0:
# self.respond("Pass")
# else:
# response = type_of_move + " " + GoBoardUtil.sorted_point_string(policy_moves, self.board.NS)
# self.respond(response)
# response = GoBoardUtil.sorted_point_string(policy_moves, self.board.NS)
if len(policy_moves) == 0:
response = ['pass', '{:.5f}'.format(1.0)]
else:
response = []
for k, v in policy_moves:
x, y = GoBoardUtil.point_to_coord(k, self.board.NS)
response.append(GoBoardUtil.format_point((x, y)))
response.append('{:.5f}'.format(v))
self.respond(' '.join(response))
def policy_moves_cmd(self, args):
"""
Return list of policy moves for the current_player of the board
"""
#ATARI CAPTURE
if self.board.last_move != None:
moves = self.last_moves_empty()
diagonal = self.board._diag_neighbors(self.board.last_move)
capture_moves = list(set(moves) - set(diagonal))
capture_moves = GoBoardUtil.filter_moves(
self.board, capture_moves, self.go_engine.check_selfatari)
if (len(capture_moves) == 1):
if (self.board._liberty(
capture_moves[0],
self.board._points_color(capture_moves[0])) == 1):
policy_moves, type_of_move = capture_moves, 'AtariCapture'
response = type_of_move + " " + GoBoardUtil.sorted_point_string(
policy_moves, self.board.NS)
self.respond(response)
# self.respond("akjhfjkasdhfkjahsd")
return
# # ATARI DEFENCE
# else:
# defence_moves=[]
# moves = self.board._neighbors(self.board.last_move)
# # moves.extend(board._diag_neighbors2(board.last_move))
# for move in moves:
# if(self.board._single_liberty(move,self.board.current_player)!=None):
# # print(self.board._single_liberty(move,self.board.current_player))
# # print(self.board._point_to_coord(move))
# defence_moves.append(self.board._single_liberty(move,self.board.current_player))
# if(defence_moves != []):
# defence_moves = GoBoardUtil.filter_moves(self.board, defence_moves, self.go_engine.check_selfatari)
# policy_moves, type_of_move = defence_moves, 'AtariDefense'
# response = type_of_move + " " + GoBoardUtil.sorted_point_string(policy_moves, self.board.NS)
# self.respond(response)
# return
defence_moves = []
lm = self.board.last_move
if lm != None:
current_play = self.board.current_player
opponent = GoBoardUtil.opponent(self.board.current_player)
for elem in self.board._neighbors(lm):
val = GoBoardUtil.color_to_int(self.board._points_color(elem))
if current_play == val:
# print(self.board._neighbors(elem))
# if self.board._neighbors(val) != None:
if (self.board._single_liberty(
elem, GoBoardUtil.int_to_color(val)) != None):
# val3 = GoBoardUtil.color_to_int(self.board._points_color(elem))
if self.board._liberty(
self.board._single_liberty(
elem, GoBoardUtil.int_to_color(val)),
current_play) > 1:
defence_moves.append(
self.board._single_liberty(
elem, GoBoardUtil.int_to_color(val)))
ng = self.board._neighbors(lm)
dg = self.board._diag_neighbors(self.board.last_move)
all_ng = ng + dg
# print(all_ng)
count = 0
for elem in all_ng:
val = GoBoardUtil.color_to_int(self.board._points_color(elem))
if opponent == val:
# print(self.board._single_liberty(elem, GoBoardUtil.int_to_color(val)))
if (self.board._single_liberty(
elem, GoBoardUtil.int_to_color(val)) != None):
# print(elem)
for i in self.board._neighbors(elem):
# print(i)
val2 = GoBoardUtil.color_to_int(
self.board._points_color(i))
if (val2 == opponent):
# print(self.board._liberty(i, GoBoardUtil.int_to_color(val2)))
if (self.board._liberty(
i, GoBoardUtil.int_to_color(val2)) !=
None):
count += 1
# print(count)
if (count == 0):
defence_moves.append(
self.board._single_liberty(
elem, GoBoardUtil.int_to_color(val)))
count = 0
# print(self.board.co defence_moves)
# for v in defence_moves:
# print(v)
defence_moves = GoBoardUtil.filter_moves(
self.board, defence_moves, self.go_engine.check_selfatari)
defence_moves = GoBoardUtil.sorted_point_string(
defence_moves, self.board.NS)
if len(defence_moves) > 0:
# defence_moves = GoBoardUtil.filter_moves(self.board,defence_moves, self.go_engine.check_selfatari)
self.respond("AtariDefense " + defence_moves)
return
policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves(
self.board, self.go_engine.use_pattern,
self.go_engine.check_selfatari)
if len(policy_moves) == 0:
self.respond("Pass")
else:
response = type_of_move + " " + GoBoardUtil.sorted_point_string(
policy_moves, self.board.NS)
self.respond(response)
return
