class RemotePlayer(BasePlayer):
def __init__(self, max_depth=None):
BasePlayer.__init__(self, max_depth)
self.instructor_url = "http://silo.cs.indiana.edu:30005"
if self.max_depth > 8:
print("It refused to go that hard. Sorry.")
self.max_depth = 8
def findMove(self, trace):
import requests
r = requests.get(f'{self.instructor_url}/getmove/{self.max_depth},{trace}')
move = int(r.text)
return move

class PlayerMM(BasePlayer):
##################
# TODO #
##################
# performs minimax on board with depth.
# returns the best move and best score as a tuple
def minimax(self, board, depth):
# return null move and score for board's terminal state
# when game is over
if board.game_over == True:
move = 0
if board.winner == 0:
score = self.P1_WIN_SCORE
elif board.winner == 1:
score = self.P2_WIN_SCORE
else: # in case of tie
score = self.TIE_SCORE
return move, score

# return a null move and the heuristic value for board
# when non-end state and depth = 0
if depth == 0:
move = 0
score = self.heuristic(board)
return move, score

if board.turn == 0: # turn of maximising player
score = -math.inf
moves = board.getAllValidMoves()
for move in moves:
board = board.makeMove(move)
b_move, score = move, max(score, self.minimax(board, depth - 1))
board = board.undoMove()
return b_move, score
else: # turn of minimising player
score = math.inf
moves = board.getAllValidMoves()
for move in moves:
board = board.makeMove(move)
b_move, score = move, min(score, self.minimax(board, depth - 1))
board = board.undoMove()
return b_move, score

def findMove(self, trace):
board = Board(trace)
move, score = self.minimax(board, self.max_depth)
return move

class PlayerAB(BasePlayer):
##################
# TODO #
##################
# performs minimax with alpha-beta pruning on board with depth.
# alpha represents the score of max's current strategy
# beta represents the score of min's current strategy
# in a cutoff situation, return the score that resulted in the cutoff
# returns the best move and best score as a tuple
def alphaBeta(self, board, depth, alpha, beta):
# return null move and score for board's terminal state
# when game is over
if board.game_over:
move = 0
if board.winner == 0:
score = self.P1_WIN_SCORE
elif board.winner == 1:
score = self.P2_WIN_SCORE
else: # in case of tie
score = self.TIE_SCORE
return move, score

# return a null move and the heuristic value for board
# when non-end state and depth = 0
if depth == 0:
move = 0
score = self.heuristic(board)
return move, score

if board.turn == 0: # turn of maximising player
score = -math.inf
moves = board.getAllValidMoves()
for move in moves:
board = board.makeMove(move)
b_move, score = b_move, max(score, self.alphaBeta(board, depth - 1, alpha, beta))
if score >= beta:
break # beta cutoff
alpha = max(alpha, score)
return b_move, score

else:
score = math.inf
moves = board.getAllValidMoves()
for move in moves:
board = board.makeMove(move)
b_move, score = b_move, min(score, self.alphaBeta(board, depth - 1, alpha, beta))
if score <= alpha:
break # alpha cutoff
beta = min(beta, score)
return b_move, score

def findMove(self, trace):
board = Board(trace)
move, score = self.alphaBeta(board, self.max_depth, -math.inf, math.inf)
return move

class PlayerDP(PlayerAB):
''' A version of PlayerAB that implements dynamic programming
to cache values for its heuristic function, improving performance. '''
def __init__(self, max_depth):
PlayerAB.__init__(self, max_depth)
self.resolved = {}

##################
# TODO #
##################
# if a saved heuristic value exists in self.resolved for board.state, returns that value
# otherwise, uses BasePlayer.heuristic to get a heuristic value and saves it under board.state
def heuristic(self, board: Board):
if board.state in self.resolved.keys():
return self.resolved.get(str(board.state))
else:
score = BasePlayer.heuristic(board)
self.resolved{str(board.state)} = score
return score

class PlayerBonus(BasePlayer):
''' This class is here to give you space to experiment for your ultimate Mancala AI,
your one and only PlayerBonus. This is only used for the extra credit tournament. '''
def findMove(self, trace):
raise NotImplementedError

#######################################################
###########Example Subclass for Testing
#######################################################

# This will inherit your findMove from above, but will override the heuristic function with
# a new one; you can swap out the type of player by changing X in "class TestPlayer(X):"
class TestPlayer(BasePlayer):
# define your new heuristic here
def heuristic(self):
pass