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)))