def return_moves(self):
self.time = False
win = self.negamaxBoolean(0)
if self.time:
return GoBoardUtil.generate_random_move(self.board,
self.board.current_player,
True)
elif win:
self.board.move(self.move[0], self.board.current_player)
else:
return GoBoardUtil.generate_random_move(self.board,
self.board.current_player,
True)
def simulate(self, move, color, policy='random'):
stats = {'black': 0, 'white': 0, 'draw': 0}
movesMade = []
#Append move which will start the simulation
self.board.play_move(move, color)
color = GoBoardUtil.opponent(color)
movesMade.append(move)
for i in range(self.numSimulations):
while self.board.get_result(color, move, 5) == 'unknown':
if policy == 'random':
move = GoBoardUtil.generate_random_move(self.board, color)
elif policy == 'rule':
move = self.rule_move(color)
self.board.play_move(move, color)
color = GoBoardUtil.opponent(color)
movesMade.append(move)
stats[self.board.get_result(color, move, 5)] += 1
for moveMade in movesMade:
self.board.undo_move(moveMade)
movesMade = []
if self.board.current_player == BLACK:
eval = ((stats['black'] + (0.5 * stats['draw'])) /
self.numSimulations)
elif self.board.current_player == WHITE:
eval = ((stats['white'] + (0.5 * stats['draw'])) /
self.numSimulations)
return eval
def simulate(self, node, board_copy):
if len(board_copy.get_empty_points()) == 0:
node.set_winner(DRAW)
return NUM_SIMS / 2
initial_winner = board_copy.check_win(node.move)
if initial_winner != EMPTY:
node.set_winner(initial_winner)
return NUM_SIMS
wins = 0
for i in range(NUM_SIMS):
moves_played = []
winner = EMPTY
while winner == EMPTY and len(board_copy.get_empty_points()) > 0:
next_move = GoBoardUtil.generate_random_move(
board_copy, board_copy.current_player)
board_copy.play_move(next_move, board_copy.current_player)
moves_played.append(next_move)
last_move = next_move
winner = board_copy.check_win(last_move)
for move in moves_played:
board_copy.undo_move(move)
if winner == node.color:
wins += 1
elif winner == EMPTY:
wins += 0.5
return wins
def get_move(self, board, color, timelimit, tt, zobrist):
result, move = self.solve(board, timelimit, tt, zobrist)
if move is not None:
return move
else:
return GoBoardUtil.generate_random_move(board, color)
def playGame(board, color, **kwargs):
"""
modified to use custom policy
"""
komi = kwargs.pop('komi', 0)
limit = kwargs.pop('limit', 1000)
random_simulation = kwargs.pop('random_simulation', True)
use_pattern = kwargs.pop('use_pattern', True)
check_selfatari = kwargs.pop('check_selfatari', True)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
for _ in range(limit):
if random_simulation:
move = GoBoardUtil.generate_random_move(board, color, True)
else:
#this uses custom move policy for simulation now
moves, _ = Gm.generate_moves(board, use_pattern,
check_selfatari)
move = GoBoardUtil.filter_moves_and_generate(
board, moves, check_selfatari)
isLegalMove = board.move(move, color)
assert isLegalMove
if board.end_of_game():
break
color = GoBoardUtil.opponent(color)
winner, _ = board.score(komi)
return winner
def playGame(board, color, **kwargs):
"""
Run a simulation game according to give parameters.
"""
komi = kwargs.pop('komi', 0)
limit = kwargs.pop('limit', 1000)
simulation_policy = kwargs.pop('random_simulation','rulebased')
use_pattern = kwargs.pop('use_pattern',True)
#check_selfatari = kwargs.pop('check_selfatari',True)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
nuPasses = 0
for _ in range(limit):
color = board.current_player
if simulation_policy == 'random':
move = GoBoardUtil.generate_random_move(board,color,True)
elif simulation_policy == 'rulebased':
move = PatternUtil.generate_move_with_filter(board,use_pattern,False)
else:
assert simulation_policy == 'prob'
move = PatternUtil.generate_move_with_feature_based_probs(board)
if move == PASS:
break
board.play_move(move, color)
winner = GoBoardUtil.opponent(color)
return winner
def generate_move_with_filter(board, use_pattern, check_selfatari):
"""
Arguments
---------
check_selfatari: filter selfatari moves?
Note that even if True, this filter only applies to pattern moves
use_pattern: Use pattern policy?
"""
if board.last_move != None:
# AtariCapture move
atari_capture_move = GoBoardUtil_Go3.generate_atari_capture_move(board)
if atari_capture_move:
return atari_capture_move
# AtariDefense move
atari_defense_moves = GoBoardUtil_Go3.generate_atari_defense_moves(board)
if len(atari_defense_moves) > 0:
return random.choice(atari_defense_moves)
if use_pattern:
moves = GoBoardUtil.generate_pattern_moves(board)
move = GoBoardUtil.filter_moves_and_generate(board, moves,
check_selfatari)
if move:
return move
return GoBoardUtil.generate_random_move(board, board.current_player,True)
def generate_move_with_filter(board, use_pattern):
"""
Arguments
---------
check_selfatari: filter selfatari moves?
Note that even if True, this filter only applies to pattern moves
use_pattern: Use pattern policy?
"""
move = None
if use_pattern:
moves,values = PatternUtil.generate_pattern_moves(board)
new_values = PatternUtil.normalize_val(values)
x = random.uniform(0,1)
cumulative_probability = 0.0
i = 0
while i < len(moves):
cumulative_probability += new_values[i]
if x < cumulative_probability:
break
i += 1
if i < len(moves):
move = moves[i]
#move = PatternUtil.filter_moves_and_generate(board, moves, check_selfatari)
if move == None:
move = GoBoardUtil.generate_random_move(board, board.current_player,False)
return move
def getBestMove(self, state, toPlay):
weightDict = self.getPatternMoveWeights(state, toPlay)
# Generate a random move if we have no pattern matches
if (len(weightDict) == 0):
return GoBoardUtil.generate_random_move(state, toPlay, True)
weightSum = 0
probabilities = {}
for weight in weightDict:
weightSum += weightDict.get(weight)
# Calculate the probability of each move
prev = 0
for weight in weightDict:
probabilities[weight] = (weightDict.get(weight) / weightSum) + prev
prev = probabilities.get(weight)
#print("probabilities: ", probabilities)
uniform = random.uniform(0, 1)
for move in probabilities:
if (uniform <= probabilities.get(move)):
return move
def playGame(board, color, **kwargs):
"""
Run a simulation game according to give parameters.
"""
komi = kwargs.pop('komi', 0)
limit = kwargs.pop('limit', 1000)
random_simulation = kwargs.pop('random_simulation',True)
use_pattern = kwargs.pop('use_pattern',True)
check_selfatari = kwargs.pop('check_selfatari',True)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
nuPasses = 0
for _ in range(limit):
color = board.current_player
if random_simulation:
move = GoBoardUtil.generate_random_move(board,color,True)
else:
move = PatternUtil.generate_move_with_filter(board,use_pattern,check_selfatari)
board.play_move(move, color)
if move == PASS:
nuPasses += 1
else:
nuPasses = 0
if nuPasses >= 2:
break
print('limit:', limit, 'random:', random_simulation,'\nuse_pattern:', use_pattern, 'check_selfatari:', check_selfatari, 'nuPasses:', nuPasses)
winner,_ = board.score(komi)
return winner
def get_move(self, board, color, timelimit, tTable, hasher):
outcome, move = self.solve(board, timelimit, tTable, hasher)
if move is not None:
return move
else:
return GoBoardUtil.generate_random_move(board, color)
def playGame(board, color, **kwargs):
"""
Run a simulation game according to give parameters.
"""
komi = kwargs.pop('komi', 0)
limit = kwargs.pop('limit', 1000)
random_simulation = kwargs.pop('random_simulation', True)
use_pattern = kwargs.pop('use_pattern', True)
check_selfatari = kwargs.pop('check_selfatari', True) # always false
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
nuPasses = 0
for _ in range(limit):
color = board.current_player
if random_simulation:
move = GoBoardUtil.generate_random_move(board, color, True)
else:
move = PatternUtil.generate_move_with_filter(
board, use_pattern, check_selfatari)
board.play_move(move, color)
if move == PASS:
nuPasses += 1
else:
nuPasses = 0
if nuPasses >= 2:
break
winner = board.get_final_result() # gogui-final-result.
return winner
def play_game(self, board, color):
num_pass = 0
while board.detect_five_in_a_row() == board_util.EMPTY or len(
board.get_empty_points()) >= 1:
color = board.current_player
move = GoBoardUtil.generate_random_move(board, color)
board.play_move(move, color)
return board.detect_five_in_a_row()
def uniform_random_simulation(self, move, color):
board_copy = self.board.copy()
board_copy.play_move(move, color)
while board_copy.detect_five_in_a_row() == board_util.EMPTY or len(board_copy.get_empty_points()) >= 1:
color = board_copy
move = GoBoardUtil.generate_random_move(board_copy, color)
board_copy.play_move(move, color)
if self.board.detect_five_in_a_row() == color:
return True
return False
def get_move(self, board, color, timelimit=1):
board_copy = board.copy()
board_copy.to_play = color
winner, last_move, first_move = GoBoardUtil.solve(board, timelimit)
print(winner, color)
if winner is color:
return first_move
else:
return GoBoardUtil.generate_random_move(board, color)
def sim_for_one(self, board, color):
result = board.detect_five_in_a_row()
if result == color:
return 1
elif result == GoBoardUtil.opponent(color):
return -1
moves = GoBoardUtil.generate_random_move(board, board.current_player)
if moves == None:
return 0
board.play_move(move, board.current_player)
return self.sim_for_one(board, color)
def randomSimulation(board):
"""
Randomly generates moves and returns the winning color
when the game is over.
"""
timeout = len(board.get_empty_points())
for i in range(timeout):
color = board.current_player
move = GoBoardUtil.generate_random_move(board, color, False)
if move == PASS:
return GoBoardUtil.opponent(color)
board.play_move(move, color)
print("Error: Played too many moves!)")
def gogui_rules_final_result_cmd(self, args):
""" Imlement 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
move = GoBoardUtil.generate_random_move(self.board, color, False)
if move == PASS:
if color == BLACK:
self.respond("white")
return
else:
self.respond("black")
return
self.respond("unknown")
def generate_move_with_filter(board, use_pattern, check_selfatari):
"""
Arguments
---------
check_selfatari: filter selfatari moves?
Note that even if True, this filter only applies to pattern moves
use_pattern: Use pattern policy?
"""
move = None
if use_pattern:
moves = PatternUtil.generate_pattern_moves(board)
move = PatternUtil.filter_moves_and_generate(board, moves,
check_selfatari)
if move == None:
move = GoBoardUtil.generate_random_move(board, board.current_player,True)
return move
def simulate(self, board, toplay):
"""
Run a simulated game for a given starting move.
"""
res = game_result(board)
simulation_moves = []
while (res is None):
move = GoBoardUtil.generate_random_move(board,
board.current_player)
play_move(board, move, board.current_player)
simulation_moves.append(move)
res = game_result(board)
for m in simulation_moves[::-1]:
undo(board, m)
result = 1.0 if res == toplay else 0.0
return result
def generate_move(board, use_pattern, table):
"""
Arguments
---------
board: GoBoard
use_pattern: Use pattern policy?
"""
move = None
if use_pattern:
moves = PatternUtil.generate_pattern_moves(board, table)
mvs, vals = PatternUtil.calc_probabilities(board, moves)
move = np.random.choice(mvs, len(mvs), vals)
if move == None:
move = GoBoardUtil.generate_random_move(board,
board.current_player, True)
return move
def playGame(board, color, **kwargs):
komi = kwargs.pop('komi', 0)
limit = kwargs.pop('limit', 1000)
random_simulation = kwargs.pop('random_simulation',True)
use_pattern = kwargs.pop('use_pattern',True)
check_selfatari = kwargs.pop('check_selfatari',True)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
for _ in range(limit):
if random_simulation:
move = GoBoardUtil.generate_random_move(board,color,True)
else:
move = GoBoardUtil_Go3.generate_move_with_filter(board,use_pattern,check_selfatari)
isLegalMove = board.move(move,color)
assert isLegalMove
if board.end_of_game():
break
color = GoBoardUtil.opponent(color)
winner,_ = board.score(komi)
return winner
def run_sim(self, board, move, random, N):
cboard = board.copy()
cboard.play_move(move, cboard.current_player)
# Play through the rest of a game until it's over
for _ in range(1000):
color = cboard.current_player
# uniform random
if random:
move = GoBoardUtil.generate_random_move(cboard, color, False)
# pattern
else:
# Select a random pattern move based on its probability
move = self.getBestMove(cboard, color)
cboard.play_move(move, color)
if move == PASS:
break
winner = GoBoardUtil.opponent(color)
return winner
def playGame(board, color, **kwargs):
"""
Run a simulation game according to give parameters.
"""
limit = kwargs.pop('limit', 1000)
random_simulation = kwargs.pop('random_simulation', True)
use_pattern = kwargs.pop('use_pattern', True)
table = kwargs.pop('table', True)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
for _ in range(limit):
color = board.current_player
if random_simulation:
move = GoBoardUtil.generate_random_move(board, color, False)
else:
move = PatternUtil.generate_move(board, use_pattern, table)
if move == PASS:
break
board.play_move(move, color)
winner = GoBoardUtil.opponent(color)
return winner
def playGame(board, color, **kwargs):
"""
Run a simulation game according to give parameters.
"""
komi = kwargs.pop('komi', 0)
limit = kwargs.pop('limit', 1000)
random_simulation = kwargs.pop('random_simulation', True)
use_pattern = kwargs.pop('use_pattern', True)
check_selfatari = kwargs.pop('check_selfatari', True)
if kwargs:
raise TypeError('Unexpected **kwargs: %r' % kwargs)
nuPasses = 0
for _ in range(limit):
color = board.current_player
if random_simulation:
move = GoBoardUtil.generate_random_move(board, color, False)
else:
move = PatternUtil.generate_move_with_filter(
board, use_pattern, check_selfatari)
if move == PASS:
return GoBoardUtil.opponent(color)
board.play_move(move, color)
return board.current_player
def playGame(self, board, color):
"""
Run a simulation game.
"""
moveType = None
moveList = None
if not self.random_simulation:
moveList = getOneWinning(board, color)
if len(moveList) == 0:
moveType = "Win"
moveList = getBlockWin(board, color)
if len(moveList) == 0:
moveType = "OpenFour"
moveList = getOpenFour(board, color)
if len(moveList) == 0:
moveType = "BlockOpenFour"
moveList = getBlockOpenFour(board, color)
if len(moveList) == 0:
moveType = "Random"
moveList = getRandom(board, color)
numPasses = 0
for _ in range(self.limit):
color = board.current_player
move = GoBoardUtil.generate_random_move(board, color)
board.play_move(move, color)
if move == PASS:
numPasses += 1
else:
numPasses = 0
if numPasses >= 2:
break
return winner(board, self.komi)
return [moveType, moveList]
def get_move(self, board, color):
return GoBoardUtil.generate_random_move(board, color, False)
def get_move(self, board, color):
print("get random move")
return GoBoardUtil.generate_random_move(board, color)
def get_move(self, board, color):
return GoBoardUtil.generate_random_move(board,
color,
use_eye_filter=False)
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:
self.notdone = False
board_color = args[0].lower()
color = GoBoardUtil.color_to_int(board_color)
#TODO
if self.board.get_winner() != None:
self.respond("resign")
return
self.winMoves = []
self.genCall = True
if args[0] != None:
if args[0] == 'b':
self.board.to_play = BLACK
else:
self.board.to_play = WHITE
self.solve_cmd(args)
self.genCall = False
if len(self.winMoves) != 0:
row, col = GoBoardUtil.move_to_coord(self.winMoves[0],
self.board.size)
move = self.board._coord_to_point(row, col)
#self.respond(self.winMoves[0])
else:
move = GoBoardUtil.generate_random_move(self.board, color)
move = self.board._point_to_coord(move)
move = GoBoardUtil.format_point(move)
row, col = GoBoardUtil.move_to_coord(move, self.board.size)
move = self.board._coord_to_point(row, col)
#self.respond(move)
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)))
