def legal_moves_cmd(self, args):
"""
list legal moves for current player
"""
color = self.board.current_player
legal_moves = GoBoardUtil.generate_legal_moves(self.board, color)
self.respond(GoBoardUtil.sorted_point_string(legal_moves, self.board.NS))
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)
ans = self.solve(True)
if ans != None:
self.board.play_move(ans, color)
move_coord = point_to_coord(ans, self.board.size)
move_as_string = format_point(move_coord)
self.respond(move_as_string.lower())
return
else:
move = GoBoardUtil.generate_legal_moves(self.board, color)
if move == []:
self.respond("resign")
return
move_coord = point_to_coord(move[0], self.board.size)
move_as_string = format_point(move_coord)
self.board.play_move(move[0], color)
self.respond(move_as_string.lower())
def probabilitySimulation(board, WU):
"""
Given a WeightUtil object, randomly generates moves according
to the pattern-based probabilistic and returns the winning
color when the game is over. Recalculates all patterns after
every move, could be made more efficient by storing patterns
and weights and only recalculating patterns that neighbour
previous moves.
"""
timeout = len(board.get_empty_points())
for i in range(timeout):
color = board.current_player
moves = GoBoardUtil.generate_legal_moves(board, color)
if not moves:
return GoBoardUtil.opponent(color)
weights = []
for move in moves:
index = WU.getindex(board, move)
weight = WU.getweight(index)
weights.append(weight)
npWeights = np.array(weights)
# Normalize weights to sum to 1
npWeights = npWeights * (1. / npWeights.sum())
move = np.random.choice(moves, p=npWeights)
board.play_move(move, color)
print("Error: Played too many moves!")
def gogui_rules_legal_moves_cmd(self, args):
""" Implement this function for Assignment 1 """
moves = GoBoardUtil.generate_legal_moves(self.board,
self.board.current_player)
moves = map(lambda m: point_to_coord(m, self.board.size), moves)
moves = list(map(format_point, moves))
self.respond(' '.join(moves))
def negamax(self, board, color, depth, connection):
timeElapsed = time.process_time() - self.startTime
if timeElapsed > connection.timelimit:
self.timedOut = True
return False, None
if depth == self.max_depth:
winner, score = board.score(self.komi)
if winner == color:
return True, None
else:
return False, None
if board.end_of_game():
winner, score = board.score(self.komi)
if winner == color:
return True, None
else:
return False, None
moves = GoBoardUtil.generate_legal_moves(board,
color).strip().split(' ')
for _m in moves:
m = GoBoardUtil.move_to_coord(_m, board.size)
m = board._coord_to_point(m[0], m[1])
if board.is_eye(m, color):
continue
board.move(m, color)
value, _ = self.negamax(board, GoBoardUtil.opponent(color),
depth + 1, connection)
value = not value
board.undo_move()
if value:
return True, m
return False, None
def legal_moves_for_toPlay_cmd(self, args):
try:
color = self.board.current_player
moves = GoBoardUtil.generate_legal_moves(self.board, color)
self.respond(moves)
except Exception as e:
self.respond('Error: {}'.format(str(e)))
def getPatternMoveWeights(self, state, toPlay):
weights = {}
for move in GoBoardUtil.generate_legal_moves(state, toPlay):
weight = self.isPattern(state, move, toPlay)
weights[move] = weight
return weights
def get_random_move_prob(self, state, toPlay):
legal_moves = GoBoardUtil.generate_legal_moves(state, toPlay)
moves = []
for move in legal_moves:
moves.append(format_point(point_to_coord(move, self.board.size)))
prob = str(round(1 / len(legal_moves), 3))
moves.sort()
probs = [prob] * len(legal_moves)
return "" + " ".join(moves + probs)
def get_winner(self):
"""
Returns:
winner: color of winner, if the game is over, or None if not
"""
if len(GoBoardUtil.generate_legal_moves(self, self.to_play)) == 0:
return GoBoardUtil.opponent(self.to_play)
else:
return None
def gogui_rules_final_result_cmd(self, args):
""" Implement this function for Assignment 1 """
""" if legal moves are available to a player, then the game is not over """
if GoBoardUtil.generate_legal_moves(self.board,
self.board.current_player):
self.respond("unknown")
else:
winner = "black" if self.board.current_player == WHITE else "white"
self.respond(winner)
def gogui_rules_legal_moves_cmd(self, args):
""" Implement this function for Assignment 1 """
finalResult = self.return_string(args)
if finalResult != "unknown":
self.respond("")
return
color = color_to_int('b')
moves = GoBoardUtil.generate_legal_moves(self.board, color)
color = color_to_int('w')
moves2 = GoBoardUtil.generate_legal_moves(self.board, color)
moves += list(set(moves2) - set(moves))
gtp_moves = []
for move in moves:
coords = point_to_coord(move, self.board.size)
gtp_moves.append(format_point(coords))
sorted_moves = ' '.join(sorted(gtp_moves))
self.respond(sorted_moves)
def simulate(self, board, color):
current_player = board.current_player
moves = GoBoardUtil.generate_legal_moves(board, current_player)
if len(moves) == 0:
return 3 - current_player
move = np.random.choice(moves)
board.board[move] = current_player
board.current_player = 3 - current_player
return self.simulate(board, color)
def gogui_rules_legal_moves_cmd(self, args): #--------DONE----------------
""" Implement this function for Assignment 1
Produce a list of all legal moves for
the current player, in alphabetic order. """
colour = self.board.current_player
if colour == 1:
colour = 'b'
else:
colour = 'w'
#print("#############:", colour)
board_color = colour.lower()
color = color_to_int(board_color)
moves = GoBoardUtil.generate_legal_moves(self.board,
self.board.current_player)
gtp_moves = []
for move in moves:
# check if a PASS
if move == "PASS":
continue
coords = point_to_coord(move, self.board.size)
if self.board.board[move] != 0:
continue
board_copy = self.board.copy()
opp_color = GoBoardUtil.opponent(color)
board_copy.board[move] = color
capture = False
single_captures = []
neighbors = board_copy._neighbors(move)
No = False
for nb in neighbors:
if board_copy.board[nb] == opp_color:
single_capture = None
opp_block = board_copy._block_of(nb)
if not board_copy._has_liberty(opp_block):
captures = list(where1d(opp_block))
board_copy.board[captures] = 0
if len(captures) == 1:
single_capture = nb
if len(captures) >= 1:
No = True
break
if single_capture != None:
# use single captures to detect suicide
single_captures.append(single_capture)
if not No:
if single_captures != []:
continue
block = board_copy._block_of(move)
if not board_copy._has_liberty(block): # undo suicide move
continue
gtp_moves.append(format_point(coords))
# put it all in a list
sorted_moves = ' '.join(sorted(gtp_moves))
self.respond(sorted_moves)
def gogui_rules_final_result_cmd(self, args):
""" Implement this function for Assignment 1 """
moves = GoBoardUtil.generate_legal_moves(self.board, BLACK) # should be same regardless of player
if self.board.winner:
winner = "black" if self.board.winner == BLACK else "white"
self.respond(winner)
elif len(moves) == 0:
self.respond("draw")
else:
self.respond("unknown")
def get_move(self, board, color):
move = GoBoardUtil.generate_legal_moves(board, color)
moves = GoBoardUtil.gen1_move(board, color, move)
if moves != None:
rand = random.randint(0, len(moves) - 1)
return moves[rand]
return None
def gogui_rules_legal_moves_cmd(self, args):
""" Implement this function for Assignment 1 """
moves = GoBoardUtil.generate_legal_moves(self.board,
self.board.current_player)
gtp_moves = []
for move in moves:
coords = point_to_coord(move, self.board.size)
gtp_moves.append(format_point(coords))
sorted_moves = ' '.join(sorted(gtp_moves))
self.respond(sorted_moves)
def solve(self, return_val=False):
try:
self.hash = {}
current_depth = 0
color = self.board.current_player
moves = GoBoardUtil.generate_legal_moves(self.board, color)
tempboard = self.board.copy()
tempboard.current_player = 3 - color
signal.signal(signal.SIGALRM, self.handler)
signal.alarm(self._timelimit)
for move in moves:
tempboard.board[move] = color
# tempboard.play_move(move,color)
# if self.minimax(tempboard,color,current_depth+1) == color:
if not self.negamax(tempboard, 1):
signal.alarm(0)
move_coord = point_to_coord(move, tempboard.size)
move_as_string = format_point(move_coord)
if return_val == True:
return (move)
if self.board.current_player == 1:
self.respond("b " + move_as_string.lower())
else:
self.respond("w " + move_as_string.lower())
return None
tempboard.board[move] = EMPTY
signal.alarm(0)
if return_val == True:
return None
if self.board.current_player == 1:
self.respond("w")
else:
self.respond("b")
except TimeoutError:
self.respond("unknown")
signal.alarm(0)
return None
signal.alarm(0)
return None
def legal_moves_cmd(self, args):
#List legal moves for color args[0] in {'b','w'}
board_color = args[0].lower()
color = color_to_int(board_color)
moves = GoBoardUtil.generate_legal_moves(self.board, color)
gtp_moves = []
for move in moves:
coords = point_to_coord(move, self.board.size)
gtp_moves.append(format_point(coords))
sorted_moves = ' '.join(sorted(gtp_moves))
self.respond(sorted_moves)
def gogui_rules_final_result_cmd(self, args):
""" Implement this function for Assignment 1 """
if self.board.winner == 1:
self.respond("black")
elif self.board.winner == 2:
self.respond("white")
elif self.board.winner == None and len(
GoBoardUtil.generate_legal_moves(self.board, 1)) == 0:
self.respond("draw")
else:
self.respond("unknown")
def search(self):
'''
Negamax with early stop + lookup table
Return:
1 if the current player can win
0 timeout
-1 if the opponent can win
'''
# if time.time() > self.timeout:
if time.process_time() > self.timeout:
return 0
try:
# hit cache, no need to search remaining children
value, _ = self.tree_cache[self]
self.hit += 1
return value
except KeyError:
winner = self.get_winner()
# if winner == self.to_play:
# return 1
# if winner == GoBoardUtil.opponent(self.to_play):
# return -1
if winner == None:
legal_moves = GoBoardUtil.generate_legal_moves(
self, self.to_play).split()
if len(legal_moves) == 0:
return -1
for move in legal_moves:
coord = GoBoardUtil.move_to_coord(move, self.size)
point = self._coord_to_point(coord[0], coord[1])
self.move(point, self.to_play)
value = -self.search()
self.undo()
if value == 1:
# We know the max score is 1, so we can stop search.
# Save the current state with the best move to the
# lookup table.
self.save_states(self, value, move)
# We solved the main diagonal symmetry state
main_diag_symm = lambda y, x: (x, y)
symm, moveT = self.copy().transform(
main_diag_symm, coord)
# print(self.get_twoD_board())
# print(symm.get_twoD_board())
self.save_states(symm, value, moveT)
return value
if value == 0:
return 0
return value
else:
return -1
def legal_moves_for_toPlay_cmd(self, args):
try:
color = self.board.current_player
moves = GoBoardUtil.generate_legal_moves(self.board, color)
gtp_moves = []
for move in moves:
coords = point_to_coord(move, self.board.size)
gtp_moves.append(format_point(coords))
sorted_moves = ' '.join(sorted(gtp_moves))
self.respond(sorted_moves)
except Exception as e:
self.respond('Error: {}'.format(str(e)))
def negamax(node, color, time, delta):
if int(time.time() - time) > delta:
return node.score
children = GoBoardUtil.generate_legal_moves(
node.state, GoBoardUtil.color_to_int(color))
for child in children:
nodecopy = copy.deepcopy(node)
nodecopy.move(color + child)
if color == "b":
v = negamax(nodecopy, "w", time, delta)
else:
v = negamax(nodecopy, "b", time, delta)
def search_alphabeta(self, alpha, beta):
'''
Negamax alpha-beta search + lookup table
Return:
1 if the current player can win
0 timeout
-1 if the opponent can win
'''
# if time.time() > self.timeout:
if time.process_time() > self.timeout:
return 0
# print(self.get_twoD_board())
try:
# hit cache, no need to search remaining children
value, _ = self.tree_cache[self]
self.hit += 1
return value
except KeyError:
winner = self.get_winner()
if winner == self.to_play:
return 1
elif winner == GoBoardUtil.opponent(self.to_play):
return -1
else:
legal_moves = GoBoardUtil.generate_legal_moves(
self, self.to_play).split()
if len(legal_moves) == 0:
return -1
for move in legal_moves:
coord = GoBoardUtil.move_to_coord(move, self.size)
point = self._coord_to_point(coord[0], coord[1])
self.move(point, self.to_play)
value = -self.search_alphabeta(-beta, -alpha)
self.undo()
if value > alpha:
alpha = value
# Save the current state with the best move to the
# lookup table.
self.save_states(self, value, move)
# We solved the main diagonal symmetry state
main_diag_symm = lambda y, x: (x, y)
symm, moveT = self.copy().transform(
main_diag_symm, coord)
# print(self.get_twoD_board())
# print(symm.get_twoD_board())
self.save_states(symm, value, moveT)
if value >= beta:
return beta
return alpha
def test_size_2_legal_moves(self):
size = 2
goboard = GoBoard(size)
moves = GoBoardUtil.generate_legal_moves(goboard, BLACK)
self.assertEqual(
moves,
[
goboard.pt(1, 1),
goboard.pt(1, 2),
goboard.pt(2, 1),
goboard.pt(2, 2)
],
)
def startSimulation(self, board, board_color, policy="random"):
self.board = board
color = self.color_to_int(board_color)
legalMoves = GoBoardUtil.generate_legal_moves(self.board, color)
numLegalMoves = len(legalMoves)
scores = {}
for i in range(len(legalMoves)):
move = legalMoves[i]
scores[i] = self.simulate(move, color, policy)
print(scores)
bestMove = max(scores, key=scores.get)
print(bestMove)
return bestMove
def gogui_rules_final_result_cmd(self, args):
""" Implement this function for Assignment 1 """
color = self.board.check_win()
if color == BLACK:
self.respond("black")
elif color == WHITE:
self.respond("white")
else:
moves = GoBoardUtil.generate_legal_moves(self.board, self.board.current_player)
if not moves:
self.respond("draw")
else:
self.respond("unknown")
def simulate_rule_based(self, board, color):
#####Fill in here#####
if len(GoBoardUtil.generate_legal_moves(board, color)) == 0:
return 'PASS'
temp_board = board.copy()
rule, move = GoBoardUtil.generate_rule_move_gomoku(temp_board, color)
if rule != "Random":
np.random.shuffle(move)
return rule, move[0]
# return move
else:
move = self.simulate_random(board, color)
return "Random", move
def gogui_rules_legal_moves_cmd(self, args):
""" Implement this function for Assignment 1 """
#board_color = args[0].lower()
#color = color_to_int(board_color)
color = 1 if self.board.current_player == BLACK else 2
moves = GoBoardUtil.generate_legal_moves(self.board, color)
gtp_moves = []
for move in moves:
coords = point_to_coord(move, self.board.size)
gtp_moves.append(format_point(coords))
sorted_moves = ' '.join(sorted(gtp_moves))
self.respond(sorted_moves)
return
def random_policy(self, args):
#for printing all moves in policy moves
color = args
moves = GoBoardUtil.generate_legal_moves(self.board, color)
np.random.shuffle(moves)
gtp_moves = []
for move in moves:
coords = point_to_coord(move, self.board.size)
gtp_moves.append(format_point(coords))
sorted_moves = ' '.join(sorted(gtp_moves))
if moves:
self.respond("Random " + sorted_moves)
else:
self.respond()
def negamax(self, pnode, color, curtime, delta):
if int(time.time() - curtime) > delta:
#If the timelimit is passed, just return the heuristic value of the move
return pnode.state.score(self.go_engine.komi)
#Generate all of the children of the current node
children = GoBoardUtil.generate_legal_moves(
pnode.state, GoBoardUtil.color_to_int(color))
#Which value is the best? I dunno?
best = float("-inf")
#Children list comes out as a string for some reason.
children = children.split(" ")
children.append('')
#Go through the children
movew = ''
for child in children:
#If the time is expired, return the score and the child
nodecopy = node(pnode.state.copy())
if child == '':
child = None
val = nodecopy.state.move(child,
GoBoardUtil.color_to_int(color))
else:
coord = GoBoardUtil.move_to_coord(child, self.board.size)
point = self.board._coord_to_point(coord[0], coord[1])
val = nodecopy.state.move(point,
GoBoardUtil.color_to_int(color))
if nodecopy.state.end_of_game():
return pnode.state.score(self.go_engine.komi)
if color == "b":
moved, score = self.negamax(nodecopy, "w", curtime, delta)
else:
moved, score = self.negamax(nodecopy, "b", curtime, delta)
#best = max(best, score)
if (best < -score):
best = -score
movew = moved
if int(time.time() - curtime) > delta:
# return movew, best
return pnode.state.score(self.go_engine.komi)
#print("returning")
print("movew", movew)
return best, movew
