def evaluate_board(board: SimpleGoBoard): init_score_cache(board) # current_player = board.current_player # opponent_player = GoBoardUtil.opponent(current_player) for row in range(1, board.size + 1): for col in range(1, board.size + 1): p = _constrained_index_2d(board, row, col) m = coord_to_point(row, col, board.size) if p == EMPTY: board.board[m] = WHITE score_color[WHITE][row][col] = evaluate_point_dir( board, row, col, WHITE, None) board.board[m] = BLACK score_color[BLACK][row][col] = evaluate_point_dir( board, row, col, BLACK, None) board.board[m] = EMPTY elif p == WHITE: score_color[WHITE][row][col] = evaluate_point_dir( board, row, col, WHITE, None) score_color[BLACK][row][col] = 0 elif p == BLACK: score_color[WHITE][row][col] = 0 score_color[BLACK][row][col] = evaluate_point_dir( board, row, col, BLACK, None) return
def test_size_2(self): goboard = SimpleGoBoard(2) self.assertEqual(goboard.size, 2) self.assertEqual(goboard.NS, 3) self.assertEqual(goboard.WE, 1) self.assertEqual(goboard.ko_recapture, None) self.assertEqual(goboard.current_player, BLACK) self.assertEqual(goboard.maxpoint, 13) self.assertEqual(goboard.board[0], BORDER) self.assertEqual(goboard.board[goboard.pt(1,1)], EMPTY) self.assertEqual(goboard.board[goboard.pt(1,2)], EMPTY) self.assertEqual(goboard.board[goboard.pt(2,1)], EMPTY) self.assertEqual(goboard.board[goboard.pt(2,2)], EMPTY)
def run(sim, move_select, sim_rule, move_filter): """ start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnection(Nogo(sim, move_select, sim_rule, move_filter), board) con.start_connection()
def genmove(self, board): result, winner = board.check_game_end_gomoku(self) assert not result simulate_moves = board.get_empty_point() simulate_moves_num = len(simulate_moves) score = [0] * simulate_moves_num for i in range(simulate_moves_num): move = simulate_moves[i] score[i] = self.mc_simulate(board, move) best_move_index = score.index(max(score)) best_move = simulate_moves[best_move_index] assert best_move in simulate_moves return best_move
def run(): """ start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnection(Go0(), board) con.start_connection()
def run(sim, selection): """ Start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnection(Nogo(sim, selection), board) con.start_connection()
def run(sim, sim_rule, move_filter, in_tree_knowledge): """ Start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnectionGo3(Go5(num_sim, sim_rule, move_filter, in_tree_knowledge), board) con.start_connection()
def run(): """ start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnection2(Go3Player(num_simulation), board) con.start_connection()
def run(sim_rule, move_filter): """ Start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnectionGo3(PolicyPlayer(sim_rule, move_filter), board) con.start_connection()
def run(): """ start the gtp connection and wait for commands """ board = SimpleGoBoard(7) con = GtpConnection(Gomoku3(sim=10, sim_rule="rule_based"), board) con.start_connection()
def run(): """ start the gtp connection and wait for commands. """ board = SimpleGoBoard(7) con = GtpConnection(GomokuMCTSPlayer(n_playout=4000), board) con.start_connection()
def run(): """ start the gtp connection and wait for commands. """ #random.seed() no need to seed because we use np.random board = SimpleGoBoard(7) con = GtpConnection(Gomoku(), board) con.start_connection()
def do_test_pointsets(self, size): goboard = SimpleGoBoard(size) count = count_colors(goboard) self.assertEqual(count[EMPTY], size * size) self.assertEqual(count[BLACK], 0) self.assertEqual(count[WHITE], 0) num_border = 3 * (size + 1) self.assertEqual(count[BORDER], num_border)
def update_dir(board: SimpleGoBoard, row, col, direction): current = _constrained_index_2d(board, row, col) m = coord_to_point(row, col, board.size) if current == EMPTY: board.board[m] = WHITE score_color[WHITE][row][col] = evaluate_point_dir( board, row, col, WHITE, direction) board.board[m] = BLACK score_color[BLACK][row][col] = evaluate_point_dir( board, row, col, BLACK, direction) board.board[m] = EMPTY elif current == BLACK or current == WHITE: oppponent = GoBoardUtil.opponent(current) score_color[current][row][col] = evaluate_point_dir( board, row, col, current, direction) score_color[oppponent][row][col] = 0 return
def run(num_sim, sim_rule, in_tree_knowledge): #-------------------------- use_pattern = None #-------------------------- board = SimpleGoBoard(7) con = GtpConnection( Gomoku5(num_sim, use_pattern, sim_rule, in_tree_knowledge), board) con.start_connection()
def solve_alphabeta(board: SimpleGoBoard, color: int, board_is_evaluated=False): result, winner = board.check_game_end_gomoku() if result: if winner == color: return 10*score.FIVE, None else: return -10*score.FIVE, None # print('ok') alpha, beta = -10*score.FIVE, 10*score.FIVE if not board_is_evaluated: evaluate_board(board) moves = gen_possible_moves(board, color) print(list(map(lambda t: (t[0], gtp_connection.format_point( gtp_connection.point_to_coord(t[0], board.size)), t[1], t[2]), moves))) if len(moves) == 0: return 0, None if (gtp_connection.total_steps == 0 or gtp_connection.total_steps == 1) and board.board[36] == EMPTY: return 1, 36 # best_move = None global best_move best_move = PASS for m in moves: move = m[0] # move_coord = gtp_connection.point_to_coord(move, board.size) # move_as_string = gtp_connection.format_point(move_coord) board.board[move] = color update_board(board, move) result = -alphabeta_search(board, move, GoBoardUtil.opponent(color), 40, -beta, -alpha) # print("trying move:", move_as_string, "score:", result) board.board[move] = EMPTY update_board(board, move) if result > alpha: alpha = result best_move = move if result >= beta: return beta, move return alpha, best_move
def mc_simulate(self, board, move): stats = [0] * 3 board.play(move) moveNr = board.moveNumber() for _ in range(self.numSim): winner = board.simulate() stats[winner] += 1 board.resetToMoveNumber(moveNr) assert sum(stats) == self.numSim board.undo_move() eval = (stats[BLACK] + 0.5 * stats[EMPTY]) / self.numSim if board.current_player == WHITE: eval = 1 - eval return eval
def boolean_negamax(board: SimpleGoBoard, last_move: int, current_color: int) -> ('result', 'move'): if debug: print_board(board) if last_move is None: evaluate_board(board) if last_move is not None and check_winning_condition(board, last_move, board.board[last_move]): # print('game ends') return -1, None opponent_color = GoBoardUtil.opponent(current_color) moves = gen_possible_moves(board, current_color) if len(moves) == 0: return 0, None best_result = -1 best_move = moves[0][0] if debug: print_moves(moves, board.size) for m in moves: move = m[0] board.board[move] = current_color update_board(board, move) # print('play', gtp_connection.point_to_str(move, board.size)) result, _ = boolean_negamax(board, move, opponent_color) result = -result board.board[move] = EMPTY update_board(board, move) if result > 0: # print("win") return 1, move if result > best_result: best_result = result best_move = move return best_result, best_move
def alphabeta_search( board: SimpleGoBoard, last_move: int, current_color: int, depth: int, alpha: int, beta: int) -> int: # if last_move is None: # evaluate_board(board) # last_move is not None if check_winning_condition(board, last_move, board.board[last_move]): return -10 * score.FIVE if depth <= 0: return point_estimation(board, current_color) opponent_color = GoBoardUtil.opponent(current_color) moves = gen_possible_moves(board, current_color) if len(moves) == 0: return 0 depth -= min(10, len(moves)) if debug: print_moves(moves, board.size) for m in moves: move = m[0] board.board[move] = current_color update_board(board, move) result = -alphabeta_search(board, move, opponent_color, depth, -beta, -alpha) board.board[move] = EMPTY update_board(board, move) if result > alpha: alpha = result if result >= beta: return beta return alpha
def test_size_2_play_move(self): size = 2 goboard = SimpleGoBoard(size) goboard.play_move(goboard.pt(1,1), BLACK) count = count_colors(goboard) self.assertEqual(count, [size * size - 1, 1, 0, 3 * (size + 1)])
def playgame(): board = SimpleGoBoard(7)
def gen_possible_moves(board: SimpleGoBoard, color): fives = [] fours = {BLACK: [], WHITE: []} blocked_fours = {BLACK: [], WHITE: []} two_threes = {BLACK: [], WHITE: []} threes = {BLACK: [], WHITE: []} twos = {BLACK: [], WHITE: []} others = [] current = color opponent = GoBoardUtil.opponent(current) empty_points = board.get_empty_points() for point in empty_points: row, col = point_to_coord(point, board.size) current_score = score_color[current][row][col] opponent_score = score_color[opponent][row][col] move = coord_to_point(row, col, board.size) # always consider current side, then the opposite side if current_score >= score.FIVE: fives.append((move, current_score, opponent_score)) elif opponent_score >= score.FIVE: fives.append((move, current_score, opponent_score)) elif current_score >= score.FOUR: fours[current].append((move, current_score, opponent_score)) elif opponent_score >= score.FOUR: fours[opponent].append((move, current_score, opponent_score)) elif current_score >= score.BLOCKED_FOUR: blocked_fours[current].append( (move, current_score, opponent_score)) elif opponent_score >= score.BLOCKED_FOUR: blocked_fours[opponent].append( (move, current_score, opponent_score)) elif current_score >= 2 * score.THREE: two_threes[current].append((move, current_score, opponent_score)) elif opponent_score >= 2 * score.THREE: two_threes[opponent].append((move, current_score, opponent_score)) elif current_score >= score.THREE: threes[current].append((move, current_score, opponent_score)) elif opponent_score >= score.THREE: threes[opponent].append((move, current_score, opponent_score)) elif current_score >= score.TWO: twos[current] = [(move, current_score, opponent_score) ] + twos[current] elif opponent_score >= score.TWO: twos[opponent] = [(move, current_score, opponent_score) ] + twos[opponent] else: others.append((move, current_score, opponent_score)) # if debug: # print('fives:', fives) # print('current fours:', fours[current]) # print('current blocked fours:', blocked_fours[current]) # print('current two threes:', two_threes[current]) # print('current threes:', threes[current]) if len(fives) > 0: # form our fives or block other's fives return fives if len(fours[current]) > 0: # form our fours return fours[current] if len(fours[opponent]) > 0 and len(blocked_fours[current]) <= 0: # other has fours, but we don't even have blocked four return fours[opponent] # others have fours, but we have blocked fours, then we can take those blocked fours total_fours = fours[current] + fours[opponent] total_blocked_fours = blocked_fours[current] + blocked_fours[opponent] if len(total_fours) > 0: return total_fours + total_blocked_fours # two threes, either block or form result = two_threes[current] + two_threes[opponent] + blocked_fours[ current] + blocked_fours[opponent] + threes[current] + threes[opponent] if len(two_threes[current]) > 0 or len(two_threes[opponent]) > 0: return result # twos, not very useful... total_twos = twos[current] + twos[opponent] # total_twos.sort(key=lambda t: max(t[1],t[2]), reverse=True) total_twos.sort(reverse=True) if len(total_twos) > 0: result += total_twos else: result += others # remember to add other points return result[:20]
#!/usr/bin/python3 import os, sys utilpath = sys.path[0] + "/../util/" sys.path.append(utilpath) utilpath = sys.path[0] + "/../Go4/" sys.path.append(utilpath) from simple_board import SimpleGoBoard import numpy as np from Go5 import Go5Player import time from board_util_go4 import BLACK, WHITE board = SimpleGoBoard(4) player = Go5Player(num_simulation=200, limit=100, exploration=np.sqrt(2)) player.MCTS.komi = 6.5 player.num_nodes = 5 player.MCTS.simulation_policy = 'random' cboard = board.copy() print("\nrunning playout 200 times\n") player.sample_run(cboard, BLACK, print_info=True) time.sleep(30) # sleeping player.num_simulation = 300 print("\nrunning it 300 more times\n") cboard = board.copy() player.sample_run(cboard, BLACK, print_info=True) time.sleep(30) print("\nrunning it 300 more times\n") cboard = board.copy()
def test_size_2_legal_moves(self): size = 2 goboard = SimpleGoBoard(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 __init__(self, value_fn, n_playout = 10000): self.root = TreeNode(None, SimpleGoBoard(7)) self.value_fn = value_fn self.n_playout = n_playout
def test_size_2(self): board = SimpleGoBoard(2) con = GtpConnection(Go0(), board) con.start_connection()