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