305 lines
11 KiB
Python
305 lines
11 KiB
Python
# multiAgents.py
|
|
# --------------
|
|
# Licensing Information: You are free to use or extend these projects for
|
|
# educational purposes provided that (1) you do not distribute or publish
|
|
# solutions, (2) you retain this notice, and (3) you provide clear
|
|
# attribution to UC Berkeley, including a link to http://ai.berkeley.edu.
|
|
#
|
|
# Attribution Information: The Pacman AI projects were developed at UC Berkeley.
|
|
# The core projects and autograders were primarily created by John DeNero
|
|
# (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
|
|
# Student side autograding was added by Brad Miller, Nick Hay, and
|
|
# Pieter Abbeel (pabbeel@cs.berkeley.edu).
|
|
|
|
|
|
from util import manhattanDistance
|
|
from game import Directions
|
|
import random, util
|
|
|
|
from game import Agent
|
|
|
|
class ReflexAgent(Agent):
|
|
"""
|
|
A reflex agent chooses an action at each choice point by examining
|
|
its alternatives via a state evaluation function.
|
|
|
|
The code below is provided as a guide. You are welcome to change
|
|
it in any way you see fit, so long as you don't touch our method
|
|
headers.
|
|
"""
|
|
|
|
|
|
def getAction(self, gameState):
|
|
"""
|
|
You do not need to change this method, but you're welcome to.
|
|
|
|
getAction chooses among the best options according to the evaluation function.
|
|
|
|
Just like in the previous project, getAction takes a GameState and returns
|
|
some Directions.X for some X in the set {North, South, West, East, Stop}
|
|
"""
|
|
# Collect legal moves and successor states
|
|
legalMoves = gameState.getLegalActions()
|
|
|
|
# Choose one of the best actions
|
|
scores = [self.evaluationFunction(gameState, action) for action in legalMoves]
|
|
bestScore = max(scores)
|
|
bestIndices = [index for index in range(len(scores)) if scores[index] == bestScore]
|
|
chosenIndex = random.choice(bestIndices) # Pick randomly among the best
|
|
|
|
# For debugging:
|
|
# print(gameState)
|
|
# print(list(zip(scores, legalMoves)))
|
|
# print("chosenAction", legalMoves[chosenIndex])
|
|
|
|
return legalMoves[chosenIndex]
|
|
|
|
def evaluationFunction(self, currentGameState, action):
|
|
"""
|
|
Design a better evaluation function here.
|
|
|
|
The evaluation function takes in the current and proposed successor
|
|
GameStates (pacman.py) and returns a number, where higher numbers are
|
|
better.
|
|
|
|
The code below extracts some useful information from the state, like
|
|
the remaining food (newFood) and Pacman position after moving (newPos).
|
|
newScaredTimes holds the number of moves that each ghost will remain
|
|
scared because of Pacman having eaten a power pellet.
|
|
|
|
Print out these variables to see what you're getting, then combine them
|
|
to create a masterful evaluation function.
|
|
"""
|
|
# Useful information you can extract from a GameState (pacman.py)
|
|
# newScaredTimes = [ghostSt.scaredTimer for ghostSt in newGhostStates]
|
|
|
|
successorGameState = currentGameState.generatePacmanSuccessor(action)
|
|
newPos = successorGameState.getPacmanPosition()
|
|
|
|
closestGhost = min([manhattanDistance(newPos, ghost.getPosition())
|
|
for ghost in successorGameState.getGhostStates()])
|
|
if closestGhost < 2.0:
|
|
return 0
|
|
|
|
if successorGameState.getScore() > currentGameState.getScore():
|
|
return 1.0
|
|
|
|
foodPositions = successorGameState.getFood().asList()
|
|
closestFoodDist = min([manhattanDistance(newPos, foodPos)
|
|
for foodPos in foodPositions])
|
|
|
|
return 1. / closestFoodDist
|
|
|
|
|
|
def scoreEvaluationFunction(currentGameState):
|
|
"""
|
|
This default evaluation function just returns the score of the state.
|
|
The score is the same one displayed in the Pacman GUI.
|
|
|
|
This evaluation function is meant for use with adversarial search agents
|
|
(not reflex agents).
|
|
"""
|
|
return currentGameState.getScore()
|
|
|
|
|
|
class MultiAgentSearchAgent(Agent):
|
|
"""
|
|
This class provides some common elements to all of your
|
|
multi-agent searchers. Any methods defined here will be available
|
|
to the MinimaxPacmanAgent, AlphaBetaPacmanAgent & ExpectimaxPacmanAgent.
|
|
|
|
You *do not* need to make any changes here, but you can if you want to
|
|
add functionality to all your adversarial search agents. Please do not
|
|
remove anything, however.
|
|
|
|
Note: this is an abstract class: one that should not be instantiated. It's
|
|
only partially specified, and designed to be extended. Agent (game.py)
|
|
is another abstract class.
|
|
"""
|
|
|
|
def __init__(self, evalFn = 'scoreEvaluationFunction', depth = '2'):
|
|
self.index = 0 # Pacman is always agent index 0
|
|
self.evaluationFunction = util.lookup(evalFn, globals())
|
|
self.depth = int(depth)
|
|
|
|
|
|
class MinimaxAgent(MultiAgentSearchAgent):
|
|
"""
|
|
Your minimax agent (question 2)
|
|
"""
|
|
|
|
def getAction(self, gameState):
|
|
"""
|
|
Returns the minimax action from the current gameState using
|
|
self.depth and self.evaluationFunction.
|
|
|
|
Here are some method calls that might be useful when implementing
|
|
minimax.
|
|
|
|
gameState.getLegalActions(agentIndex):
|
|
Returns a list of legal actions for an agent
|
|
agentIndex=0 means Pacman, ghosts are >= 1
|
|
|
|
gameState.generateSuccessor(agentIndex, action):
|
|
Returns the successor game state after an agent takes an action
|
|
|
|
gameState.getNumAgents():
|
|
Returns the total number of agents in the game
|
|
"""
|
|
|
|
numAgents = gameState.getNumAgents()
|
|
totalDepth = self.depth * numAgents
|
|
|
|
def value(depth, state):
|
|
agentIndex = depth % numAgents
|
|
actions = state.getLegalActions(agentIndex)
|
|
if not actions or depth == totalDepth:
|
|
return (self.evaluationFunction(state), "terminal")
|
|
successorStates = [state.generateSuccessor(agentIndex, action) for action in actions]
|
|
successorValueActionPairs = [(value(depth + 1, state)[0], action)
|
|
for action, state in zip(actions, successorStates)]
|
|
# Pacman (agentIndex=0) maximizes, ghosts minimize.
|
|
if agentIndex == 0:
|
|
return max(successorValueActionPairs)
|
|
else:
|
|
return min(successorValueActionPairs)
|
|
|
|
# [0] is the best value, [1] is the best action
|
|
return value(0, gameState)[1]
|
|
|
|
|
|
class AlphaBetaAgent(MultiAgentSearchAgent):
|
|
"""
|
|
Your minimax agent with alpha-beta pruning (question 3)
|
|
"""
|
|
|
|
def getAction(self, gameState):
|
|
"""
|
|
Returns the minimax action using self.depth and self.evaluationFunction
|
|
"""
|
|
numAgents = gameState.getNumAgents()
|
|
totalDepth = self.depth * numAgents
|
|
|
|
def value(depth, state, alpha, beta):
|
|
agentIndex = depth % numAgents
|
|
actions = state.getLegalActions(agentIndex)
|
|
if not actions or depth == totalDepth:
|
|
return (self.evaluationFunction(state), "terminal")
|
|
|
|
if agentIndex == 0:
|
|
maxTuple = (-999999, "None")
|
|
for action in actions:
|
|
newState = state.generateSuccessor(agentIndex, action)
|
|
newValue = value(depth + 1, newState, alpha, beta)[0]
|
|
newTuple = (newValue, action)
|
|
maxTuple = max((newValue, action), maxTuple)
|
|
if maxTuple[0] > beta:
|
|
return maxTuple
|
|
alpha = max(alpha, maxTuple[0])
|
|
return maxTuple
|
|
else:
|
|
minTuple = (999999, "None")
|
|
for action in actions:
|
|
newState = state.generateSuccessor(agentIndex, action)
|
|
newValue = value(depth + 1, newState, alpha, beta)[0]
|
|
minTuple = min((newValue, action), minTuple)
|
|
if minTuple[0] < alpha:
|
|
return minTuple
|
|
beta = min(beta, minTuple[0])
|
|
return minTuple
|
|
|
|
return value(0, gameState, alpha=-999999, beta=999999)[1]
|
|
|
|
|
|
class ExpectimaxAgent(MultiAgentSearchAgent):
|
|
"""
|
|
Your expectimax agent (question 4)
|
|
"""
|
|
|
|
def getAction(self, gameState):
|
|
"""
|
|
Returns the expectimax action using self.depth and self.evaluationFunction
|
|
|
|
All ghosts should be modeled as choosing uniformly at random from their
|
|
legal moves.
|
|
"""
|
|
numAgents = gameState.getNumAgents()
|
|
totalDepth = self.depth * numAgents
|
|
|
|
def value(depth, state):
|
|
agentIndex = depth % numAgents
|
|
actions = state.getLegalActions(agentIndex)
|
|
if not actions or depth == totalDepth:
|
|
return (self.evaluationFunction(state), "terminal")
|
|
successorStates = [state.generateSuccessor(agentIndex, action) for action in actions]
|
|
successorValueActionPairs = [(value(depth + 1, state)[0], action)
|
|
for action, state in zip(actions, successorStates)]
|
|
# Pacman (agentIndex=0) maximizes, ghosts minimize.
|
|
if agentIndex == 0:
|
|
return max(successorValueActionPairs)
|
|
else:
|
|
values = [va[0] for va in successorValueActionPairs]
|
|
average = sum(values) / float(len(values))
|
|
return (average, "expected")
|
|
|
|
# [0] is the best value, [1] is the best action
|
|
return value(0, gameState)[1]
|
|
|
|
|
|
def betterEvaluationFunction(currentGameState):
|
|
"""
|
|
Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
|
|
evaluation function (question 5).
|
|
|
|
DESCRIPTION: <write something here so we know what you did>
|
|
"""
|
|
|
|
from searchAgents import mazeDistance
|
|
|
|
state = currentGameState
|
|
pos = state.getPacmanPosition()
|
|
|
|
# foodDists = [mazeDistance(pos, foodPos, state)
|
|
# for foodPos in state.getFood().asList()]
|
|
scaredTimeScore = 0
|
|
scaredTimes = [ghostSt.scaredTimer for ghostSt in state.getGhostStates()]
|
|
if scaredTimes:
|
|
scaredTimeScore = min(scaredTimes)
|
|
|
|
ghostDists = []
|
|
for ghostState in state.getGhostStates():
|
|
x, y = ghostState.getPosition()
|
|
ghostPos = (int(x), int(y))
|
|
distance = mazeDistance(pos, ghostPos, state)
|
|
ghostDists.append(distance)
|
|
if ghostDists:
|
|
try:
|
|
ghostScore = 1. / min(ghostDists)
|
|
except ZeroDivisionError:
|
|
ghostScore = 100
|
|
|
|
foodDists = [manhattanDistance(pos, foodPos)
|
|
for foodPos in state.getFood().asList()]
|
|
foodScore = 0
|
|
if foodDists:
|
|
foodScore = 1. / min(foodDists)
|
|
|
|
gameScore = state.getScore()
|
|
|
|
weightGhost = -0.01
|
|
weightFood = 0.5
|
|
weightScore = 0.2
|
|
weightScaredTime = 0.01
|
|
|
|
score = ghostScore * weightGhost + \
|
|
foodScore * weightFood + \
|
|
gameScore * weightScore + \
|
|
scaredTimeScore * weightScaredTime
|
|
# print(state)
|
|
# print(score, ghostScore, foodScore, gameScore, scaredTimeScore)
|
|
return score
|
|
|
|
# Abbreviation
|
|
better = betterEvaluationFunction
|
|
|