def find_moves(self, board, mine): """ This function finds possible moves and sort it according one step rating on each move. Sorting it might utilizes alpha beta pruning if the first expanded node got the best value so far for min and max. Attributes: mine: boolean this is just to differ from max and min for evalution. """ if self.all_zeros(board): return [((5, 5), 0)] elif self.no_my_stones(board): if legalMove(board, (5, 5)): return [((5, 5), 0)] elif legalMove(board, (5, 6)): return [((5, 6), 0)] else: list_of_moves = [] # this is a list of (move, value) tuples for r in range(len(board)): for c in range(len(board)): if board[r, c] != 0: list_of_moves = list_of_moves + self.get_moves_from_a_position( board, r, c, mine) if mine: list_of_moves.sort(key=lambda item: item[1], reverse=True) else: list_of_moves.sort(key=lambda item: item[1]) return list_of_moves[: 20] # list_of_moves is truncated to top 20 moves for efficiency.
def precognition(player_id, board, node): returning_nodes = [] positions = np.nonzero(board == player_id) coordinates = list(zip(positions[0], positions[1])) for coord in coordinates: for x_pos in range(-1, 1): for y_pos in range(-1, 1): location = (coord[0] + x_pos, coord[1] + y_pos) if legalMove(board, location): new_board = copy.deepcopy(board) new_board[location[0]][location[1]] = player_id new_node = Node(new_board, node, coordinates=location) returning_nodes.append(new_node) return returning_nodes
def turn(board, player, turn_id): # make a copy of the board, which is passed to the agent tempBoard = np.array(board) # TIME_OUT seconds Timer try: with concurrent.futures.ThreadPoolExecutor() as executor: playerThread = executor.submit(player.move, tempBoard) moveLoc = playerThread.result(TIME_OUT + 1) except TimeOutException: # Caught the signal timeout exception print("before pass") pass except concurrent.futures.TimeoutError: print("Player" + str(turn_id) + " time out.") return turn_id * 1, board # test if the move is legal - on the original board if legalMove(board, moveLoc): board[moveLoc] = player.ID else: print("Player " + str(player.ID) + " illegal move at " + str(moveLoc)) return turn_id * -1, board # test if any player wins the game if winningTest(player.ID, board, X_IN_A_LINE): return turn_id, board # move to the next turn return 0, board
def actions(self, board): moves = [] for x in range(0, self.BOARD_SIZE): for y in range(0, self.BOARD_SIZE): if legalMove(board, (x, y)): moves.append((x, y)) return moves
def move(self, board): while True: x=input() y=input() moveLoc = (int(x),int(y)) if legalMove(board, moveLoc): return moveLoc print("Illegal move,Try Again")
def move(self, board): while True: # calculate best move location, if legal, return move location # call minimax root function to do this moveLoc = tuple() if legalMove(board, moveLoc): return moveLoc
def minimax(self, depth, game_position, is_max, alpha, beta): searching = True if depth == 0: return self.calculateScore(game_position) if is_max: best_move_score = -9999 for i in range(self.BOARD_SIZE): if (searching == False): break for j in range(self.BOARD_SIZE): check = (i, j) new_game_position = game_position if legalMove(new_game_position, check): new_game_position[check] = 1 best_move_score = max( best_move_score, self.minimax(depth - 1, new_game_position, not is_max, alpha, beta)) new_game_position[check] = 0 alpha = max(alpha, best_move_score) if beta <= alpha: searching = False break return best_move_score else: best_move_score = 9999 for i in range(self.BOARD_SIZE): if (searching == False): break for j in range(self.BOARD_SIZE): check = (i, j) new_game_position = game_position if legalMove(new_game_position, check): new_game_position[check] = -1 best_move_score = min( best_move_score, self.minimax(depth - 1, new_game_position, not is_max, alpha, beta)) new_game_position[check] = 0 beta = min(beta, best_move_score) if beta <= alpha: searching = False return best_move_score
def move(self, board): while True: print("H now: ", getHeuristics(self, board)) print("NOW IS PLAYER ", self.ID, " MOVE!!!\n") moveLoc = determineMove( self, board) #COMBINATION OF RANDOM AND NOT RANDOM MOVES if legalMove(board, moveLoc): return moveLoc
def move(self, board): is_max = True while True: # calculate best move location, if legal, return move location # call minimax root function to do this t = time() moveLoc = self.minimaxroot(1, board, is_max) print("Move loc: ", moveLoc) print("Time taken to get move location: ", time() - t) print("board move loc: ", board[moveLoc]) if legalMove(board, moveLoc): return moveLoc
def move(self, board): # First moves if legalMove(board, (5, 5)): return 5, 5 evaluations = [] moves = [] # Performs minimax and all possible moves from given board state for child in self.children(self.ID, board): moves.append([child[1], child[2]]) evaluation = self.minimax(self.ID, child[0], 2, -1_000_000, 1_000_000, True) evaluations.append(evaluation[0]) bestValueIndex = np.argmax(np.array(evaluations)) # Returns move that ends with the highest heuristic score (evaluation) return moves[bestValueIndex][0], moves[bestValueIndex][1]
def move(self, board): while True: move_loc = tuple(np.random.randint(self.BOARD_SIZE, size=2)) current_state = Node(board, ancestor=False) generate_tree(self.ID, current_state) best_value = minimax(current_state, 3, True, self.ID) for child in current_state.children: if child.value == best_value: move_loc = child.coordinates if legalMove(board, move_loc): return move_loc
def max_value(self, board): # initialize v = -∞ v = -np.inf coordinates = self.get_successors(board) # for each successor of state: for i in range(len(coordinates)): temp = np.array(board) r = coordinates[i][0] c = coordinates[i][1] temp[r, c] = self.ID state_val = self.value(temp) if state_val > v and legalMove(board, (r, c)): v = state_val move_loc = (r, c) return move_loc
def turn(board, player): # set the time out alarm and call player's move function signal.alarm(TIME_OUT) try: moveLoc = player.move(board) except timeOutException: return player.ID * -1, board signal.alarm(0) # test if the move is legal if legalMove(board, moveLoc): board[moveLoc] = player.ID else: return player.ID * -1, board # test if any player wins the game if winningTest(player.ID, board, X_IN_A_LINE): return player.ID, board # move to the next turn return 0, board
def minimaxroot(self, depth, game_position, is_max): best_move_location = (-100, -100) current_score = self.calculateScore(game_position) if is_max: best_move_score = -9999 else: best_move_score = 9999 temp_score = best_move_score for i in range(self.BOARD_SIZE): for j in range(self.BOARD_SIZE): check = (i, j) new_game_position = game_position if legalMove(new_game_position, check): new_game_position[check] = self.ID if (is_max and self.calculateScore(new_game_position) > current_score): temp_score = max( best_move_score, self.minimax(depth - 1, new_game_position, not is_max, -9999, 9999)) if (temp_score > best_move_score): best_move_location = check best_move_score = temp_score elif (self.calculateScore(new_game_position) < current_score): temp_score = min( best_move_score, self.minimax(depth - 1, new_game_position, not is_max, -9999, 9999)) new_game_position[check] = 0 if (temp_score < best_move_score): best_move_location = check best_move_score = temp_score new_game_position[check] = 0 return best_move_location
def move(self, board): while True: moveLoc = tuple(np.random.randint(self.BOARD_SIZE, size=2)) if legalMove(board, moveLoc): return moveLoc
def get_moves_from_a_position(self, board, r, c, mine): list_of_moves = [] if legalMove(board, (r - 1, c - 1)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r - 1, c - 1, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r - 1, c - 1, self.opp_id) ] if legalMove(board, (r - 1, c)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r - 1, c, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r - 1, c, self.opp_id) ] if legalMove(board, (r - 1, c + 1)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r - 1, c + 1, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r - 1, c + 1, self.opp_id) ] if legalMove(board, (r, c - 1)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r, c - 1, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r, c - 1, self.opp_id) ] if legalMove(board, (r, c)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r, c, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r, c, self.opp_id) ] if legalMove(board, (r, c + 1)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r, c + 1, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r, c + 1, self.opp_id) ] if legalMove(board, (r + 1, c - 1)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r + 1, c - 1, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r + 1, c - 1, self.opp_id) ] if legalMove(board, (r + 1, c)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r + 1, c, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r + 1, c, self.opp_id) ] if legalMove(board, (r + 1, c + 1)): if mine: list_of_moves = list_of_moves + [ self.get_move_result(board, r + 1, c + 1, self.ID) ] else: list_of_moves = list_of_moves + [ self.get_move_result(board, r + 1, c + 1, self.opp_id) ] return list_of_moves
def getChildBoards(ID, parentBoard): opponentID = ID * -1 childBoards = list() patternFound = False # complete five in a row if straight four is detected # scan for straight 4 horizontally left to right for row in range(BOARD_SIZE): for col in range(BOARD_SIZE - 5): if parentBoard[row, col] == 0 and parentBoard[row, col+1] == ID and \ parentBoard[row, col+2] == ID and parentBoard[row, col+3] == ID and parentBoard[row, col+4] == ID and \ parentBoard[row, col+5] == 0: childBoard = parentBoard.copy() childBoard[row, col] = ID childBoards.append(childBoard) patternFound = True # scan for straight 4 vertially top to bottom for row in range(BOARD_SIZE - 5): for col in range(BOARD_SIZE): if parentBoard[row, col] == 0 and parentBoard[row+1, col] == ID and \ parentBoard[row+2, col] == ID and parentBoard[row+3, col] == ID and parentBoard[row+4, col] == ID and \ parentBoard[row+5, col] == 0: childBoard = parentBoard.copy() childBoard[row, col] = ID childBoards.append(childBoard) patternFound = True # scan for straight 4 diagonally left to right for row in range(BOARD_SIZE - 5): for col in range(BOARD_SIZE - 5): if parentBoard[row, col] == 0 and parentBoard[row+1, col+1] == ID and \ parentBoard[row+2, col+2] == ID and parentBoard[row+3, col+3] == ID and parentBoard[row+4, col+4] == ID and \ parentBoard[row+5, col+5] == 0: childBoard = parentBoard.copy() childBoard[row, col] = ID childBoards.append(childBoard) patternFound = True # scan for straight 4 diagonally right to left for row in reversed(range(BOARD_SIZE - 5)): for col in reversed(range(BOARD_SIZE - 5)): if parentBoard[row, col] == 0 and parentBoard[row-1, col-1] == ID and \ parentBoard[row-2, col-2] == ID and parentBoard[row-3, col-3] == ID and parentBoard[row-4, col-4] == ID and \ parentBoard[row-5, col-5] == 0: childBoard = parentBoard.copy() childBoard[row, col] = ID childBoards.append(childBoard) patternFound = True # immediately block if opponent has 3 in a row # scan horizontally left to right for row in range(BOARD_SIZE): for col in range(BOARD_SIZE - 4): if parentBoard[row, col] == 0 and parentBoard[row, col+1] == opponentID and \ parentBoard[row, col+2] == opponentID and parentBoard[row, col+3] == opponentID and \ parentBoard[row, col+4] == 0: childBoard1 = parentBoard.copy() childBoard1[row, col] = ID childBoards.append(childBoard1) patternFound = True # scan vertially top to bottom for row in range(BOARD_SIZE - 4): for col in range(BOARD_SIZE): if parentBoard[row, col] == 0 and parentBoard[row+1, col] == opponentID and \ parentBoard[row+2, col] == opponentID and parentBoard[row+3, col] == opponentID and \ parentBoard[row+4, col] == 0: childBoard1 = parentBoard.copy() childBoard1[row, col] = ID childBoards.append(childBoard1) patternFound = True # # scan diagonally left to right for row in range(BOARD_SIZE - 4): for col in range(BOARD_SIZE - 4): if parentBoard[row, col] == 0 and parentBoard[row+1, col+1] == ID and \ parentBoard[row+2, col+2] == ID and parentBoard[row+3, col+3] == ID and \ parentBoard[row+4, col+4] == 0: childBoard1 = parentBoard.copy() childBoard1[row, col] = ID childBoards.append(childBoard1) patternFound = True # # scan diagonally right to left for row in reversed(range(BOARD_SIZE - 4)): for col in reversed(range(BOARD_SIZE - 4)): if parentBoard[row, col] == 0 and parentBoard[row-1, col-1] == ID and \ parentBoard[row-2, col-2] == ID and parentBoard[row-3, col-3] == ID and \ parentBoard[row-4, col-4] == 0: childBoard1 = parentBoard.copy() childBoard1[row, col] = ID childBoards.append(childBoard1) patternFound = True if not patternFound: while True: moveLoc = tuple(np.random.randint(BOARD_SIZE, size=2)) if legalMove(parentBoard, moveLoc): childBoard = parentBoard.copy() childBoard[moveLoc] = ID childBoards.append(childBoard) break return childBoards