def genmove_cmd(self, args): try: color = GoBoardUtil.color_to_int(args[0].lower()) move = self.policy_moves_return_cmd(color) if move is None: self.respond("pass") return print(move) one_move = move[0] print(one_move) if not self.board.check_legal(one_move, color): one_move = self.board._point_to_coord(one_move) board_move = GoBoardUtil.format_point(one_move) self.respond("Illegal move: {}".format(board_move)) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(one_move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format( one_move, str(self.board.get_twoD_board()))) one_move = self.board._point_to_coord(one_move) board_move = GoBoardUtil.format_point(one_move) self.respond(board_move) except Exception as e: print(e) self.respond('Error: {}'.format(str(e)))
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) move = self.go_engine.get_move(self.board, color) 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 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)) self.current_player = color 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) # result = [] # for i in range(len(policy_moves)): # result1 = [] # result1.append(policy_moves[i]) # result.append(GoBoardUtil.sorted_point_string(result1, self.board.NS)) # print(len(result)) # if len(result) != 0: # row, col = GoBoardUtil.move_to_coord(random.choice(result), self.board.size) # move = self.board._coord_to_point(row, col) # print(policy_moves[0]) # row, col = GoBoardUtil.move_to_coord(policy_moves[0], self.board.size) # move = policy_moves[0] 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 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)) # Assignment4 - policy probabilistic player # ========================================= if color != self.board.current_player: self.respond("Opponent's turn") return move_prob_tuples = self.get_move_prob() if move_prob_tuples[0][0] == 'pass': self.respond("pass") self.go_engine.update('pass') self.board.move(None, color) return # based on # https://docs.python.org/3.5/library/random.html population = [val for val, cnt in move_prob_tuples for _ in range(int(cnt*1e5))] move = random.choice(population) move = GoBoardUtil.move_to_coord(move, self.board.size) move = self.board._coord_to_point(move[0], move[1]) # ========================================= 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)) traceback.print_exc(file=sys.stdout) self.respond('Error: {}'.format(str(e))) 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 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 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) # First try to solve the state and generate a best move to_play_bkp = self.board.to_play self.board.to_play = color score = self.board.call_search() if score == 1: # The player can win, make a move _, move = self.board.tree_cache[self.board] coord = GoBoardUtil.move_to_coord(move, self.board.size) point = self.board._coord_to_point(coord[0], coord[1]) self.board.move(point, color) self.respond(GoBoardUtil.format_point(coord)) return # Opponent can win or timeout, use the existing code to generate # a random move self.board.to_play = to_play_bkp move = self.go_engine.get_move(self.board, color) if move is None: # self.respond("pass") self.respond("resign") 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 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)) # Assignment4 - policy max player # ========================================= if color != self.board.current_player: self.respond("Opponent's turn") return move = self.get_move_prob()[0][0] if move == 'pass': self.respond("pass") self.go_engine.update('pass') self.board.move(None, color) return move = GoBoardUtil.move_to_coord(move, self.board.size) move = self.board._coord_to_point(move[0], move[1]) # ========================================= 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)) traceback.print_exc(file=sys.stdout) self.respond('Error: {}'.format(str(e))) 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 _point_to_move(self, point): if point == 'pass': return 'pass' elif point: coord = self.board._point_to_coord(point) return GoBoardUtil.format_point(coord) return None
def prior_knowledge_cmd(self, args): ''' ''' # get moves and probs for legal moves using function given in GoBoardUtilGo4, but with pass move moves, probs = GoBoardUtilGo4.generate_moves_with_feature_based_probs( self.board) priorKnowledgeList = GoBoardUtilGo4.prior_knowledge_initialization( moves, probs) color = self.board.current_player response = "" # convert moves from format 9 to a1 for move in priorKnowledgeList: # jank? need to print PASS as Pass if move[0] == 'PASS': move[0] = 'Pass' else: move[0] = GoBoardUtil.format_point( self.board._point_to_coord(move[0])) # sort by winrate, breaking ties alphabetically sortedList = sorted(priorKnowledgeList, key=lambda x: x[0]) sortedList = sorted(sortedList, key=lambda x: x[3], reverse=True) for move in sortedList: response += move[0] + ' ' + str(int( (round(move[1])))) + ' ' + str(int(round((move[2])))) + ' ' self.respond(response)
def solve(self, board, connection): self.startTime = time.process_time() self.timedOut = False winnable, best = self.negamax(board, board.current_player, 0, connection) if not winnable: return GoBoardUtil.int_to_color( GoBoardUtil.opponent(board.current_player)) if not best: best = GoBoardUtil.format_point(best) else: best = GoBoardUtil.format_point(board._point_to_coord(best)) # Unsure of how to deal with this if self.timedOut: return 'Unknown' return GoBoardUtil.int_to_color(board.current_player) + ' ' + best
def solve_cmd(self, args=None): colour = self.board.current_player can_win, move = self.solve(args) if self.timed_out: self.respond("unknown") else: if can_win: if move: formatted_move = GoBoardUtil.format_point( self.board._point_to_coord(move)) else: formatted_move = GoBoardUtil.format_point(move) self.respond( GoBoardUtil.int_to_color(colour) + ' ' + formatted_move) else: self.respond( GoBoardUtil.int_to_color(GoBoardUtil.opponent(colour)))
def genmove(self, args): #original code from util """ 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)) solver_color, solver_move = self.solve_genmove("1") move = self.go_engine.get_move(self.board, color) if move is None: self.respond("pass") return if (solver_color == self.color_convert(color)): moves = list( GoBoardUtil.move_to_coord(solver_move, self.board.size)) solver_move = self.board._coord_to_point(moves[0], moves[1]) move = solver_move elif 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 solve_cmd(self, args): try: winner, move = self.solve() if move: move = self.board._point_to_coord(move) move = GoBoardUtil.format_point(move) self.respond("{} {}".format(winner, move)) except Exception as e: self.respond("Error: {}".format(str(e)))
def format_list(board, sims_wins_list): for item in sims_wins_list: if item[0] == "PASS": item[0] = "Pass" else: row, col = board._point_to_coord(item[0]) move = GoBoardUtil.format_point((row, col)) item[0] = move sorted_list = sorted(sims_wins_list, key=lambda element: (-element[1], element[0])) return sorted_list
def safety_cmd(self, args): try: color = GoBoardUtil.color_to_int(args[0].lower()) safety_list = self.board.find_safety(color) safety_points = [] for point in safety_list: x, y = self.board._point_to_coord(point) safety_points.append(GoBoardUtil.format_point((x, y))) self.respond(safety_points) except Exception as e: self.respond('Error: {}'.format(str(e)))
def transform(self, T, coord): new = self.copy() for i in range(1, self.size + 1): for j in range(1, self.size + 1): # print('in:', i, j) y, x = T(i, j) # print('T ->', y, x) # print() new.board[new._coord_to_point( y, x)] = self.board[self._coord_to_point(i, j)] move = GoBoardUtil.format_point(T(coord[0], coord[1])) return new, move
def writeMoves(board, moves, count, numSimulations): gtp_moves = [] for i in range(len(moves)): if moves[i] != None: x, y = board._point_to_coord(moves[i]) gtp_moves.append((GoBoardUtil.format_point( (x, y)), float(count[i]) / float(numSimulations))) else: gtp_moves.append(('Pass', float(count[i]) / float(numSimulations))) sys.stderr.write("win rates: {}\n".format( sorted(gtp_moves, key=byPercentage, reverse=True))) sys.stderr.flush()
def solve_cmd(self, args): color, position = self.board.solve() # didn't finish if color == None: self.respond('\nunknown') # winner elif position != None: self.respond('\n' + str( GoBoardUtil.int_to_color(color) + ' ' + str( GoBoardUtil.format_point( self.board._point_to_coord(position))))) # loser else: self.respond('\n' + str(GoBoardUtil.int_to_color(color)))
def get_dict(board): p_dict = dict() legal_moves = [] color = board.current_player w = [] m = [] p = [] sims = [] winrate = [] wins = [] moves = board.get_empty_points() for move in moves: if board.check_legal(move, color) and not board.is_eye(move, color): legal_moves.append(move) legal_moves.append("PASS") for move in legal_moves: weight = get_the_prob(move, board) if move is not "PASS": i = board._point_to_coord(move) m.append(GoBoardUtil.format_point(i)) w.append(weight) else: m.append("Pass") w.append(weight) length = len(m) gamma_sum = sum(w) for i in range(length): p.append(w[i] / gamma_sum) h_prob = max(p) for i in range(length): sims.append(int(round((p[i] / h_prob) * 10))) winrate.append((((p[i] / h_prob) + 1) * 0.5)) wins.append(int(round(winrate[i] * ((p[i] / h_prob) * 10)))) results = sort_function(m, sims, winrate, wins) results = split_list(results) results = sorted(sorted(results, key=lambda x: x[0]), key=lambda x: x[3], reverse=True) for result in results: if result[0] is not "Pass": move = GoBoardUtil.move_to_coord(result[0], board.size) m = board._coord_to_point(move[0], move[1]) p_dict[m] = (int(result[1]), int(result[2])) else: p_dict["Pass"] = (int(result[1]), int(result[2])) return p_dict
def solve_cmd(self, args): self.move = [] self.start = time.process_time() self.time = False win = self.negamaxBoolean(0) if self.time: self.respond("unknown") return False elif win: self.respond( GoBoardUtil.int_to_color(self.board.current_player) + ' ' + GoBoardUtil.format_point( self.board._point_to_coord(self.move[0]))) return True else: self.respond( GoBoardUtil.int_to_color( GoBoardUtil.opponent(self.board.current_player)))
def prior_knowledge_cmd(self, args): legal_moves = [] color = self.board.current_player w = [] m = [] p = [] sims = [] winrate = [] wins = [] moves = self.board.get_empty_points() for move in moves: if self.board.check_legal( move, color) and not self.board.is_eye(move, color): legal_moves.append(move) legal_moves.append("PASS") for move in legal_moves: weight = self.get_the_prob(move) if move is not "PASS": i = self.board._point_to_coord(move) m.append(GoBoardUtil.format_point(i)) w.append(weight) else: m.append("Pass") w.append(weight) length = len(m) gamma_sum = sum(w) for i in range(length): p.append(w[i] / gamma_sum) h_prob = max(p) for i in range(length): sims.append(int(round((p[i] / h_prob) * 10))) winrate.append((((p[i] / h_prob) + 1) * 0.5)) wins.append(int(round(winrate[i] * ((p[i] / h_prob) * 10)))) results = self.sort_function(m, sims, winrate, wins) results = split_list(results) results = sorted(sorted(results, key=lambda x: x[0]), key=lambda x: x[3], reverse=True) response = '' for i in results: response = response + i[0] + ' ' + str(i[1]) + ' ' + str( i[2]) + ' ' self.respond(response)
def solve_cmd(self, args): """ Solves the current game state and returns the winner and the winning move. """ signal.signal(signal.SIGALRM, self.handler) signal.alarm(self.timelimit) try: winner, last_move, first_move = GoBoardUtil.solve(self.board) if self.board.to_play is winner: self.respond("{} {}".format(GoBoardUtil.int_to_color(winner), GoBoardUtil.format_point(self.board._point_to_coord(last_move)))) else: self.respond("{}".format(GoBoardUtil.int_to_color(winner))) except RuntimeError: self.respond("unknown") warnings.warn("Times Up") signal.alarm(0)
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 point_to_string(self, point): if point == None: return 'Pass' x, y = GoBoardUtil.point_to_coord(point, self.NS) return GoBoardUtil.format_point((x, y))
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)))
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) #move = GoBoardUtil.generate_move_with_filter(self.board, True, True) 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)))