talksik/pacman_games
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

getting right starter files

Browse Source
This commit is contained in:
Arjun Patel
2019-02-20 15:24:24 -08:00
parent 48d11417be
commit ade293719f
358 changed files with 8770 additions and 4878 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VERSION
+1 -1
View File
@@ -1 +1 @@
v1.001
v1.004
autograder.py
+29 -18
View File
@@ -29,8 +29,10 @@ except:
# register arguments and set default values
def readCommand(argv):
parser = optparse.OptionParser(description = 'Run public tests on student code')
parser.set_defaults(generateSolutions=False, edxOutput=False, gsOutput=False, muteOutput=False, printTestCase=False, noGraphics=False)
parser = optparse.OptionParser(
description='Run public tests on student code')
parser.set_defaults(generateSolutions=False, edxOutput=False, gsOutput=False,
muteOutput=False, printTestCase=False, noGraphics=False)
parser.add_option('--test-directory',
dest='testRoot',
default='test_cases',
@@ -107,14 +109,15 @@ def setModuleName(module, filename):
for i in dir(module):
o = getattr(module, i)
if hasattr(o, '__file__'): continue
if hasattr(o, '__file__'):
continue
if type(o) == functionType:
setattr(o, '__file__', filename)
elif type(o) == classType:
setattr(o, '__file__', filename)
# TODO: assign member __file__'s?
#print(i, type(o))
# print i, type(o)
#from cStringIO import StringIO
@@ -126,12 +129,14 @@ def loadModuleString(moduleSource):
#f = StringIO(moduleCodeDict[k])
#tmp = imp.load_module(k, f, k, (".py", "r", imp.PY_SOURCE))
tmp = imp.new_module(k)
exec(moduleCodeDict[k] in tmp.__dict__)
exec(moduleCodeDict[k], tmp.__dict__)
setModuleName(tmp, k)
return tmp
import py_compile
def loadModuleFile(moduleName, filePath):
with open(filePath, 'r') as f:
return imp.load_module(moduleName, f, "%s.py" % moduleName, (".py", "r", imp.PY_SOURCE))
@@ -174,6 +179,7 @@ ERROR_HINT_MAP = {
import pprint
def splitStrings(d):
d2 = dict(d)
for k in d:
@@ -222,7 +228,8 @@ def runTest(testName, moduleDict, printTestCase=False, display=None):
# returns all the tests you need to run in order to run question
def getDepends(testParser, testRoot, question):
allDeps = [question]
questionDict = testParser.TestParser(os.path.join(testRoot, question, 'CONFIG')).parse()
questionDict = testParser.TestParser(
os.path.join(testRoot, question, 'CONFIG')).parse()
if 'depends' in questionDict:
depends = questionDict['depends'].split()
for d in depends:
@@ -232,11 +239,13 @@ def getDepends(testParser, testRoot, question):
# get list of questions to grade
def getTestSubdirs(testParser, testRoot, questionToGrade):
problemDict = testParser.TestParser(os.path.join(testRoot, 'CONFIG')).parse()
problemDict = testParser.TestParser(
os.path.join(testRoot, 'CONFIG')).parse()
if questionToGrade != None:
questions = getDepends(testParser, testRoot, questionToGrade)
if len(questions) > 1:
print('Note: due to dependencies, the following tests will be run: %s' % ' '.join(questions))
print('Note: due to dependencies, the following tests will be run: %s' %
' '.join(questions))
return questions
if 'order' in problemDict:
return problemDict['order'].split()
@@ -263,14 +272,16 @@ def evaluate(generateSolutions, testRoot, moduleDict, exceptionMap=ERROR_HINT_MA
continue
# create a question object
questionDict = testParser.TestParser(os.path.join(subdir_path, 'CONFIG')).parse()
questionDict = testParser.TestParser(
os.path.join(subdir_path, 'CONFIG')).parse()
questionClass = getattr(testClasses, questionDict['class'])
question = questionClass(questionDict, display)
questionDicts[q] = questionDict
# load test cases into question
tests = filter(lambda t: re.match('[^#~.].*\.test\Z', t), os.listdir(subdir_path))
tests = map(lambda t: re.match('(.*)\.test\Z', t).group(1), tests)
tests = [t for t in os.listdir(
subdir_path) if re.match('[^#~.].*\.test\Z', t)]
tests = [re.match('(.*)\.test\Z', t).group(1) for t in tests]
for t in sorted(tests):
test_file = os.path.join(subdir_path, '%s.test' % t)
solution_file = os.path.join(subdir_path, '%s.solution' % t)
@@ -281,6 +292,7 @@ def evaluate(generateSolutions, testRoot, moduleDict, exceptionMap=ERROR_HINT_MA
testDict['test_out_file'] = test_out_file
testClass = getattr(projectTestClasses, testDict['class'])
testCase = testClass(question, testDict)
def makefun(testCase, solution_file):
if generateSolutions:
# write solution file to disk
@@ -312,7 +324,6 @@ def evaluate(generateSolutions, testRoot, moduleDict, exceptionMap=ERROR_HINT_MA
return grades.points
def getDisplay(graphicsByDefault, options=None):
graphics = graphicsByDefault
if options is not None and options.noGraphics:
@@ -327,8 +338,6 @@ def getDisplay(graphicsByDefault, options=None):
return textDisplay.NullGraphics()
if __name__ == '__main__':
options = readCommand(sys.argv)
if options.generateSolutions:
@@ -344,13 +353,15 @@ if __name__ == '__main__':
moduleDict = {}
for cp in codePaths:
moduleName = re.match('.*?([^/]*)\.py', cp).group(1)
moduleDict[moduleName] = loadModuleFile(moduleName, os.path.join(options.codeRoot, cp))
moduleDict[moduleName] = loadModuleFile(
moduleName, os.path.join(options.codeRoot, cp))
moduleName = re.match('.*?([^/]*)\.py', options.testCaseCode).group(1)
moduleDict['projectTestClasses'] = loadModuleFile(moduleName, os.path.join(options.codeRoot, options.testCaseCode))
moduleDict['projectTestClasses'] = loadModuleFile(
moduleName, os.path.join(options.codeRoot, options.testCaseCode))
if options.runTest != None:
runTest(options.runTest, moduleDict, printTestCase=options.printTestCase, display=getDisplay(True, options))
runTest(options.runTest, moduleDict, printTestCase=options.printTestCase,
display=getDisplay(True, options))
else:
evaluate(options.generateSolutions, options.testRoot, moduleDict,
gsOutput=options.gsOutput,
commands.txt
-21
View File
@@ -1,21 +0,0 @@
python pacman.py
python pacman.py --layout testMaze --pacman GoWestAgent
python pacman.py --layout tinyMaze --pacman GoWestAgent
python pacman.py -h
python pacman.py -l tinyMaze -p SearchAgent -a fn=tinyMazeSearch
python pacman.py -l tinyMaze -p SearchAgent
python pacman.py -l mediumMaze -p SearchAgent
python pacman.py -l bigMaze -z .5 -p SearchAgent
python pacman.py -l mediumMaze -p SearchAgent -a fn=bfs
python pacman.py -l bigMaze -p SearchAgent -a fn=bfs -z .5
python eightpuzzle.py
python pacman.py -l mediumMaze -p SearchAgent -a fn=ucs
python pacman.py -l mediumDottedMaze -p StayEastSearchAgent
python pacman.py -l mediumScaryMaze -p StayWestSearchAgent
python pacman.py -l bigMaze -z .5 -p SearchAgent -a fn=astar,heuristic=manhattanHeuristic
python pacman.py -l tinyCorners -p SearchAgent -a fn=bfs,prob=CornersProblem
python pacman.py -l mediumCorners -p SearchAgent -a fn=bfs,prob=CornersProblem
python pacman.py -l mediumCorners -p AStarCornersAgent -z 0.5
python pacman.py -l testSearch -p AStarFoodSearchAgent
python pacman.py -l trickySearch -p AStarFoodSearchAgent
python pacman.py -l bigSearch -p ClosestDotSearchAgent -z .5
eightpuzzle.py
-281
View File
@@ -1,281 +0,0 @@
# eightpuzzle.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).
import search
import random
# Module Classes
class EightPuzzleState:
"""
The Eight Puzzle is described in the course textbook on
page 64.
This class defines the mechanics of the puzzle itself. The
task of recasting this puzzle as a search problem is left to
the EightPuzzleSearchProblem class.
"""
def __init__( self, numbers ):
"""
Constructs a new eight puzzle from an ordering of numbers.
numbers: a list of integers from 0 to 8 representing an
instance of the eight puzzle. 0 represents the blank
space. Thus, the list
[1, 0, 2, 3, 4, 5, 6, 7, 8]
represents the eight puzzle:
-------------
| 1 | | 2 |
-------------
| 3 | 4 | 5 |
-------------
| 6 | 7 | 8 |
------------
The configuration of the puzzle is stored in a 2-dimensional
list (a list of lists) 'cells'.
"""
self.cells = []
numbers = numbers[:] # Make a copy so as not to cause side-effects.
numbers.reverse()
for row in range( 3 ):
self.cells.append( [] )
for col in range( 3 ):
self.cells[row].append( numbers.pop() )
if self.cells[row][col] == 0:
self.blankLocation = row, col
def isGoal( self ):
"""
Checks to see if the puzzle is in its goal state.
-------------
| | 1 | 2 |
-------------
| 3 | 4 | 5 |
-------------
| 6 | 7 | 8 |
-------------
>>> EightPuzzleState([0, 1, 2, 3, 4, 5, 6, 7, 8]).isGoal()
True
>>> EightPuzzleState([1, 0, 2, 3, 4, 5, 6, 7, 8]).isGoal()
False
"""
current = 0
for row in range( 3 ):
for col in range( 3 ):
if current != self.cells[row][col]:
return False
current += 1
return True
def legalMoves( self ):
"""
Returns a list of legal moves from the current state.
Moves consist of moving the blank space up, down, left or right.
These are encoded as 'up', 'down', 'left' and 'right' respectively.
>>> EightPuzzleState([0, 1, 2, 3, 4, 5, 6, 7, 8]).legalMoves()
['down', 'right']
"""
moves = []
row, col = self.blankLocation
if(row != 0):
moves.append('up')
if(row != 2):
moves.append('down')
if(col != 0):
moves.append('left')
if(col != 2):
moves.append('right')
return moves
def result(self, move):
"""
Returns a new eightPuzzle with the current state and blankLocation
updated based on the provided move.
The move should be a string drawn from a list returned by legalMoves.
Illegal moves will raise an exception, which may be an array bounds
exception.
NOTE: This function *does not* change the current object. Instead,
it returns a new object.
"""
row, col = self.blankLocation
if(move == 'up'):
newrow = row - 1
newcol = col
elif(move == 'down'):
newrow = row + 1
newcol = col
elif(move == 'left'):
newrow = row
newcol = col - 1
elif(move == 'right'):
newrow = row
newcol = col + 1
else:
raise "Illegal Move"
# Create a copy of the current eightPuzzle
newPuzzle = EightPuzzleState([0, 0, 0, 0, 0, 0, 0, 0, 0])
newPuzzle.cells = [values[:] for values in self.cells]
# And update it to reflect the move
newPuzzle.cells[row][col] = self.cells[newrow][newcol]
newPuzzle.cells[newrow][newcol] = self.cells[row][col]
newPuzzle.blankLocation = newrow, newcol
return newPuzzle
# Utilities for comparison and display
def __eq__(self, other):
"""
Overloads '==' such that two eightPuzzles with the same configuration
are equal.
>>> EightPuzzleState([0, 1, 2, 3, 4, 5, 6, 7, 8]) == \
EightPuzzleState([1, 0, 2, 3, 4, 5, 6, 7, 8]).result('left')
True
"""
for row in range( 3 ):
if self.cells[row] != other.cells[row]:
return False
return True
def __hash__(self):
return hash(str(self.cells))
def __getAsciiString(self):
"""
Returns a display string for the maze
"""
lines = []
horizontalLine = ('-' * (13))
lines.append(horizontalLine)
for row in self.cells:
rowLine = '|'
for col in row:
if col == 0:
col = ' '
rowLine = rowLine + ' ' + col.__str__() + ' |'
lines.append(rowLine)
lines.append(horizontalLine)
return '\n'.join(lines)
def __str__(self):
return self.__getAsciiString()
# TODO: Implement The methods in this class
class EightPuzzleSearchProblem(search.SearchProblem):
"""
Implementation of a SearchProblem for the Eight Puzzle domain
Each state is represented by an instance of an eightPuzzle.
"""
def __init__(self,puzzle):
"Creates a new EightPuzzleSearchProblem which stores search information."
self.puzzle = puzzle
def getStartState(self):
return puzzle
def isGoalState(self,state):
return state.isGoal()
def getSuccessors(self,state):
"""
Returns list of (successor, action, stepCost) pairs where
each succesor is either left, right, up, or down
from the original state and the cost is 1.0 for each
"""
succ = []
for a in state.legalMoves():
succ.append((state.result(a), a, 1))
return succ
def getCostOfActions(self, actions):
"""
actions: A list of actions to take
This method returns the total cost of a particular sequence of actions. The sequence must
be composed of legal moves
"""
return len(actions)
EIGHT_PUZZLE_DATA = [[1, 0, 2, 3, 4, 5, 6, 7, 8],
[1, 7, 8, 2, 3, 4, 5, 6, 0],
[4, 3, 2, 7, 0, 5, 1, 6, 8],
[5, 1, 3, 4, 0, 2, 6, 7, 8],
[1, 2, 5, 7, 6, 8, 0, 4, 3],
[0, 3, 1, 6, 8, 2, 7, 5, 4]]
def loadEightPuzzle(puzzleNumber):
"""
puzzleNumber: The number of the eight puzzle to load.
Returns an eight puzzle object generated from one of the
provided puzzles in EIGHT_PUZZLE_DATA.
puzzleNumber can range from 0 to 5.
>>> print(loadEightPuzzle(0))
-------------
| 1 | | 2 |
-------------
| 3 | 4 | 5 |
-------------
| 6 | 7 | 8 |
-------------
"""
return EightPuzzleState(EIGHT_PUZZLE_DATA[puzzleNumber])
def createRandomEightPuzzle(moves=100):
"""
moves: number of random moves to apply
Creates a random eight puzzle by applying
a series of 'moves' random moves to a solved
puzzle.
"""
puzzle = EightPuzzleState([0,1,2,3,4,5,6,7,8])
for i in range(moves):
# Execute a random legal move
puzzle = puzzle.result(random.sample(puzzle.legalMoves(), 1)[0])
return puzzle
if __name__ == '__main__':
puzzle = createRandomEightPuzzle(25)
print('A random puzzle:')
print(puzzle)
problem = EightPuzzleSearchProblem(puzzle)
path = search.breadthFirstSearch(problem)
print('BFS found a path of %d moves: %s' % (len(path), str(path)))
curr = puzzle
i = 1
for a in path:
curr = curr.result(a)
print('After %d move%s: %s' % (i, ("", "s")[i>1], a))
print(curr)
input("Press return for the next state...") # wait for key stroke
i += 1
game.py
+102 -53
View File
@@ -21,7 +21,8 @@
# For more info, see http://inst.eecs.berkeley.edu/~cs188/sp09/pacman.html
from util import *
import time, os
import time
import os
import traceback
import sys
@@ -29,6 +30,7 @@ import sys
# Parts worth reading #
#######################
class Agent:
"""
An agent must define a getAction method, but may also define the
@@ -36,6 +38,7 @@ class Agent:
def registerInitialState(self, state): # inspects the starting state
"""
def __init__(self, index=0):
self.index = index
@@ -46,6 +49,7 @@ class Agent:
"""
raiseNotDefined()
class Directions:
NORTH = 'North'
SOUTH = 'South'
@@ -59,7 +63,7 @@ class Directions:
WEST: SOUTH,
STOP: STOP}
RIGHT = dict([(y,x) for x, y in LEFT.items()])
RIGHT = dict([(y, x) for x, y in list(LEFT.items())])
REVERSE = {NORTH: SOUTH,
SOUTH: NORTH,
@@ -67,6 +71,7 @@ class Directions:
WEST: EAST,
STOP: STOP}
class Configuration:
"""
A Configuration holds the (x,y) coordinate of a character, along with its
@@ -91,7 +96,8 @@ class Configuration:
return x == int(x) and y == int(y)
def __eq__(self, other):
if other == None: return False
if other == None:
return False
return (self.pos == other.pos and self.direction == other.direction)
def __hash__(self):
@@ -117,6 +123,7 @@ class Configuration:
direction = self.direction # There is no stop direction
return Configuration((x + dx, y+dy), direction)
class AgentState:
"""
AgentStates hold the state of an agent (configuration, speed, scared, etc).
@@ -127,6 +134,7 @@ class AgentState:
self.configuration = startConfiguration
self.isPacman = isPacman
self.scaredTimer = 0
# state below potentially used for contest only
self.numCarrying = 0
self.numReturned = 0
@@ -153,12 +161,14 @@ class AgentState:
return state
def getPosition(self):
if self.configuration == None: return None
if self.configuration == None:
return None
return self.configuration.getPosition()
def getDirection(self):
return self.configuration.getDirection()
class Grid:
"""
A 2-dimensional array of objects backed by a list of lists. Data is accessed
@@ -167,13 +177,16 @@ class Grid:
The __str__ method constructs an output that is oriented like a pacman board.
"""
def __init__(self, width, height, initialValue=False, bitRepresentation=None):
if initialValue not in [False, True]: raise Exception('Grids can only contain booleans')
if initialValue not in [False, True]:
raise Exception('Grids can only contain booleans')
self.CELLS_PER_INT = 30
self.width = width
self.height = height
self.data = [[initialValue for y in range(height)] for x in range(width)]
self.data = [[initialValue for y in range(
height)] for x in range(width)]
if bitRepresentation:
self._unpackBits(bitRepresentation)
@@ -184,12 +197,14 @@ class Grid:
self.data[key] = item
def __str__(self):
out = [[str(self.data[x][y])[0] for x in range(self.width)] for y in range(self.height)]
out = [[str(self.data[x][y])[0] for x in range(self.width)]
for y in range(self.height)]
out.reverse()
return '\n'.join([''.join(x) for x in out])
def __eq__(self, other):
if other == None: return False
if other == None:
return False
return self.data == other.data
def __hash__(self):
@@ -223,7 +238,8 @@ class Grid:
list = []
for x in range(self.width):
for y in range(self.height):
if self[x][y] == key: list.append( (x,y) )
if self[x][y] == key:
list.append((x, y))
return list
def packBits(self):
@@ -246,7 +262,7 @@ class Grid:
return tuple(bits)
def _cellIndexToPosition(self, index):
x = index // self.height
x = index / self.height
y = index % self.height
return x, y
@@ -257,14 +273,16 @@ class Grid:
cell = 0
for packed in bits:
for bit in self._unpackInt(packed, self.CELLS_PER_INT):
if cell == self.width * self.height: break
if cell == self.width * self.height:
break
x, y = self._cellIndexToPosition(cell)
self[x][y] = bit
cell += 1
def _unpackInt(self, packed, size):
bools = []
if packed < 0: raise ValueError("must be a positive integer")
if packed < 0:
raise ValueError("must be a positive integer")
for i in range(size):
n = 2 ** (self.CELLS_PER_INT - i - 1)
if packed >= n:
@@ -274,6 +292,7 @@ class Grid:
bools.append(False)
return bools
def reconstituteGrid(bitRep):
if type(bitRep) is not type((1, 2)):
return bitRep
@@ -284,18 +303,19 @@ def reconstituteGrid(bitRep):
# Parts you shouldn't have to read #
####################################
class Actions:
"""
A collection of static methods for manipulating move actions.
"""
# Directions
_directions = {Directions.NORTH: (0, 1),
Directions.SOUTH: (0, -1),
_directions = {Directions.WEST: (-1, 0),
Directions.STOP: (0, 0),
Directions.EAST: (1, 0),
Directions.WEST: (-1, 0),
Directions.STOP: (0, 0)}
Directions.NORTH: (0, 1),
Directions.SOUTH: (0, -1)}
_directionsAsList = _directions.items()
_directionsAsList = [('West', (-1, 0)), ('Stop', (0, 0)), ('East', (1, 0)), ('North', (0, 1)), ('South', (0, -1))]
TOLERANCE = .001
@@ -342,7 +362,8 @@ class Actions:
dx, dy = vec
next_y = y_int + dy
next_x = x_int + dx
if not walls[next_x][next_y]: possible.append(dir)
if not walls[next_x][next_y]:
possible.append(dir)
return possible
@@ -355,10 +376,13 @@ class Actions:
for dir, vec in Actions._directionsAsList:
dx, dy = vec
next_x = x_int + dx
if next_x < 0 or next_x == walls.width: continue
if next_x < 0 or next_x == walls.width:
continue
next_y = y_int + dy
if next_y < 0 or next_y == walls.height: continue
if not walls[next_x][next_y]: neighbors.append((next_x, next_y))
if next_y < 0 or next_y == walls.height:
continue
if not walls[next_x][next_y]:
neighbors.append((next_x, next_y))
return neighbors
getLegalNeighbors = staticmethod(getLegalNeighbors)
@@ -368,10 +392,9 @@ class Actions:
return (x + dx, y + dy)
getSuccessor = staticmethod(getSuccessor)
class GameStateData:
"""
"""
class GameStateData:
def __init__(self, prevState=None):
"""
Generates a new data packet by copying information from its predecessor.
@@ -412,12 +435,17 @@ class GameStateData:
"""
Allows two states to be compared.
"""
if other == None: return False
if other == None:
return False
# TODO Check for type of other
if not self.agentStates == other.agentStates: return False
if not self.food == other.food: return False
if not self.capsules == other.capsules: return False
if not self.score == other.score: return False
if not self.agentStates == other.agentStates:
return False
if not self.food == other.food:
return False
if not self.capsules == other.capsules:
return False
if not self.score == other.score:
return False
return True
def __hash__(self):
@@ -443,8 +471,10 @@ class GameStateData:
map[x][y] = self._foodWallStr(food[x][y], walls[x][y])
for agentState in self.agentStates:
if agentState == None: continue
if agentState.configuration == None: continue
if agentState == None:
continue
if agentState.configuration == None:
continue
x, y = [int(i) for i in nearestPoint(agentState.configuration.pos)]
agent_dir = agentState.configuration.direction
if agentState.isPacman:
@@ -499,17 +529,22 @@ class GameStateData:
numGhosts = 0
for isPacman, pos in layout.agentPositions:
if not isPacman:
if numGhosts == numGhostAgents: continue # Max ghosts reached already
else: numGhosts += 1
self.agentStates.append( AgentState( Configuration( pos, Directions.STOP), isPacman) )
if numGhosts == numGhostAgents:
continue # Max ghosts reached already
else:
numGhosts += 1
self.agentStates.append(AgentState(
Configuration(pos, Directions.STOP), isPacman))
self._eaten = [False for a in self.agentStates]
try:
import boinc
_BOINC_ENABLED = True
except:
_BOINC_ENABLED = False
class Game:
"""
The Game manages the control flow, soliciting actions from agents.
@@ -539,7 +574,8 @@ class Game:
def _agentCrash(self, agentIndex, quiet=False):
"Helper method for handling agent crashes"
if not quiet: traceback.print_exc()
if not quiet:
traceback.print_exc()
self.gameOver = True
self.agentCrashed = True
self.rules.agentCrash(self, agentIndex)
@@ -548,7 +584,8 @@ class Game:
OLD_STDERR = None
def mute(self, agentIndex):
if not self.muteAgents: return
if not self.muteAgents:
return
global OLD_STDOUT, OLD_STDERR
import io
OLD_STDOUT = sys.stdout
@@ -557,13 +594,13 @@ class Game:
sys.stderr = self.agentOutput[agentIndex]
def unmute(self):
if not self.muteAgents: return
if not self.muteAgents:
return
global OLD_STDOUT, OLD_STDERR
# Revert stdout/stderr to originals
sys.stdout = OLD_STDOUT
sys.stderr = OLD_STDERR
def run(self):
"""
Main control loop for game play.
@@ -571,7 +608,7 @@ class Game:
self.display.initialize(self.state.data)
self.numMoves = 0
###self.display.initialize(self.state.makeObservation(1).data)
# self.display.initialize(self.state.makeObservation(1).data)
# inform learning agents of the game start
for i in range(len(self.agents)):
agent = self.agents[i]
@@ -587,14 +624,16 @@ class Game:
self.mute(i)
if self.catchExceptions:
try:
timed_func = TimeoutFunction(agent.registerInitialState, int(self.rules.getMaxStartupTime(i)))
timed_func = TimeoutFunction(
agent.registerInitialState, int(self.rules.getMaxStartupTime(i)))
try:
start_time = time.time()
timed_func(self.state.deepCopy())
time_taken = time.time() - start_time
self.totalAgentTimes[i] += time_taken
except TimeoutFunctionException:
print("Agent %d ran out of time on startup!" % i, file=sys.stderr)
print("Agent %d ran out of time on startup!" %
i, file=sys.stderr)
self.unmute()
self.agentTimeout = True
self._agentCrash(i, quiet=True)
@@ -605,7 +644,7 @@ class Game:
return
else:
agent.registerInitialState(self.state.deepCopy())
## TODO: could this exceed the total time
# TODO: could this exceed the total time
self.unmute()
agentIndex = self.startingIndex
@@ -621,7 +660,8 @@ class Game:
self.mute(agentIndex)
if self.catchExceptions:
try:
timed_func = TimeoutFunction(agent.observationFunction, int(self.rules.getMoveTimeout(agentIndex)))
timed_func = TimeoutFunction(agent.observationFunction, int(
self.rules.getMoveTimeout(agentIndex)))
try:
start_time = time.time()
observation = timed_func(self.state.deepCopy())
@@ -634,7 +674,8 @@ class Game:
self.unmute()
return
else:
observation = agent.observationFunction(self.state.deepCopy())
observation = agent.observationFunction(
self.state.deepCopy())
self.unmute()
else:
observation = self.state.deepCopy()
@@ -644,14 +685,16 @@ class Game:
self.mute(agentIndex)
if self.catchExceptions:
try:
timed_func = TimeoutFunction(agent.getAction, int(self.rules.getMoveTimeout(agentIndex)) - int(move_time))
timed_func = TimeoutFunction(agent.getAction, int(
self.rules.getMoveTimeout(agentIndex)) - int(move_time))
try:
start_time = time.time()
if skip_action:
raise TimeoutFunctionException()
action = timed_func(observation)
except TimeoutFunctionException:
print("Agent %d timed out on a single move!" % agentIndex, file=sys.stderr)
print("Agent %d timed out on a single move!" %
agentIndex, file=sys.stderr)
self.agentTimeout = True
self._agentCrash(agentIndex, quiet=True)
self.unmute()
@@ -661,18 +704,21 @@ class Game:
if move_time > self.rules.getMoveWarningTime(agentIndex):
self.totalAgentTimeWarnings[agentIndex] += 1
print("Agent %d took too long to make a move! This is warning %d" % (agentIndex, self.totalAgentTimeWarnings[agentIndex]), file=sys.stderr)
print("Agent %d took too long to make a move! This is warning %d" % (
agentIndex, self.totalAgentTimeWarnings[agentIndex]), file=sys.stderr)
if self.totalAgentTimeWarnings[agentIndex] > self.rules.getMaxTimeWarnings(agentIndex):
print("Agent %d exceeded the maximum number of warnings: %d" % (agentIndex, self.totalAgentTimeWarnings[agentIndex]), file=sys.stderr)
print("Agent %d exceeded the maximum number of warnings: %d" % (
agentIndex, self.totalAgentTimeWarnings[agentIndex]), file=sys.stderr)
self.agentTimeout = True
self._agentCrash(agentIndex, quiet=True)
self.unmute()
return
self.totalAgentTimes[agentIndex] += move_time
#print("Agent: %d, time: %f, total: %f" % (agentIndex, move_time, self.totalAgentTimes[agentIndex]))
# print "Agent: %d, time: %f, total: %f" % (agentIndex, move_time, self.totalAgentTimes[agentIndex])
if self.totalAgentTimes[agentIndex] > self.rules.getMaxTotalTime(agentIndex):
print("Agent %d ran out of time! (time: %1.2f)" % (agentIndex, self.totalAgentTimes[agentIndex]), file=sys.stderr)
print("Agent %d ran out of time! (time: %1.2f)" % (
agentIndex, self.totalAgentTimes[agentIndex]), file=sys.stderr)
self.agentTimeout = True
self._agentCrash(agentIndex, quiet=True)
self.unmute()
@@ -690,7 +736,8 @@ class Game:
self.moveHistory.append((agentIndex, action))
if self.catchExceptions:
try:
self.state = self.state.generateSuccessor( agentIndex, action )
self.state = self.state.generateSuccessor(
agentIndex, action)
except Exception as data:
self.mute(agentIndex)
self._agentCrash(agentIndex)
@@ -707,7 +754,8 @@ class Game:
# Allow for game specific conditions (winning, losing, etc.)
self.rules.process(self.state, self)
# Track progress
if agentIndex == numAgents + 1: self.numMoves += 1
if agentIndex == numAgents + 1:
self.numMoves += 1
# Next agent
agentIndex = (agentIndex + 1) % numAgents
@@ -722,7 +770,8 @@ class Game:
agent.final(self.state)
self.unmute()
except Exception as data:
if not self.catchExceptions: raise data
if not self.catchExceptions:
raise
self._agentCrash(agentIndex)
self.unmute()
return
ghostAgents.py
+19 -7
View File
@@ -19,6 +19,7 @@ import random
from util import manhattanDistance
import util
class GhostAgent(Agent):
def __init__(self, index):
self.index = index
@@ -34,16 +35,21 @@ class GhostAgent( Agent ):
"Returns a Counter encoding a distribution over actions from the provided state."
util.raiseNotDefined()
class RandomGhost(GhostAgent):
"A ghost that chooses a legal action uniformly at random."
def getDistribution(self, state):
dist = util.Counter()
for a in state.getLegalActions( self.index ): dist[a] = 1.0
for a in state.getLegalActions(self.index):
dist[a] = 1.0
dist.normalize()
return dist
class DirectionalGhost(GhostAgent):
"A ghost that prefers to rush Pacman, or flee when scared."
def __init__(self, index, prob_attack=0.8, prob_scaredFlee=0.8):
self.index = index
self.prob_attack = prob_attack
@@ -57,25 +63,31 @@ class DirectionalGhost( GhostAgent ):
isScared = ghostState.scaredTimer > 0
speed = 1
if isScared: speed = 0.5
if isScared:
speed = 0.5
actionVectors = [Actions.directionToVector( a, speed ) for a in legalActions]
actionVectors = [Actions.directionToVector(
a, speed) for a in legalActions]
newPositions = [(pos[0]+a[0], pos[1]+a[1]) for a in actionVectors]
pacmanPosition = state.getPacmanPosition()
# Select best actions given the state
distancesToPacman = [manhattanDistance( pos, pacmanPosition ) for pos in newPositions]
distancesToPacman = [manhattanDistance(
pos, pacmanPosition) for pos in newPositions]
if isScared:
bestScore = max(distancesToPacman)
bestProb = self.prob_scaredFlee
else:
bestScore = min(distancesToPacman)
bestProb = self.prob_attack
bestActions = [action for action, distance in zip( legalActions, distancesToPacman ) if distance == bestScore]
bestActions = [action for action, distance in zip(
legalActions, distancesToPacman) if distance == bestScore]
# Construct distribution
dist = util.Counter()
for a in bestActions: dist[a] = bestProb / len(bestActions)
for a in legalActions: dist[a] += ( 1-bestProb ) / len(legalActions)
for a in bestActions:
dist[a] = bestProb / len(bestActions)
for a in legalActions:
dist[a] += (1-bestProb) / len(legalActions)
dist.normalize()
return dist
grading.py
+25 -20
View File
@@ -23,8 +23,10 @@ import pdb
from collections import defaultdict
import util
class Grades:
"A data structure for project grades, along with formatting code to display them"
def __init__(self, projectName, questionsAndMaxesList,
gsOutput=False, edxOutput=False, muteOutput=False):
"""
@@ -45,7 +47,7 @@ class Grades:
self.mute = muteOutput
self.prereqs = defaultdict(set)
#print('Autograder transcript for %s' % self.project)
# print 'Autograder transcript for %s' % self.project
print('Starting on %d-%d at %d:%02d:%02d' % self.start)
def addPrereq(self, question, prereq):
@@ -61,21 +63,22 @@ class Grades:
for q in self.questions:
print('\nQuestion %s' % q)
print('=' * (9 + len(q)))
print
print()
self.currentQuestion = q
incompleted = self.prereqs[q].difference(completedQuestions)
if len(incompleted) > 0:
prereq = incompleted.pop()
print(
"""*** NOTE: Make sure to complete Question %s before working on Question %s,
print("""*** NOTE: Make sure to complete Question %s before working on Question %s,
*** because Question %s builds upon your answer for Question %s.
""" % (prereq, q, q, prereq))
continue
if self.mute: util.mutePrint()
if self.mute:
util.mutePrint()
try:
util.TimeoutFunction(getattr(gradingModule, q),1800)(self) # Call the question's function
util.TimeoutFunction(getattr(gradingModule, q), 1800)(
self) # Call the question's function
# TimeoutFunction(getattr(gradingModule, q),1200)(self) # Call the question's function
except Exception as inst:
self.addExceptionMessage(q, inst, traceback)
@@ -83,13 +86,14 @@ class Grades:
except:
self.fail('FAIL: Terminated with a string exception.')
finally:
if self.mute: util.unmutePrint()
if self.mute:
util.unmutePrint()
if self.points[q] >= self.maxes[q]:
completedQuestions.add(q)
print('\n### Question %s: %d/%d ###\n' % (q, self.points[q], self.maxes[q]))
print('\n### Question %s: %d/%d ###\n' %
(q, self.points[q], self.maxes[q]))
print('\nFinished at %d:%02d:%02d' % time.localtime()[3:6])
print("\nProvisional grades\n==================")
@@ -97,7 +101,8 @@ class Grades:
for q in self.questions:
print('Question %s: %d/%d' % (q, self.points[q], self.maxes[q]))
print('------------------')
print('Total: %d/%d' % (self.points.totalCount(), sum(self.maxes.values())))
print('Total: %d/%d' %
(self.points.totalCount(), sum(self.maxes.values())))
if bonusPic and self.points.totalCount() == 25:
print("""
@@ -181,7 +186,8 @@ to follow your instructor's guidelines to receive credit on your project.
total_score = sum(self.points.values())
out_dct['score'] = total_score
out_dct['max_score'] = total_possible
out_dct['output'] = "Total score (%d / %d)" % (total_score, total_possible)
out_dct['output'] = "Total score (%d / %d)" % (
total_score, total_possible)
# individual tests
tests_out = []
@@ -256,8 +262,8 @@ to follow your instructor's guidelines to receive credit on your project.
checkOrX=checkOrX,
points=self.points[q]
)
# print("*** output for Question %s " % q[1])
# print(output)
# print "*** output for Question %s " % q[1]
# print output
edxOutput.write(output)
edxOutput.write("</div>")
edxOutput.close()
@@ -288,9 +294,11 @@ to follow your instructor's guidelines to receive credit on your project.
def addMessage(self, message, raw=False):
if not raw:
# We assume raw messages, formatted for HTML, are printed separately
if self.mute: util.unmutePrint()
if self.mute:
util.unmutePrint()
print('*** ' + message)
if self.mute: util.mutePrint()
if self.mute:
util.mutePrint()
message = cgi.escape(message)
self.messages[self.currentQuestion].append(message)
@@ -298,17 +306,15 @@ to follow your instructor's guidelines to receive credit on your project.
print("WARNING**** addMessageToEmail is deprecated %s" % message)
for line in message.split('\n'):
pass
#print('%%% ' + line + ' %%%')
# print '%%% ' + line + ' %%%'
# self.messages[self.currentQuestion].append(line)
class Counter(dict):
"""
Dict with default 0
"""
def __getitem__(self, idx):
try:
return dict.__getitem__(self, idx)
@@ -320,4 +326,3 @@ class Counter(dict):
Returns the sum of counts for all keys.
"""
return sum(self.values())
graphicsDisplay.py
+118 -59
View File
@@ -13,7 +13,8 @@
from graphicsUtils import *
import math, time
import math
import time
from game import Directions
###########################
@@ -58,7 +59,7 @@ GHOST_SHAPE = [
GHOST_SIZE = 0.65
SCARED_COLOR = formatColor(1, 1, 1)
GHOST_VEC_COLORS = [colorToVector(c) for c in GHOST_COLORS]
GHOST_VEC_COLORS = list(map(colorToVector, GHOST_COLORS))
PACMAN_COLOR = formatColor(255.0/255.0, 255.0/255.0, 61.0/255)
PACMAN_SCALE = 0.5
@@ -79,6 +80,7 @@ CAPSULE_SIZE = 0.25
# Drawing walls
WALL_RADIUS = 0.15
class InfoPane:
def __init__(self, layout, gridSize):
self.gridSize = gridSize
@@ -103,7 +105,8 @@ class InfoPane:
return x, y
def drawPane(self):
self.scoreText = text( self.toScreen(0, 0 ), self.textColor, "SCORE: 0", "Times", self.fontSize, "bold")
self.scoreText = text(self.toScreen(
0, 0), self.textColor, "SCORE: 0", "Times", self.fontSize, "bold")
def initializeGhostDistances(self, distances):
self.ghostDistanceText = []
@@ -115,7 +118,8 @@ class InfoPane:
size = 10
for i, d in enumerate(distances):
t = text( self.toScreen(self.width//2 + self.width//8 * i, 0), GHOST_COLORS[i+1], d, "Times", size, "bold")
t = text(self.toScreen(self.width/2 + self.width/8 * i, 0),
GHOST_COLORS[i+1], d, "Times", size, "bold")
self.ghostDistanceText.append(t)
def updateScore(self, score):
@@ -123,12 +127,16 @@ class InfoPane:
def setTeam(self, isBlue):
text = "RED TEAM"
if isBlue: text = "BLUE TEAM"
self.teamText = text( self.toScreen(300, 0 ), self.textColor, text, "Times", self.fontSize, "bold")
if isBlue:
text = "BLUE TEAM"
self.teamText = text(self.toScreen(
300, 0), self.textColor, text, "Times", self.fontSize, "bold")
def updateGhostDistances(self, distances):
if len(distances) == 0: return
if 'ghostDistanceText' not in dir(self): self.initializeGhostDistances(distances)
if len(distances) == 0:
return
if 'ghostDistanceText' not in dir(self):
self.initializeGhostDistances(distances)
else:
for i, d in enumerate(distances):
changeText(self.ghostDistanceText[i], d)
@@ -224,7 +232,8 @@ class PacmanGraphics:
Changes an image from a ghost to a pacman or vis versa (for capture)
"""
prevState, prevImage = self.agentImages[agentIndex]
for item in prevImage: remove_from_screen(item)
for item in prevImage:
remove_from_screen(item)
if newState.isPacman:
image = self.drawPacman(newState, agentIndex)
self.agentImages[agentIndex] = (newState, image)
@@ -237,7 +246,8 @@ class PacmanGraphics:
agentIndex = newState._agentMoved
agentState = newState.agentStates[agentIndex]
if self.agentImages[agentIndex][0].isPacman != agentState.isPacman: self.swapImages(agentIndex, agentState)
if self.agentImages[agentIndex][0].isPacman != agentState.isPacman:
self.swapImages(agentIndex, agentState)
prevState, prevImage = self.agentImages[agentIndex]
if agentState.isPacman:
self.animatePacman(agentState, prevState, prevImage)
@@ -318,12 +328,14 @@ class PacmanGraphics:
px, py = self.getPosition(pacman)
frames = 4.0
for i in range(1, int(frames) + 1):
pos = px*i/frames + fx*(frames-i)/frames, py*i/frames + fy*(frames-i)/frames
pos = px*i/frames + fx * \
(frames-i)/frames, py*i/frames + fy*(frames-i)/frames
self.movePacman(pos, self.getDirection(pacman), image)
refresh()
sleep(abs(self.frameTime) / frames)
else:
self.movePacman(self.getPosition(pacman), self.getDirection(pacman), image)
self.movePacman(self.getPosition(pacman),
self.getDirection(pacman), image)
refresh()
def getGhostColor(self, ghost, ghostIndex):
@@ -338,7 +350,8 @@ class PacmanGraphics:
(screen_x, screen_y) = (self.to_screen(pos))
coords = []
for (x, y) in GHOST_SHAPE:
coords.append((x*self.gridSize*GHOST_SIZE + screen_x, y*self.gridSize*GHOST_SIZE + screen_y))
coords.append((x*self.gridSize*GHOST_SIZE + screen_x,
y*self.gridSize*GHOST_SIZE + screen_y))
colour = self.getGhostColor(ghost, agentIndex)
body = polygon(coords, colour, filled=1)
@@ -355,10 +368,14 @@ class PacmanGraphics:
dx = 0.2
if dir == 'West':
dx = -0.2
leftEye = circle((screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx/1.5), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2, WHITE, WHITE)
rightEye = circle((screen_x+self.gridSize*GHOST_SIZE*(0.3+dx/1.5), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2, WHITE, WHITE)
leftPupil = circle((screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08, BLACK, BLACK)
rightPupil = circle((screen_x+self.gridSize*GHOST_SIZE*(0.3+dx), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08, BLACK, BLACK)
leftEye = circle((screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx/1.5), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2, WHITE, WHITE)
rightEye = circle((screen_x+self.gridSize*GHOST_SIZE*(0.3+dx/1.5), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2, WHITE, WHITE)
leftPupil = circle((screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08, BLACK, BLACK)
rightPupil = circle((screen_x+self.gridSize*GHOST_SIZE*(0.3+dx), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08, BLACK, BLACK)
ghostImageParts = []
ghostImageParts.append(body)
ghostImageParts.append(leftEye)
@@ -380,10 +397,14 @@ class PacmanGraphics:
dx = 0.2
if dir == 'West':
dx = -0.2
moveCircle(eyes[0],(screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx/1.5), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2)
moveCircle(eyes[1],(screen_x+self.gridSize*GHOST_SIZE*(0.3+dx/1.5), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2)
moveCircle(eyes[2],(screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08)
moveCircle(eyes[3],(screen_x+self.gridSize*GHOST_SIZE*(0.3+dx), screen_y-self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08)
moveCircle(eyes[0], (screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx/1.5), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2)
moveCircle(eyes[1], (screen_x+self.gridSize*GHOST_SIZE*(0.3+dx/1.5), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy/1.5)), self.gridSize*GHOST_SIZE*0.2)
moveCircle(eyes[2], (screen_x+self.gridSize*GHOST_SIZE*(-0.3+dx), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08)
moveCircle(eyes[3], (screen_x+self.gridSize*GHOST_SIZE*(0.3+dx), screen_y -
self.gridSize*GHOST_SIZE*(0.3-dy)), self.gridSize*GHOST_SIZE*0.08)
def moveGhost(self, ghost, ghostIndex, prevGhost, ghostImageParts):
old_x, old_y = self.to_screen(self.getPosition(prevGhost))
@@ -399,15 +420,18 @@ class PacmanGraphics:
else:
color = GHOST_COLORS[ghostIndex]
edit(ghostImageParts[0], ('fill', color), ('outline', color))
self.moveEyes(self.getPosition(ghost), self.getDirection(ghost), ghostImageParts[-4:])
self.moveEyes(self.getPosition(ghost),
self.getDirection(ghost), ghostImageParts[-4:])
refresh()
def getPosition(self, agentState):
if agentState.configuration == None: return (-1000, -1000)
if agentState.configuration == None:
return (-1000, -1000)
return agentState.getPosition()
def getDirection(self, agentState):
if agentState.configuration == None: return Directions.STOP
if agentState.configuration == None:
return Directions.STOP
return agentState.configuration.getDirection()
def finish(self):
@@ -431,8 +455,10 @@ class PacmanGraphics:
def drawWalls(self, wallMatrix):
wallColor = WALL_COLOR
for xNum, x in enumerate(wallMatrix):
if self.capture and (xNum * 2) < wallMatrix.width: wallColor = TEAM_COLORS[0]
if self.capture and (xNum * 2) >= wallMatrix.width: wallColor = TEAM_COLORS[1]
if self.capture and (xNum * 2) < wallMatrix.width:
wallColor = TEAM_COLORS[0]
if self.capture and (xNum * 2) >= wallMatrix.width:
wallColor = TEAM_COLORS[1]
for yNum, cell in enumerate(x):
if cell: # There's a wall here
@@ -453,66 +479,90 @@ class PacmanGraphics:
# NE quadrant
if (not nIsWall) and (not eIsWall):
# inner circle
circle(screen2, WALL_RADIUS * self.gridSize, wallColor, wallColor, (0,91), 'arc')
circle(screen2, WALL_RADIUS * self.gridSize,
wallColor, wallColor, (0, 91), 'arc')
if (nIsWall) and (not eIsWall):
# vertical line
line(add(screen, (self.gridSize*WALL_RADIUS, 0)), add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(-0.5)-1)), wallColor)
line(add(screen, (self.gridSize*WALL_RADIUS, 0)), add(screen,
(self.gridSize*WALL_RADIUS, self.gridSize*(-0.5)-1)), wallColor)
if (not nIsWall) and (eIsWall):
# horizontal line
line(add(screen, (0, self.gridSize*(-1)*WALL_RADIUS)), add(screen, (self.gridSize*0.5+1, self.gridSize*(-1)*WALL_RADIUS)), wallColor)
line(add(screen, (0, self.gridSize*(-1)*WALL_RADIUS)), add(screen,
(self.gridSize*0.5+1, self.gridSize*(-1)*WALL_RADIUS)), wallColor)
if (nIsWall) and (eIsWall) and (not neIsWall):
# outer circle
circle(add(screen2, (self.gridSize*2*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS)), WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (180,271), 'arc')
line(add(screen, (self.gridSize*2*WALL_RADIUS-1, self.gridSize*(-1)*WALL_RADIUS)), add(screen, (self.gridSize*0.5+1, self.gridSize*(-1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS+1)), add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(-0.5))), wallColor)
circle(add(screen2, (self.gridSize*2*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS)),
WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (180, 271), 'arc')
line(add(screen, (self.gridSize*2*WALL_RADIUS-1, self.gridSize*(-1)*WALL_RADIUS)),
add(screen, (self.gridSize*0.5+1, self.gridSize*(-1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS+1)),
add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(-0.5))), wallColor)
# NW quadrant
if (not nIsWall) and (not wIsWall):
# inner circle
circle(screen2, WALL_RADIUS * self.gridSize, wallColor, wallColor, (90,181), 'arc')
circle(screen2, WALL_RADIUS * self.gridSize,
wallColor, wallColor, (90, 181), 'arc')
if (nIsWall) and (not wIsWall):
# vertical line
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, 0)), add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(-0.5)-1)), wallColor)
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, 0)), add(screen,
(self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(-0.5)-1)), wallColor)
if (not nIsWall) and (wIsWall):
# horizontal line
line(add(screen, (0, self.gridSize*(-1)*WALL_RADIUS)), add(screen, (self.gridSize*(-0.5)-1, self.gridSize*(-1)*WALL_RADIUS)), wallColor)
line(add(screen, (0, self.gridSize*(-1)*WALL_RADIUS)), add(screen,
(self.gridSize*(-0.5)-1, self.gridSize*(-1)*WALL_RADIUS)), wallColor)
if (nIsWall) and (wIsWall) and (not nwIsWall):
# outer circle
circle(add(screen2, (self.gridSize*(-2)*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS)), WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (270,361), 'arc')
line(add(screen, (self.gridSize*(-2)*WALL_RADIUS+1, self.gridSize*(-1)*WALL_RADIUS)), add(screen, (self.gridSize*(-0.5), self.gridSize*(-1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS+1)), add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(-0.5))), wallColor)
circle(add(screen2, (self.gridSize*(-2)*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS)),
WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (270, 361), 'arc')
line(add(screen, (self.gridSize*(-2)*WALL_RADIUS+1, self.gridSize*(-1)*WALL_RADIUS)),
add(screen, (self.gridSize*(-0.5), self.gridSize*(-1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(-2)*WALL_RADIUS+1)),
add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(-0.5))), wallColor)
# SE quadrant
if (not sIsWall) and (not eIsWall):
# inner circle
circle(screen2, WALL_RADIUS * self.gridSize, wallColor, wallColor, (270,361), 'arc')
circle(screen2, WALL_RADIUS * self.gridSize,
wallColor, wallColor, (270, 361), 'arc')
if (sIsWall) and (not eIsWall):
# vertical line
line(add(screen, (self.gridSize*WALL_RADIUS, 0)), add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(0.5)+1)), wallColor)
line(add(screen, (self.gridSize*WALL_RADIUS, 0)), add(screen,
(self.gridSize*WALL_RADIUS, self.gridSize*(0.5)+1)), wallColor)
if (not sIsWall) and (eIsWall):
# horizontal line
line(add(screen, (0, self.gridSize*(1)*WALL_RADIUS)), add(screen, (self.gridSize*0.5+1, self.gridSize*(1)*WALL_RADIUS)), wallColor)
line(add(screen, (0, self.gridSize*(1)*WALL_RADIUS)), add(screen,
(self.gridSize*0.5+1, self.gridSize*(1)*WALL_RADIUS)), wallColor)
if (sIsWall) and (eIsWall) and (not seIsWall):
# outer circle
circle(add(screen2, (self.gridSize*2*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS)), WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (90,181), 'arc')
line(add(screen, (self.gridSize*2*WALL_RADIUS-1, self.gridSize*(1)*WALL_RADIUS)), add(screen, (self.gridSize*0.5, self.gridSize*(1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS-1)), add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(0.5))), wallColor)
circle(add(screen2, (self.gridSize*2*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS)),
WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (90, 181), 'arc')
line(add(screen, (self.gridSize*2*WALL_RADIUS-1, self.gridSize*(1)*WALL_RADIUS)),
add(screen, (self.gridSize*0.5, self.gridSize*(1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS-1)),
add(screen, (self.gridSize*WALL_RADIUS, self.gridSize*(0.5))), wallColor)
# SW quadrant
if (not sIsWall) and (not wIsWall):
# inner circle
circle(screen2, WALL_RADIUS * self.gridSize, wallColor, wallColor, (180,271), 'arc')
circle(screen2, WALL_RADIUS * self.gridSize,
wallColor, wallColor, (180, 271), 'arc')
if (sIsWall) and (not wIsWall):
# vertical line
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, 0)), add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(0.5)+1)), wallColor)
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, 0)), add(screen,
(self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(0.5)+1)), wallColor)
if (not sIsWall) and (wIsWall):
# horizontal line
line(add(screen, (0, self.gridSize*(1)*WALL_RADIUS)), add(screen, (self.gridSize*(-0.5)-1, self.gridSize*(1)*WALL_RADIUS)), wallColor)
line(add(screen, (0, self.gridSize*(1)*WALL_RADIUS)), add(screen,
(self.gridSize*(-0.5)-1, self.gridSize*(1)*WALL_RADIUS)), wallColor)
if (sIsWall) and (wIsWall) and (not swIsWall):
# outer circle
circle(add(screen2, (self.gridSize*(-2)*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS)), WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (0,91), 'arc')
line(add(screen, (self.gridSize*(-2)*WALL_RADIUS+1, self.gridSize*(1)*WALL_RADIUS)), add(screen, (self.gridSize*(-0.5), self.gridSize*(1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS-1)), add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(0.5))), wallColor)
circle(add(screen2, (self.gridSize*(-2)*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS)),
WALL_RADIUS * self.gridSize-1, wallColor, wallColor, (0, 91), 'arc')
line(add(screen, (self.gridSize*(-2)*WALL_RADIUS+1, self.gridSize*(1)*WALL_RADIUS)),
add(screen, (self.gridSize*(-0.5), self.gridSize*(1)*WALL_RADIUS)), wallColor)
line(add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(2)*WALL_RADIUS-1)),
add(screen, (self.gridSize*(-1)*WALL_RADIUS, self.gridSize*(0.5))), wallColor)
def isWall(self, x, y, walls):
if x < 0 or y < 0:
@@ -525,8 +575,10 @@ class PacmanGraphics:
foodImages = []
color = FOOD_COLOR
for xNum, x in enumerate(foodMatrix):
if self.capture and (xNum * 2) <= foodMatrix.width: color = TEAM_COLORS[0]
if self.capture and (xNum * 2) > foodMatrix.width: color = TEAM_COLORS[1]
if self.capture and (xNum * 2) <= foodMatrix.width:
color = TEAM_COLORS[0]
if self.capture and (xNum * 2) > foodMatrix.width:
color = TEAM_COLORS[1]
imageRow = []
foodImages.append(imageRow)
for yNum, cell in enumerate(x):
@@ -571,7 +623,8 @@ class PacmanGraphics:
self.expandedCells = []
for k, cell in enumerate(cells):
screenPos = self.to_screen(cell)
cellColor = formatColor(*[(n-k) * c * .5 / n + .25 for c in baseColor])
cellColor = formatColor(
*[(n-k) * c * .5 / n + .25 for c in baseColor])
block = square(screenPos,
0.5 * self.gridSize,
color=cellColor,
@@ -585,11 +638,10 @@ class PacmanGraphics:
for cell in self.expandedCells:
remove_from_screen(cell)
def updateDistributions(self, distributions):
"Draws an agent's belief distributions"
# copy all distributions so we don't change their state
distributions = map(lambda x: x.copy(), distributions)
distributions = [x.copy() for x in distributions]
if self.distributionImages == None:
self.drawDistributions(self.previousState)
for x in range(len(self.distributionImages)):
@@ -602,12 +654,15 @@ class PacmanGraphics:
# Fog of war
color = [0.0, 0.0, 0.0]
colors = GHOST_VEC_COLORS[1:] # With Pacman
if self.capture: colors = GHOST_VEC_COLORS
if self.capture:
colors = GHOST_VEC_COLORS
for weight, gcolor in zip(weights, colors):
color = [min(1.0, c + 0.95 * g * weight ** .3) for c,g in zip(color, gcolor)]
color = [min(1.0, c + 0.95 * g * weight ** .3)
for c, g in zip(color, gcolor)]
changeColor(image, formatColor(*color))
refresh()
class FirstPersonPacmanGraphics(PacmanGraphics):
def __init__(self, zoom=1.0, showGhosts=True, capture=False, frameTime=0):
PacmanGraphics.__init__(self, zoom, frameTime=frameTime)
@@ -654,6 +709,7 @@ class FirstPersonPacmanGraphics(PacmanGraphics):
else:
return PacmanGraphics.getPosition(self, ghostState)
def add(x, y):
return (x[0] + y[0], x[1] + y[1])
@@ -669,11 +725,14 @@ POSTSCRIPT_OUTPUT_DIR = 'frames'
FRAME_NUMBER = 0
import os
def saveFrame():
"Saves the current graphical output as a postscript file"
global SAVE_POSTSCRIPT, FRAME_NUMBER, POSTSCRIPT_OUTPUT_DIR
if not SAVE_POSTSCRIPT: return
if not os.path.exists(POSTSCRIPT_OUTPUT_DIR): os.mkdir(POSTSCRIPT_OUTPUT_DIR)
if not SAVE_POSTSCRIPT:
return
if not os.path.exists(POSTSCRIPT_OUTPUT_DIR):
os.mkdir(POSTSCRIPT_OUTPUT_DIR)
name = os.path.join(POSTSCRIPT_OUTPUT_DIR, 'frame_%08d.ps' % FRAME_NUMBER)
FRAME_NUMBER += 1
writePostscript(name) # writes the current canvas
graphicsUtils.py
+68 -19
View File
@@ -33,11 +33,14 @@ _canvas_col = None # Current colour (set to black below)
_canvas_tsize = 12
_canvas_tserifs = 0
def formatColor(r, g, b):
return '#%02x%02x%02x' % (int(r * 255), int(g * 255), int(b * 255))
def colorToVector(color):
return list(map(lambda x: int(x, 16) / 256.0, [color[1:3], color[3:5], color[5:7]]))
return [int(x, 16) / 256.0 for x in [color[1:3], color[3:5], color[5:7]]]
if _Windows:
_canvas_tfonts = ['times new roman', 'lucida console']
@@ -45,6 +48,7 @@ else:
_canvas_tfonts = ['times', 'lucidasans-24']
pass # XXX need defaults here
def sleep(secs):
global _root_window
if _root_window == None:
@@ -54,6 +58,7 @@ def sleep(secs):
_root_window.after(int(1000 * secs), _root_window.quit)
_root_window.mainloop()
def begin_graphics(width=640, height=480, color=formatColor(0, 0, 0), title=None):
global _root_window, _canvas, _canvas_x, _canvas_y, _canvas_xs, _canvas_ys, _bg_color
@@ -95,22 +100,27 @@ def begin_graphics(width=640, height=480, color=formatColor(0, 0, 0), title=None
_root_window.bind("<Control-Button-1>", _ctrl_leftclick)
_clear_keys()
_leftclick_loc = None
_rightclick_loc = None
_ctrl_leftclick_loc = None
def _leftclick(event):
global _leftclick_loc
_leftclick_loc = (event.x, event.y)
def _rightclick(event):
global _rightclick_loc
_rightclick_loc = (event.x, event.y)
def _ctrl_leftclick(event):
global _ctrl_leftclick_loc
_ctrl_leftclick_loc = (event.x, event.y)
def wait_for_click():
while True:
global _leftclick_loc
@@ -130,16 +140,21 @@ def wait_for_click():
return val, 'ctrl_left'
sleep(0.05)
def draw_background():
corners = [(0,0), (0, _canvas_ys), (_canvas_xs, _canvas_ys), (_canvas_xs, 0)]
polygon(corners, _bg_color, fillColor=_bg_color, filled=True, smoothed=False)
corners = [(0, 0), (0, _canvas_ys),
(_canvas_xs, _canvas_ys), (_canvas_xs, 0)]
polygon(corners, _bg_color, fillColor=_bg_color,
filled=True, smoothed=False)
def _destroy_window(event=None):
sys.exit(0)
# global _root_window
# _root_window.destroy()
# _root_window = None
#print("DESTROY")
# print "DESTROY"
def end_graphics():
global _root_window, _canvas, _mouse_enabled
@@ -156,30 +171,37 @@ def end_graphics():
_mouse_enabled = 0
_clear_keys()
def clear_screen(background=None):
global _canvas_x, _canvas_y
_canvas.delete('all')
draw_background()
_canvas_x, _canvas_y = 0, _canvas_ys
def polygon(coords, outlineColor, fillColor=None, filled=1, smoothed=1, behind=0, width=1):
c = []
for coord in coords:
c.append(coord[0])
c.append(coord[1])
if fillColor == None: fillColor = outlineColor
if filled == 0: fillColor = ""
poly = _canvas.create_polygon(c, outline=outlineColor, fill=fillColor, smooth=smoothed, width=width)
if fillColor == None:
fillColor = outlineColor
if filled == 0:
fillColor = ""
poly = _canvas.create_polygon(
c, outline=outlineColor, fill=fillColor, smooth=smoothed, width=width)
if behind > 0:
_canvas.tag_lower(poly, behind) # Higher should be more visible
return poly
def square(pos, r, color, filled=1, behind=0):
x, y = pos
coords = [(x - r, y - r), (x + r, y - r), (x + r, y + r), (x - r, y + r)]
return polygon(coords, color, color, filled, 0, behind=behind)
def circle(pos, r, outlineColor, fillColor=None, endpoints=None, style='pieslice', width=2):
def circle(pos, r, outlineColor, fillColor, endpoints=None, style='pieslice', width=2):
x, y = pos
x0, x1 = x - r - 1, x + r
y0, y1 = y - r - 1, y + r
@@ -187,11 +209,13 @@ def circle(pos, r, outlineColor, fillColor=None, endpoints=None, style='pieslice
e = [0, 359]
else:
e = list(endpoints)
while e[0] > e[1]: e[1] = e[1] + 360
while e[0] > e[1]:
e[1] = e[1] + 360
return _canvas.create_arc(x0, y0, x1, y1, outline=outlineColor, fill=fillColor or outlineColor,
return _canvas.create_arc(x0, y0, x1, y1, outline=outlineColor, fill=fillColor,
extent=e[1] - e[0], start=e[0], style=style, width=width)
def image(pos, file="../../blueghost.gif"):
x, y = pos
# img = PhotoImage(file=file)
@@ -201,6 +225,7 @@ def image(pos, file="../../blueghost.gif"):
def refresh():
_canvas.update_idletasks()
def moveCircle(id, pos, r, endpoints=None):
global _canvas_x, _canvas_y
@@ -213,7 +238,8 @@ def moveCircle(id, pos, r, endpoints=None):
e = [0, 359]
else:
e = list(endpoints)
while e[0] > e[1]: e[1] = e[1] + 360
while e[0] > e[1]:
e[1] = e[1] + 360
if os.path.isfile('flag'):
edit(id, ('extent', e[1] - e[0]))
@@ -221,23 +247,28 @@ def moveCircle(id, pos, r, endpoints=None):
edit(id, ('start', e[0]), ('extent', e[1] - e[0]))
move_to(id, x0, y0)
def edit(id, *args):
_canvas.itemconfigure(id, **dict(args))
def text(pos, color, contents, font='Helvetica', size=12, style='normal', anchor="nw"):
global _canvas_x, _canvas_y
x, y = pos
font = (font, str(size), style)
return _canvas.create_text(x, y, fill=color, text=contents, font=font, anchor=anchor)
def changeText(id, newText, font=None, size=12, style='normal'):
_canvas.itemconfigure(id, text=newText)
if font != None:
_canvas.itemconfigure(id, font=(font, '-%d' % size, style))
def changeColor(id, newColor):
_canvas.itemconfigure(id, fill=newColor)
def line(here, there, color=formatColor(0, 0, 0), width=2):
x0, y0 = here[0], here[1]
x1, y1 = there[0], there[1]
@@ -249,20 +280,23 @@ def line(here, there, color=formatColor(0, 0, 0), width=2):
# We bind to key-down and key-up events.
_keysdown = {}
_keyswaiting = {}
# This holds an unprocessed key release. We delay key releases by up to
# one call to keys_pressed() to get round a problem with auto repeat.
_got_release = None
def _keypress(event):
global _got_release
# remap_arrows(event)
_keysdown[event.keysym] = 1
_keyswaiting[event.keysym] = 1
# print(event.char, event.keycode)
# print event.char, event.keycode
_got_release = None
def _keyrelease(event):
global _got_release
# remap_arrows(event)
@@ -272,6 +306,7 @@ def _keyrelease(event):
pass
_got_release = 1
def remap_arrows(event):
# TURN ARROW PRESSES INTO LETTERS (SHOULD BE IN KEYBOARD AGENT)
if event.char in ['a', 's', 'd', 'w']:
@@ -285,27 +320,31 @@ def remap_arrows(event):
if event.keycode in [40, 104]: # DOWN ARROW
event.char = 's'
def _clear_keys(event=None):
global _keysdown, _got_release, _keyswaiting
_keysdown = {}
_keyswaiting = {}
_got_release = None
def keys_pressed(d_o_e=lambda arg: _root_window.dooneevent(arg),
d_w=tkinter._tkinter.DONT_WAIT):
d_o_e(d_w)
if _got_release:
d_o_e(d_w)
return _keysdown.keys()
return list(_keysdown.keys())
def keys_waiting():
global _keyswaiting
keys = _keyswaiting.keys()
keys = list(_keyswaiting.keys())
_keyswaiting = {}
return keys
# Block for a list of keys...
def wait_for_keys():
keys = []
while keys == []:
@@ -313,24 +352,29 @@ def wait_for_keys():
sleep(0.05)
return keys
def remove_from_screen(x,
d_o_e=lambda arg: _root_window.dooneevent(arg),
d_w=tkinter._tkinter.DONT_WAIT):
_canvas.delete(x)
d_o_e(d_w)
def _adjust_coords(coord_list, x, y):
for i in range(0, len(coord_list), 2):
coord_list[i] = coord_list[i] + x
coord_list[i + 1] = coord_list[i + 1] + y
return coord_list
def move_to(object, x, y=None,
d_o_e=lambda arg: _root_window.dooneevent(arg),
d_w=tkinter._tkinter.DONT_WAIT):
if y is None:
try: x, y = x
except: raise 'incomprehensible coordinates'
try:
x, y = x
except:
raise Exception('incomprehensible coordinates')
horiz = True
newCoords = []
@@ -347,12 +391,15 @@ def move_to(object, x, y=None,
_canvas.coords(object, *newCoords)
d_o_e(d_w)
def move_by(object, x, y=None,
d_o_e=lambda arg: _root_window.dooneevent(arg),
d_w=tkinter._tkinter.DONT_WAIT, lift=False):
if y is None:
try: x, y = x
except: raise Exception('incomprehensible coordinates')
try:
x, y = x
except:
raise Exception('incomprehensible coordinates')
horiz = True
newCoords = []
@@ -370,14 +417,16 @@ def move_by(object, x, y=None,
if lift:
_canvas.tag_raise(object)
def writePostscript(filename):
"Writes the current canvas to a postscript file."
psfile = open(filename, 'w')
psfile = file(filename, 'w')
psfile.write(_canvas.postscript(pageanchor='sw',
y='0.c',
x='0.c'))
psfile.close()
ghost_shape = [
(0, - 0.5),
(0.25, - 0.75),
keyboardAgents.py
+21 -10
View File
@@ -16,6 +16,7 @@ from game import Agent
from game import Directions
import random
class KeyboardAgent(Agent):
"""
An agent controlled by the keyboard.
@@ -36,7 +37,7 @@ class KeyboardAgent(Agent):
def getAction(self, state):
from graphicsUtils import keys_waiting
from graphicsUtils import keys_pressed
keys = list(keys_waiting()) + list(keys_pressed())
keys = keys_waiting() + keys_pressed()
if keys != []:
self.keys = keys
@@ -48,7 +49,8 @@ class KeyboardAgent(Agent):
if self.lastMove in legal:
move = self.lastMove
if (self.STOP_KEY in self.keys) and Directions.STOP in legal: move = Directions.STOP
if (self.STOP_KEY in self.keys) and Directions.STOP in legal:
move = Directions.STOP
if move not in legal:
move = random.choice(legal)
@@ -58,12 +60,17 @@ class KeyboardAgent(Agent):
def getMove(self, legal):
move = Directions.STOP
if (self.WEST_KEY in self.keys or 'Left' in self.keys) and Directions.WEST in legal: move = Directions.WEST
if (self.EAST_KEY in self.keys or 'Right' in self.keys) and Directions.EAST in legal: move = Directions.EAST
if (self.NORTH_KEY in self.keys or 'Up' in self.keys) and Directions.NORTH in legal: move = Directions.NORTH
if (self.SOUTH_KEY in self.keys or 'Down' in self.keys) and Directions.SOUTH in legal: move = Directions.SOUTH
if (self.WEST_KEY in self.keys or 'Left' in self.keys) and Directions.WEST in legal:
move = Directions.WEST
if (self.EAST_KEY in self.keys or 'Right' in self.keys) and Directions.EAST in legal:
move = Directions.EAST
if (self.NORTH_KEY in self.keys or 'Up' in self.keys) and Directions.NORTH in legal:
move = Directions.NORTH
if (self.SOUTH_KEY in self.keys or 'Down' in self.keys) and Directions.SOUTH in legal:
move = Directions.SOUTH
return move
class KeyboardAgent2(KeyboardAgent):
"""
A second agent controlled by the keyboard.
@@ -77,8 +84,12 @@ class KeyboardAgent2(KeyboardAgent):
def getMove(self, legal):
move = Directions.STOP
if (self.WEST_KEY in self.keys) and Directions.WEST in legal: move = Directions.WEST
if (self.EAST_KEY in self.keys) and Directions.EAST in legal: move = Directions.EAST
if (self.NORTH_KEY in self.keys) and Directions.NORTH in legal: move = Directions.NORTH
if (self.SOUTH_KEY in self.keys) and Directions.SOUTH in legal: move = Directions.SOUTH
if (self.WEST_KEY in self.keys) and Directions.WEST in legal:
move = Directions.WEST
if (self.EAST_KEY in self.keys) and Directions.EAST in legal:
move = Directions.EAST
if (self.NORTH_KEY in self.keys) and Directions.NORTH in legal:
move = Directions.NORTH
if (self.SOUTH_KEY in self.keys) and Directions.SOUTH in legal:
move = Directions.SOUTH
return move
layout.py
+28 -14
View File
@@ -20,6 +20,7 @@ from functools import reduce
VISIBILITY_MATRIX_CACHE = {}
class Layout:
"""
A Layout manages the static information about the game board.
@@ -46,8 +47,10 @@ class Layout:
if reduce(str.__add__, self.layoutText) not in VISIBILITY_MATRIX_CACHE:
from game import Directions
vecs = [(-0.5, 0), (0.5, 0), (0, -0.5), (0, 0.5)]
dirs = [Directions.NORTH, Directions.SOUTH, Directions.WEST, Directions.EAST]
vis = Grid(self.width, self.height, {Directions.NORTH:set(), Directions.SOUTH:set(), Directions.EAST:set(), Directions.WEST:set(), Directions.STOP:set()})
dirs = [Directions.NORTH, Directions.SOUTH,
Directions.WEST, Directions.EAST]
vis = Grid(self.width, self.height, {Directions.NORTH: set(), Directions.SOUTH: set(
), Directions.EAST: set(), Directions.WEST: set(), Directions.STOP: set()})
for x in range(self.width):
for y in range(self.height):
if self.walls[x][y] == False:
@@ -60,26 +63,29 @@ class Layout:
self.visibility = vis
VISIBILITY_MATRIX_CACHE[reduce(str.__add__, self.layoutText)] = vis
else:
self.visibility = VISIBILITY_MATRIX_CACHE[reduce(str.__add__, self.layoutText)]
self.visibility = VISIBILITY_MATRIX_CACHE[reduce(
str.__add__, self.layoutText)]
def isWall(self, pos):
x, col = pos
return self.walls[x][col]
def getRandomLegalPosition(self):
x = random.choice(range(self.width))
y = random.choice(range(self.height))
x = random.choice(list(range(self.width)))
y = random.choice(list(range(self.height)))
while self.isWall((x, y)):
x = random.choice(range(self.width))
y = random.choice(range(self.height))
x = random.choice(list(range(self.width)))
y = random.choice(list(range(self.height)))
return (x, y)
def getRandomCorner(self):
poses = [(1,1), (1, self.height - 2), (self.width - 2, 1), (self.width - 2, self.height - 2)]
poses = [(1, 1), (1, self.height - 2), (self.width - 2, 1),
(self.width - 2, self.height - 2)]
return random.choice(poses)
def getFurthestCorner(self, pacPos):
poses = [(1,1), (1, self.height - 2), (self.width - 2, 1), (self.width - 2, self.height - 2)]
poses = [(1, 1), (1, self.height - 2), (self.width - 2, 1),
(self.width - 2, self.height - 2)]
dist, pos = max([(manhattanDistance(p, pacPos), p) for p in poses])
return pos
@@ -129,13 +135,17 @@ class Layout:
elif layoutChar in ['1', '2', '3', '4']:
self.agentPositions.append((int(layoutChar), (x, y)))
self.numGhosts += 1
def getLayout(name, back=2):
if name.endswith('.lay'):
layout = tryToLoad('layouts/' + name)
if layout == None: layout = tryToLoad(name)
if layout == None:
layout = tryToLoad(name)
else:
layout = tryToLoad('layouts/' + name + '.lay')
if layout == None: layout = tryToLoad(name + '.lay')
if layout == None:
layout = tryToLoad(name + '.lay')
if layout == None and back >= 0:
curdir = os.path.abspath('.')
os.chdir('..')
@@ -143,8 +153,12 @@ def getLayout(name, back = 2):
os.chdir(curdir)
return layout
def tryToLoad(fullname):
if(not os.path.exists(fullname)): return None
if(not os.path.exists(fullname)):
return None
f = open(fullname)
try: return Layout([line.strip() for line in f])
finally: f.close()
try:
return Layout([line.strip() for line in f])
finally:
f.close()
layouts/bigCorners.lay
-37
View File
@@ -1,37 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%. % %.%
% %%%%% % %%% %%% %%%%%%% % %
% % % % % % % %
%%%%% %%%%% %%% % % % %%% %%%%% % %%%
% % % % % % % % % % % % %
% %%% % % % %%% %%%%% %%% % %%% %%% %
% % % % % % % % %
%%% %%%%%%%%% %%%%%%% %%% %%% % % % %
% % % % % % %
% % %%%%% % %%% % % %%% % %%% %%% % %
% % % % % % % % % % % % % %
% % % %%%%%%% % %%%%%%%%% %%% % %%% %
% % % % % % % % % %
%%% %%% % %%%%% %%%%% %%% %%% %%%%% %
% % % % % % % % %
% % % % % % %%% %%% %%% % % % % % %
% % % % % %% % % % % % % % % %
% % %%%%% % %%% %%% % %%% %%% %%%%%
% % % % % % % % % % %
% %%% % % % %%% %%% %%%%%%%%% % %%%
% % % % % % %
% %%% %%%%%%%%%%%%%%%%%%%%% % % %%% %
% % % %
% % % %%%%% %%% % % % % %%%%%%%%%%%%%
% % % % % % % % % % % %
% % %%% %%% % % % %%%%%%%%% %%% % % %
% % % % % % %P % % % % % %
% %%% %%% %%% % %%% % % %%%%% % %%%%%
% % % % % % % %
%%% % %%%%% %%%%% %%% %%% % %%% % %%%
% % % % % % % % % % % % % % %
% % %%% % % % % %%%%%%%%% % % % % % %
% % % %
% % % %%% %%% %%%%%%% %%% %%% %%% %
%.% % % % % .%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/bigMaze.lay
-37
View File
@@ -1,37 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% % % % % % % %
% %%%%%%% % %%% % %%% %%% %%%%%%% % %
% % % % % % % %
%%%%% %%%%% %%% % % % %%% %%%%% % %%%
% % % % % % % % % % % % % %
% %%% % % % %%% %%%%% %%% % %%% %%% %
% % % % % % % % %
%%% %%%%%%%%% %%%%%%% %%% %%% % % % %
% % % % % % %
% % %%%%% % %%% % % %%% % %%% %%% % %
% % % % % % % % % % % % % %
% % % %%%%%%% % %%%%%%%%% %%% % %%% %
% % % % % % % % % %
%%% %%% % %%%%% %%%%% %%% %%% %%%%% %
% % % % % % % % % % % %
% % % % % %%% %%% %%% %%% % % % % % %
% % % % % % % % %
%%% %%%%%%% % % %%%%% %%% % %%% %%%%%
% % % % % % % % % %
%%%%% % % %%%%%%%%% %%%%%%%%%%% % %%%
% % % % % % % % %
% %%% %%%%% %%%%%%%%% %%%%% % % %%% %
% % % % % % %
% % % %%%%% %%% % % % % %%%%%%%%%%%%%
% % % % % % % % % % % %
% % %%% %%% % % % %%%%%%%%% %%% % % %
% % % % % % % % % % % % %
% %%% %%% %%%%% %%% % % %%%%% % %%%%%
% % % % % % % % %
%%% % %%%%% %%%%% %%% %%% % %%% % %%%
% % % % % % % % % % % % % % %
% % %%% % % % % %%%%%%%%% % % % % % %
% % % % % %
% % % % %%% %%% %%%%%%% %%% %%% %%% %
%.% % % % % % % % P%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/bigSafeSearch.lay
-8
View File
@@ -1,8 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%.%.........%% G % o%%%%.....%
%.%.%%%%%%%.%%%%%% %%%%%%%.%%.%
%............%...%............%
%%%%%...%%%.. ..%.%...%.%%%
%o%%%.%%%%%.%%%%%%%.%%%.%.%%%%%
% ..........Po...%...%. o%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/bigSearch.lay
-15
View File
@@ -1,15 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%.....%.................%.....%
%.%%%.%.%%%.%%%%%%%.%%%.%.....%
%.%...%.%......%......%.%.....%
%...%%%.%.%%%%.%.%%%%...%%%...%
%%%.%.%.%.%......%..%.%...%.%%%
%...%.%%%.%.%%% %%%.%.%%%.%...%
%.%%%.......% %.......%%%.%
%...%.%%%%%.%%%%%%%.%.%%%.%...%
%%%.%...%.%....%....%.%...%.%%%
%...%%%.%.%%%%.%.%%%%.%.%%%...%
%.......%......%......%.....%.%
%.....%.%%%.%%%%%%%.%%%.%.%%%.%
%.....%........P....%...%.....%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/boxSearch.lay
-14
View File
@@ -1,14 +0,0 @@
%%%%%%%%%%%%%%
%. . . . . % %
% % %
%. . . . . %G%
% % %
%. . . . . % %
% % %
%. . . . . % %
% P %G%
%. . . . . % %
% % %
%. . . . . % %
% % %
%%%%%%%%%%%%%%
layouts/contoursMaze.lay
-11
View File
@@ -1,11 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% %
% P %
% %
% %
% %
%. %
%%%%%%%%%%%%%%%%%%%%%
layouts/greedySearch.lay
-8
View File
@@ -1,8 +0,0 @@
%%%%%%
%....%
% %%.%
% %%.%
%.P .%
%.%%%%
%....%
%%%%%%
layouts/mediumCorners.lay
-14
View File
@@ -1,14 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%. % % % %.%
% % % %%%%%% %%%%%%% % %
% % % % % %
%%%%% %%%%% %%% %% %%%%% % %%%
% % % % % % % % %
% %%% % % % %%%%%%%% %%% %%% %
% % %% % % % %
%%% % %%%%%%% %%%% %%% % % % %
% % %% % % %
% % %%%%% % %%%% % %%% %%% % %
% % % % % % %%% %
%. %P%%%%% % %%% % .%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/mediumDottedMaze.lay
-18
View File
@@ -1,18 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% P%
% %%%%%%%%%%%%%%%%%%% %%% %%%%%%%% %
% %% % % %%% %%% %% ... %
% %% % % % % %%%% %%%%%%%%% %% %%%%%
% %% % % % % % %% %% %% ... %
% %% % % % % % %%%% %%% %%%%%% %
% % % % % % %% %%%%%%%% ... %
% %% % % %%%%%%%% %% %% %%%%%
% %% % %% %%%%%%%%% %% ... %
% %%%%%% %%%%%%% %% %%%%%% %
%%%%%% % %%%% %% % ... %
% %%%%%% %%%%% % %% %% %%%%%
% %%%%%% % %%%%% %% %
% %%%%%% %%%%%%%%%%% %% %% %
%%%%%%%%%% %%%%%% %
%. %%%%%%%%%%%%%%%% ...... %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/mediumMaze.lay
-18
View File
@@ -1,18 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% P%
% %%%%%%%%%%%%%%%%%%%%%%% %%%%%%%% %
% %% % % %%%%%%% %% %
% %% % % % % %%%% %%%%%%%%% %% %%%%%
% %% % % % % %% %% %
% %% % % % % % %%%% %%% %%%%%% %
% % % % % % %% %%%%%%%% %
% %% % % %%%%%%%% %% %% %%%%%
% %% % %% %%%%%%%%% %% %
% %%%%%% %%%%%%% %% %%%%%% %
%%%%%% % %%%% %% % %
% %%%%%% %%%%% % %% %% %%%%%
% %%%%%% % %%%%% %% %
% %%%%%% %%%%%%%%%%% %% %% %
%%%%%%%%%% %%%%%% %
%. %%%%%%%%%%%%%%%% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/mediumSafeSearch.lay
-6
View File
@@ -1,6 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%.% ....%% G %%%%%% o%%.%
%.%o%%%%%%%.%%%%%%% %%%%%.%
% %%%.%%%%%.%%%%%%%.%%%.%.%%%.%
% ..........Po...%.........%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/mediumScaryMaze.lay
-18
View File
@@ -1,18 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% P%
% %%%%%%%%%%%%%%%%%%% %%% %%%%%%%% %
% %% % % %%% %%% %%GG %
% %% % % % % %%%% %%%%%%%%% %% %%%%%
% %% % % % % % %%GG %% %
% %% % % % % % %%%%% %%% %%%%%% %
% %% % % % % %% %%%%%%%%% %
% %% % % %%%%%%%% %% %% %%%%%
% %% % %% %%%%%%%%% %% %
% %%% %% %%%%%%% %% %%%%%% %
%%%%%% % % %% %% %
% %%%%%% %% %% %% %% %%%%%
% %%%%%% % %%%%% %% %
% %%%% %%%%% %%%%%% %
%%%%%%%% % %%%%%% %
%. %%%%%%%%%%%%%%%% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/mediumSearch.lay
-8
View File
@@ -1,8 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%............%%%%%............%
%%%.%...%%%.........%.%...%.%%%
%...%%%.%.%%%%.%.%%%%%%.%%%...%
%.%.....%......%......%.....%.%
%.%%%.%%%%%.%%%%%%%.%%%.%.%%%%%
%.....%........P....%...%.....%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/oddSearch.lay
-7
View File
@@ -1,7 +0,0 @@
%%%%%%%%%%%%%%%%%%%%
%...%.........%%...%
%.%.%.%%%%%%%%%%.%.%
%..................%
%%%%%%%%.%.%%%%%%%P%
%%%%%%%%....... %
%%%%%%%%%%%%%%%%%%%%
layouts/openMaze.lay
-23
View File
@@ -1,23 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% P%
% % %
% % %
% % %
% % %
% % %
% % % %
% % % %
% % % %
% % % %
% % % %
% % % %
% % % %
%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%
% % %
% % %
% % %
% %
% %
% %
%. %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
layouts/openSearch.lay
-7
View File
@@ -1,7 +0,0 @@
%%%%%%%%%%%%%%%%%%%%
%..................%
%..................%
%........P.........%
%..................%
%..................%
%%%%%%%%%%%%%%%%%%%%
layouts/smallMaze.lay
-10
View File
@@ -1,10 +0,0 @@
%%%%%%%%%%%%%%%%%%%%%%
% %% % % %
% %%%%%% % %%%%%% %
%%%%%% P % %
% % %%%%%% %% %%%%%
% %%%% % % %
% %%% %%% % %
%%%%%%%%%% %%%%%% %
%. %% %
%%%%%%%%%%%%%%%%%%%%%%
layouts/smallSafeSearch.lay
-15
View File
@@ -1,15 +0,0 @@
%%%%%%%%%
%.. % G %
%%% %%%%%
% %
%%%%%%% %
% %
% %%%%% %
% % %
%%%%% % %
% %o%
% %%%%%%%
% .%
%%%%%%%.%
%Po .%
%%%%%%%%%
layouts/smallSearch.lay
-5
View File
@@ -1,5 +0,0 @@
%%%%%%%%%%%%%%%%%%%%
%. ...P .%
%.%%.%%.%%.%%.%% %.%
% %% %..... %.%
%%%%%%%%%%%%%%%%%%%%
layouts/testMaze.lay
-3
View File
@@ -1,3 +0,0 @@
%%%%%%%%%%
%. P%
%%%%%%%%%%
layouts/testSearch.lay
-5
View File
@@ -1,5 +0,0 @@
%%%%%
%.P %
%%% %
%. %
%%%%%
layouts/tinyCorners.lay
-8
View File
@@ -1,8 +0,0 @@
%%%%%%%%
%. .%
% P %
% %%%% %
% % %
% % %%%%
%.% .%
%%%%%%%%
layouts/tinyMaze.lay
-7
View File
@@ -1,7 +0,0 @@
%%%%%%%
% P%
% %%% %
% % %
%% %%
%. %%%%
%%%%%%%
layouts/tinySafeSearch.lay
-7
View File
@@ -1,7 +0,0 @@
%%%%%%%%%
% G %...%
%%%%%%% %
%Po %
%.%%.%%.%
%.%%....%
%%%%%%%%%
layouts/tinySearch.lay
-7
View File
@@ -1,7 +0,0 @@
%%%%%%%%%
%.. ..%
%%%%.%% %
% P %
%.%% %%.%
%.%. .%
%%%%%%%%%
layouts/trickySearch.lay
-7
View File
@@ -1,7 +0,0 @@
%%%%%%%%%%%%%%%%%%%%
%. ..% %
%.%%.%%.%%.%%.%% % %
% P % %
%%%%%%%%%%%%%%%%%% %
%..... %
%%%%%%%%%%%%%%%%%%%%
multiAgents.py
+178
View File
@@ -0,0 +1,178 @@
# 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
"Add more of your code here if you want to"
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)
successorGameState = currentGameState.generatePacmanSuccessor(action)
newPos = successorGameState.getPacmanPosition()
newFood = successorGameState.getFood()
newGhostStates = successorGameState.getGhostStates()
newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
"*** YOUR CODE HERE ***"
return successorGameState.getScore()
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
gameState.isWin():
Returns whether or not the game state is a winning state
gameState.isLose():
Returns whether or not the game state is a losing state
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
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
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
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.
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
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>
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
# Abbreviation
better = betterEvaluationFunction
multiagentTestClasses.py
+578
View File
@@ -0,0 +1,578 @@
# multiagentTestClasses.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).
# A minimax tree which interfaces like gameState
# state.getNumAgents()
# state.isWin()
# state.isLose()
# state.generateSuccessor(agentIndex, action)
# state.getScore()
# used by multiAgents.scoreEvaluationFunction, which is the default
#
import testClasses
import json
from collections import defaultdict
from pprint import PrettyPrinter
pp = PrettyPrinter()
from game import Agent
from pacman import GameState
from ghostAgents import RandomGhost, DirectionalGhost
import random
import math
import traceback
import sys
import os
import layout
import pacman
import autograder
# import grading
VERBOSE = False
class MultiagentTreeState(object):
def __init__(self, problem, state):
self.problem = problem
self.state = state
def generateSuccessor(self, agentIndex, action):
if VERBOSE:
print("generateSuccessor(%s, %s, %s) -> %s" % (self.state, agentIndex,
action, self.problem.stateToSuccessorMap[self.state][action]))
successor = self.problem.stateToSuccessorMap[self.state][action]
self.problem.generatedStates.add(successor)
return MultiagentTreeState(self.problem, successor)
def getScore(self):
if VERBOSE:
print("getScore(%s) -> %s" %
(self.state, self.problem.evaluation[self.state]))
if self.state not in self.problem.evaluation:
raise Exception(
'getScore() called on non-terminal state or before maximum depth achieved.')
return float(self.problem.evaluation[self.state])
def getLegalActions(self, agentIndex=0):
if VERBOSE:
print("getLegalActions(%s) -> %s" %
(self.state, self.problem.stateToActions[self.state]))
# if len(self.problem.stateToActions[self.state]) == 0:
# print "WARNING: getLegalActions called on leaf state %s" % (self.state,)
return list(self.problem.stateToActions[self.state])
def isWin(self):
if VERBOSE:
print("isWin(%s) -> %s" %
(self.state, self.state in self.problem.winStates))
return self.state in self.problem.winStates
def isLose(self):
if VERBOSE:
print("isLose(%s) -> %s" %
(self.state, self.state in self.problem.loseStates))
return self.state in self.problem.loseStates
def getNumAgents(self):
if VERBOSE:
print("getNumAgents(%s) -> %s" %
(self.state, self.problem.numAgents))
return self.problem.numAgents
class MultiagentTreeProblem(object):
def __init__(self, numAgents, startState, winStates, loseStates, successors, evaluation):
self.startState = MultiagentTreeState(self, startState)
self.numAgents = numAgents
self.winStates = winStates
self.loseStates = loseStates
self.evaluation = evaluation
self.successors = successors
self.reset()
self.stateToSuccessorMap = defaultdict(dict)
self.stateToActions = defaultdict(list)
for state, action, nextState in successors:
self.stateToActions[state].append(action)
self.stateToSuccessorMap[state][action] = nextState
def reset(self):
self.generatedStates = set([self.startState.state])
def parseTreeProblem(testDict):
numAgents = int(testDict["num_agents"])
startState = testDict["start_state"]
winStates = set(testDict["win_states"].split(" "))
loseStates = set(testDict["lose_states"].split(" "))
successors = []
evaluation = {}
for line in testDict["evaluation"].split('\n'):
tokens = line.split()
if len(tokens) == 2:
state, value = tokens
evaluation[state] = float(value)
else:
raise Exception("[parseTree] Bad evaluation line: |%s|" % (line,))
for line in testDict["successors"].split('\n'):
tokens = line.split()
if len(tokens) == 3:
state, action, nextState = tokens
successors.append((state, action, nextState))
else:
raise Exception("[parseTree] Bad successor line: |%s|" % (line,))
return MultiagentTreeProblem(numAgents, startState, winStates, loseStates, successors, evaluation)
def run(lay, layName, pac, ghosts, disp, nGames=1, name='games'):
"""
Runs a few games and outputs their statistics.
"""
starttime = time.time()
print('*** Running %s on' % name, layName, '%d time(s).' % nGames)
games = pacman.runGames(lay, pac, ghosts, disp,
nGames, False, catchExceptions=True, timeout=120)
print('*** Finished running %s on' % name, layName,
'after %d seconds.' % (time.time() - starttime))
stats = {'time': time.time() - starttime, 'wins': [g.state.isWin() for g in games].count(True), 'games': games, 'scores': [g.state.getScore() for g in games],
'timeouts': [g.agentTimeout for g in games].count(True), 'crashes': [g.agentCrashed for g in games].count(True)}
print('*** Won %d out of %d games. Average score: %f ***' %
(stats['wins'], len(games), sum(stats['scores']) * 1.0 / len(games)))
return stats
class GradingAgent(Agent):
def __init__(self, seed, studentAgent, optimalActions, altDepthActions, partialPlyBugActions):
# save student agent and actions of refernce agents
self.studentAgent = studentAgent
self.optimalActions = optimalActions
self.altDepthActions = altDepthActions
self.partialPlyBugActions = partialPlyBugActions
# create fields for storing specific wrong actions
self.suboptimalMoves = []
self.wrongStatesExplored = -1
# boolean vectors represent types of implementation the student could have
self.actionsConsistentWithOptimal = [
True for i in range(len(optimalActions[0]))]
self.actionsConsistentWithAlternativeDepth = [
True for i in range(len(altDepthActions[0]))]
self.actionsConsistentWithPartialPlyBug = [
True for i in range(len(partialPlyBugActions[0]))]
# keep track of elapsed moves
self.stepCount = 0
self.seed = seed
def registerInitialState(self, state):
if 'registerInitialState' in dir(self.studentAgent):
self.studentAgent.registerInitialState(state)
random.seed(self.seed)
def getAction(self, state):
GameState.getAndResetExplored()
studentAction = (self.studentAgent.getAction(state),
len(GameState.getAndResetExplored()))
optimalActions = self.optimalActions[self.stepCount]
altDepthActions = self.altDepthActions[self.stepCount]
partialPlyBugActions = self.partialPlyBugActions[self.stepCount]
studentOptimalAction = False
curRightStatesExplored = False
for i in range(len(optimalActions)):
if studentAction[0] in optimalActions[i][0]:
studentOptimalAction = True
else:
self.actionsConsistentWithOptimal[i] = False
if studentAction[1] == int(optimalActions[i][1]):
curRightStatesExplored = True
if not curRightStatesExplored and self.wrongStatesExplored < 0:
self.wrongStatesExplored = 1
for i in range(len(altDepthActions)):
if studentAction[0] not in altDepthActions[i]:
self.actionsConsistentWithAlternativeDepth[i] = False
for i in range(len(partialPlyBugActions)):
if studentAction[0] not in partialPlyBugActions[i]:
self.actionsConsistentWithPartialPlyBug[i] = False
if not studentOptimalAction:
self.suboptimalMoves.append(
(state, studentAction[0], optimalActions[0][0][0]))
self.stepCount += 1
random.seed(self.seed + self.stepCount)
return optimalActions[0][0][0]
def getSuboptimalMoves(self):
return self.suboptimalMoves
def getWrongStatesExplored(self):
return self.wrongStatesExplored
def checkFailure(self):
"""
Return +n if have n suboptimal moves.
Return -1 if have only off by one depth moves.
Return 0 otherwise.
"""
if self.wrongStatesExplored > 0:
return -3
if self.actionsConsistentWithOptimal.count(True) > 0:
return 0
elif self.actionsConsistentWithPartialPlyBug.count(True) > 0:
return -2
elif self.actionsConsistentWithAlternativeDepth.count(True) > 0:
return -1
else:
return len(self.suboptimalMoves)
class PolyAgent(Agent):
def __init__(self, seed, multiAgents, ourPacOptions, depth):
# prepare our pacman agents
solutionAgents, alternativeDepthAgents, partialPlyBugAgents = self.construct_our_pacs(
multiAgents, ourPacOptions)
for p in solutionAgents:
p.depth = depth
for p in partialPlyBugAgents:
p.depth = depth
for p in alternativeDepthAgents[:2]:
p.depth = max(1, depth - 1)
for p in alternativeDepthAgents[2:]:
p.depth = depth + 1
self.solutionAgents = solutionAgents
self.alternativeDepthAgents = alternativeDepthAgents
self.partialPlyBugAgents = partialPlyBugAgents
# prepare fields for storing the results
self.optimalActionLists = []
self.alternativeDepthLists = []
self.partialPlyBugLists = []
self.seed = seed
self.stepCount = 0
def select(self, list, indices):
"""
Return a sublist of elements given by indices in list.
"""
return [list[i] for i in indices]
def construct_our_pacs(self, multiAgents, keyword_dict):
pacs_without_stop = [multiAgents.StaffMultiAgentSearchAgent(
**keyword_dict) for i in range(3)]
keyword_dict['keepStop'] = 'True'
pacs_with_stop = [multiAgents.StaffMultiAgentSearchAgent(
**keyword_dict) for i in range(3)]
keyword_dict['usePartialPlyBug'] = 'True'
partial_ply_bug_pacs = [
multiAgents.StaffMultiAgentSearchAgent(**keyword_dict)]
keyword_dict['keepStop'] = 'False'
partial_ply_bug_pacs = partial_ply_bug_pacs + \
[multiAgents.StaffMultiAgentSearchAgent(**keyword_dict)]
for pac in pacs_with_stop + pacs_without_stop + partial_ply_bug_pacs:
pac.verbose = False
ourpac = [pacs_with_stop[0], pacs_without_stop[0]]
alternative_depth_pacs = self.select(
pacs_with_stop + pacs_without_stop, [1, 4, 2, 5])
return (ourpac, alternative_depth_pacs, partial_ply_bug_pacs)
def registerInitialState(self, state):
for agent in self.solutionAgents + self.alternativeDepthAgents:
if 'registerInitialState' in dir(agent):
agent.registerInitialState(state)
random.seed(self.seed)
def getAction(self, state):
# survey agents
GameState.getAndResetExplored()
optimalActionLists = []
for agent in self.solutionAgents:
optimalActionLists.append((agent.getBestPacmanActions(
state)[0], len(GameState.getAndResetExplored())))
alternativeDepthLists = [agent.getBestPacmanActions(
state)[0] for agent in self.alternativeDepthAgents]
partialPlyBugLists = [agent.getBestPacmanActions(
state)[0] for agent in self.partialPlyBugAgents]
# record responses
self.optimalActionLists.append(optimalActionLists)
self.alternativeDepthLists.append(alternativeDepthLists)
self.partialPlyBugLists.append(partialPlyBugLists)
self.stepCount += 1
random.seed(self.seed + self.stepCount)
return optimalActionLists[0][0][0]
def getTraces(self):
# return traces from individual agents
return (self.optimalActionLists, self.alternativeDepthLists, self.partialPlyBugLists)
class PacmanGameTreeTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(PacmanGameTreeTest, self).__init__(question, testDict)
self.seed = int(self.testDict['seed'])
self.alg = self.testDict['alg']
self.layout_text = self.testDict['layout']
self.layout_name = self.testDict['layoutName']
self.depth = int(self.testDict['depth'])
self.max_points = int(self.testDict['max_points'])
def execute(self, grades, moduleDict, solutionDict):
# load student code and staff code solutions
multiAgents = moduleDict['multiAgents']
studentAgent = getattr(multiAgents, self.alg)(depth=self.depth)
allActions = [json.loads(x)
for x in solutionDict['optimalActions'].split('\n')]
altDepthActions = [json.loads(
x) for x in solutionDict['altDepthActions'].split('\n')]
partialPlyBugActions = [json.loads(
x) for x in solutionDict['partialPlyBugActions'].split('\n')]
# set up game state and play a game
random.seed(self.seed)
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
pac = GradingAgent(self.seed, studentAgent, allActions,
altDepthActions, partialPlyBugActions)
# check return codes and assign grades
disp = self.question.getDisplay()
stats = run(lay, self.layout_name, pac, [DirectionalGhost(
i + 1) for i in range(2)], disp, name=self.alg)
if stats['timeouts'] > 0:
self.addMessage('Agent timed out on smallClassic. No credit')
return self.testFail(grades)
if stats['crashes'] > 0:
self.addMessage('Agent crashed on smallClassic. No credit')
return self.testFail(grades)
code = pac.checkFailure()
if code == 0:
return self.testPass(grades)
elif code == -3:
if pac.getWrongStatesExplored() >= 0:
self.addMessage('Bug: Wrong number of states expanded.')
return self.testFail(grades)
else:
return self.testPass(grades)
elif code == -2:
self.addMessage('Bug: Partial Ply Bug')
return self.testFail(grades)
elif code == -1:
self.addMessage('Bug: Search depth off by 1')
return self.testFail(grades)
elif code > 0:
moves = pac.getSuboptimalMoves()
state, studentMove, optMove = random.choice(moves)
self.addMessage('Bug: Suboptimal moves')
self.addMessage('State:%s\nStudent Move:%s\nOptimal Move:%s' % (
state, studentMove, optMove))
return self.testFail(grades)
def writeList(self, handle, name, list):
handle.write('%s: """\n' % name)
for l in list:
handle.write('%s\n' % json.dumps(l))
handle.write('"""\n')
def writeSolution(self, moduleDict, filePath):
# load module, set seed, create ghosts and macman, run game
multiAgents = moduleDict['multiAgents']
random.seed(self.seed)
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
if self.alg == 'ExpectimaxAgent':
ourPacOptions = {'expectimax': 'True'}
elif self.alg == 'AlphaBetaAgent':
ourPacOptions = {'alphabeta': 'True'}
else:
ourPacOptions = {}
pac = PolyAgent(self.seed, multiAgents, ourPacOptions, self.depth)
disp = self.question.getDisplay()
run(lay, self.layout_name, pac, [DirectionalGhost(
i + 1) for i in range(2)], disp, name=self.alg)
(optimalActions, altDepthActions, partialPlyBugActions) = pac.getTraces()
# recover traces and record to file
handle = open(filePath, 'w')
self.writeList(handle, 'optimalActions', optimalActions)
self.writeList(handle, 'altDepthActions', altDepthActions)
self.writeList(handle, 'partialPlyBugActions', partialPlyBugActions)
handle.close()
class GraphGameTreeTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(GraphGameTreeTest, self).__init__(question, testDict)
self.problem = parseTreeProblem(testDict)
self.alg = self.testDict['alg']
self.diagram = self.testDict['diagram'].split('\n')
self.depth = int(self.testDict['depth'])
def solveProblem(self, multiAgents):
self.problem.reset()
studentAgent = getattr(multiAgents, self.alg)(depth=self.depth)
action = studentAgent.getAction(self.problem.startState)
generated = self.problem.generatedStates
return action, " ".join([str(s) for s in sorted(generated)])
def addDiagram(self):
self.addMessage('Tree:')
for line in self.diagram:
self.addMessage(line)
def execute(self, grades, moduleDict, solutionDict):
multiAgents = moduleDict['multiAgents']
goldAction = solutionDict['action']
goldGenerated = solutionDict['generated']
action, generated = self.solveProblem(multiAgents)
fail = False
if action != goldAction:
self.addMessage('Incorrect move for depth=%s' % (self.depth,))
self.addMessage(
' Student move: %s\n Optimal move: %s' % (action, goldAction))
fail = True
if generated != goldGenerated:
self.addMessage(
'Incorrect generated nodes for depth=%s' % (self.depth,))
self.addMessage(' Student generated nodes: %s\n Correct generated nodes: %s' % (
generated, goldGenerated))
fail = True
if fail:
self.addDiagram()
return self.testFail(grades)
else:
return self.testPass(grades)
def writeSolution(self, moduleDict, filePath):
multiAgents = moduleDict['multiAgents']
action, generated = self.solveProblem(multiAgents)
with open(filePath, 'w') as handle:
handle.write('# This is the solution file for %s.\n' % self.path)
handle.write('action: "%s"\n' % (action,))
handle.write('generated: "%s"\n' % (generated,))
return True
import time
from util import TimeoutFunction
class EvalAgentTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(EvalAgentTest, self).__init__(question, testDict)
self.layoutName = testDict['layoutName']
self.agentName = testDict['agentName']
self.ghosts = eval(testDict['ghosts'])
self.maxTime = int(testDict['maxTime'])
self.seed = int(testDict['randomSeed'])
self.numGames = int(testDict['numGames'])
self.scoreMinimum = int(
testDict['scoreMinimum']) if 'scoreMinimum' in testDict else None
self.nonTimeoutMinimum = int(
testDict['nonTimeoutMinimum']) if 'nonTimeoutMinimum' in testDict else None
self.winsMinimum = int(
testDict['winsMinimum']) if 'winsMinimum' in testDict else None
self.scoreThresholds = [int(s) for s in testDict.get(
'scoreThresholds', '').split()]
self.nonTimeoutThresholds = [int(s) for s in testDict.get(
'nonTimeoutThresholds', '').split()]
self.winsThresholds = [int(s) for s in testDict.get(
'winsThresholds', '').split()]
self.maxPoints = sum([len(t) for t in [
self.scoreThresholds, self.nonTimeoutThresholds, self.winsThresholds]])
self.agentArgs = testDict.get('agentArgs', '')
def execute(self, grades, moduleDict, solutionDict):
startTime = time.time()
agentType = getattr(moduleDict['multiAgents'], self.agentName)
agentOpts = pacman.parseAgentArgs(
self.agentArgs) if self.agentArgs != '' else {}
agent = agentType(**agentOpts)
lay = layout.getLayout(self.layoutName, 3)
disp = self.question.getDisplay()
random.seed(self.seed)
games = pacman.runGames(lay, agent, self.ghosts, disp, self.numGames,
False, catchExceptions=True, timeout=self.maxTime)
totalTime = time.time() - startTime
stats = {'time': totalTime, 'wins': [g.state.isWin() for g in games].count(True),
'games': games, 'scores': [g.state.getScore() for g in games],
'timeouts': [g.agentTimeout for g in games].count(True), 'crashes': [g.agentCrashed for g in games].count(True)}
averageScore = sum(stats['scores']) / float(len(stats['scores']))
nonTimeouts = self.numGames - stats['timeouts']
wins = stats['wins']
def gradeThreshold(value, minimum, thresholds, name):
points = 0
passed = (minimum == None) or (value >= minimum)
if passed:
for t in thresholds:
if value >= t:
points += 1
return (passed, points, value, minimum, thresholds, name)
results = [gradeThreshold(averageScore, self.scoreMinimum, self.scoreThresholds, "average score"),
gradeThreshold(nonTimeouts, self.nonTimeoutMinimum,
self.nonTimeoutThresholds, "games not timed out"),
gradeThreshold(wins, self.winsMinimum, self.winsThresholds, "wins")]
totalPoints = 0
for passed, points, value, minimum, thresholds, name in results:
if minimum == None and len(thresholds) == 0:
continue
# print passed, points, value, minimum, thresholds, name
totalPoints += points
if not passed:
assert points == 0
self.addMessage(
"%s %s (fail: below minimum value %s)" % (value, name, minimum))
else:
self.addMessage("%s %s (%s of %s points)" %
(value, name, points, len(thresholds)))
if minimum != None:
self.addMessage(" Grading scheme:")
self.addMessage(" < %s: fail" % (minimum,))
if len(thresholds) == 0 or minimum != thresholds[0]:
self.addMessage(" >= %s: 0 points" % (minimum,))
for idx, threshold in enumerate(thresholds):
self.addMessage(" >= %s: %s points" %
(threshold, idx+1))
elif len(thresholds) > 0:
self.addMessage(" Grading scheme:")
self.addMessage(" < %s: 0 points" % (thresholds[0],))
for idx, threshold in enumerate(thresholds):
self.addMessage(" >= %s: %s points" %
(threshold, idx+1))
if any([not passed for passed, _, _, _, _, _ in results]):
totalPoints = 0
return self.testPartial(grades, totalPoints, self.maxPoints)
def writeSolution(self, moduleDict, filePath):
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
handle.write('# File intentionally blank.\n')
handle.close()
return True
pacman.py
+92 -38
View File
@@ -45,13 +45,19 @@ from game import Directions
from game import Actions
from util import nearestPoint
from util import manhattanDistance
import util, layout
import sys, types, time, random, os
import util
import layout
import sys
import types
import time
import random
import os
###################################################
# YOUR INTERFACE TO THE PACMAN WORLD: A GameState #
###################################################
class GameState:
"""
A GameState specifies the full game state, including the food, capsules,
@@ -73,6 +79,7 @@ class GameState:
# static variable keeps track of which states have had getLegalActions called
explored = set()
def getAndResetExplored():
tmp = GameState.explored.copy()
GameState.explored = set()
@@ -84,7 +91,8 @@ class GameState:
Returns the legal actions for the agent specified.
"""
# GameState.explored.add(self)
if self.isWin() or self.isLose(): return []
if self.isWin() or self.isLose():
return []
if agentIndex == 0: # Pacman is moving
return PacmanRules.getLegalActions(self)
@@ -96,7 +104,8 @@ class GameState:
Returns the successor state after the specified agent takes the action.
"""
# Check that successors exist
if self.isWin() or self.isLose(): raise Exception('Can\'t generate a successor of a terminal state.')
if self.isWin() or self.isLose():
raise Exception('Can\'t generate a successor of a terminal state.')
# Copy current state
state = GameState(self)
@@ -259,15 +268,18 @@ class GameState:
# You shouldn't need to look through the code in this section of the file. #
############################################################################
SCARED_TIME = 40 # Moves ghosts are scared
COLLISION_TOLERANCE = 0.7 # How close ghosts must be to Pacman to kill
TIME_PENALTY = 1 # Number of points lost each round
class ClassicGameRules:
"""
These game rules manage the control flow of a game, deciding when
and how the game starts and ends.
"""
def __init__(self, timeout=30):
self.timeout = timeout
@@ -285,15 +297,19 @@ class ClassicGameRules:
"""
Checks to see whether it is time to end the game.
"""
if state.isWin(): self.win(state, game)
if state.isLose(): self.lose(state, game)
if state.isWin():
self.win(state, game)
if state.isLose():
self.lose(state, game)
def win(self, state, game):
if not self.quiet: print("Pacman emerges victorious! Score: %d" % state.data.score)
if not self.quiet:
print("Pacman emerges victorious! Score: %d" % state.data.score)
game.gameOver = True
def lose(self, state, game):
if not self.quiet: print("Pacman died! Score: %d" % state.data.score)
if not self.quiet:
print("Pacman died! Score: %d" % state.data.score)
game.gameOver = True
def getProgress(self, game):
@@ -320,6 +336,7 @@ class ClassicGameRules:
def getMaxTimeWarnings(self, agentIndex):
return 0
class PacmanRules:
"""
These functions govern how pacman interacts with his environment under
@@ -346,7 +363,8 @@ class PacmanRules:
# Update Configuration
vector = Actions.directionToVector(action, PacmanRules.PACMAN_SPEED)
pacmanState.configuration = pacmanState.configuration.generateSuccessor( vector )
pacmanState.configuration = pacmanState.configuration.generateSuccessor(
vector)
# Eat
next = pacmanState.configuration.getPosition()
@@ -378,18 +396,21 @@ class PacmanRules:
state.data.agentStates[index].scaredTimer = SCARED_TIME
consume = staticmethod(consume)
class GhostRules:
"""
These functions dictate how ghosts interact with their environment.
"""
GHOST_SPEED = 1.0
def getLegalActions(state, ghostIndex):
"""
Ghosts cannot stop, and cannot turn around unless they
reach a dead end, but can turn 90 degrees at intersections.
"""
conf = state.getGhostState(ghostIndex).configuration
possibleActions = Actions.getPossibleActions( conf, state.data.layout.walls )
possibleActions = Actions.getPossibleActions(
conf, state.data.layout.walls)
reverse = Actions.reverseDirection(conf.direction)
if Directions.STOP in possibleActions:
possibleActions.remove(Directions.STOP)
@@ -406,15 +427,18 @@ class GhostRules:
ghostState = state.data.agentStates[ghostIndex]
speed = GhostRules.GHOST_SPEED
if ghostState.scaredTimer > 0: speed /= 2.0
if ghostState.scaredTimer > 0:
speed /= 2.0
vector = Actions.directionToVector(action, speed)
ghostState.configuration = ghostState.configuration.generateSuccessor( vector )
ghostState.configuration = ghostState.configuration.generateSuccessor(
vector)
applyAction = staticmethod(applyAction)
def decrementTimer(ghostState):
timer = ghostState.scaredTimer
if timer == 1:
ghostState.configuration.pos = nearestPoint( ghostState.configuration.pos )
ghostState.configuration.pos = nearestPoint(
ghostState.configuration.pos)
ghostState.scaredTimer = max(0, timer - 1)
decrementTimer = staticmethod(decrementTimer)
@@ -458,11 +482,14 @@ class GhostRules:
# FRAMEWORK TO START A GAME #
#############################
def default(str):
return str + ' [Default: %default]'
def parseAgentArgs(str):
if str == None: return {}
if str == None:
return {}
pieces = str.split(',')
opts = {}
for p in pieces:
@@ -473,6 +500,7 @@ def parseAgentArgs(str):
opts[key] = val
return opts
def readCommand(argv):
"""
Processes the command used to run pacman from the command line.
@@ -491,17 +519,20 @@ def readCommand( argv ):
parser.add_option('-n', '--numGames', dest='numGames', type='int',
help=default('the number of GAMES to play'), metavar='GAMES', default=1)
parser.add_option('-l', '--layout', dest='layout',
help=default('the LAYOUT_FILE from which to load the map layout'),
help=default(
'the LAYOUT_FILE from which to load the map layout'),
metavar='LAYOUT_FILE', default='mediumClassic')
parser.add_option('-p', '--pacman', dest='pacman',
help=default('the agent TYPE in the pacmanAgents module to use'),
help=default(
'the agent TYPE in the pacmanAgents module to use'),
metavar='TYPE', default='KeyboardAgent')
parser.add_option('-t', '--textGraphics', action='store_true', dest='textGraphics',
help='Display output as text only', default=False)
parser.add_option('-q', '--quietTextGraphics', action='store_true', dest='quietGraphics',
help='Generate minimal output and no graphics', default=False)
parser.add_option('-g', '--ghosts', dest='ghost',
help=default('the ghost agent TYPE in the ghostAgents module to use'),
help=default(
'the ghost agent TYPE in the ghostAgents module to use'),
metavar='TYPE', default='RandomGhost')
parser.add_option('-k', '--numghosts', type='int', dest='numGhosts',
help=default('The maximum number of ghosts to use'), default=4)
@@ -530,19 +561,23 @@ def readCommand( argv ):
args = dict()
# Fix the random seed
if options.fixRandomSeed: random.seed('cs188')
if options.fixRandomSeed:
random.seed('cs188')
# Choose a layout
args['layout'] = layout.getLayout(options.layout)
if args['layout'] == None: raise Exception("The layout " + options.layout + " cannot be found")
if args['layout'] == None:
raise Exception("The layout " + options.layout + " cannot be found")
# Choose a Pacman agent
noKeyboard = options.gameToReplay == None and (options.textGraphics or options.quietGraphics)
noKeyboard = options.gameToReplay == None and (
options.textGraphics or options.quietGraphics)
pacmanType = loadAgent(options.pacman, noKeyboard)
agentOpts = parseAgentArgs(options.agentArgs)
if options.numTraining > 0:
args['numTraining'] = options.numTraining
if 'numTraining' not in agentOpts: agentOpts['numTraining'] = options.numTraining
if 'numTraining' not in agentOpts:
agentOpts['numTraining'] = options.numTraining
pacman = pacmanType(**agentOpts) # Instantiate Pacman with agentArgs
args['pacman'] = pacman
@@ -565,7 +600,8 @@ def readCommand( argv ):
args['display'] = textDisplay.PacmanGraphics()
else:
import graphicsDisplay
args['display'] = graphicsDisplay.PacmanGraphics(options.zoom, frameTime = options.frameTime)
args['display'] = graphicsDisplay.PacmanGraphics(
options.zoom, frameTime=options.frameTime)
args['numGames'] = options.numGames
args['record'] = options.record
args['catchExceptions'] = options.catchExceptions
@@ -575,15 +611,18 @@ def readCommand( argv ):
if options.gameToReplay != None:
print('Replaying recorded game %s.' % options.gameToReplay)
import pickle
f = open(options.gameToReplay, 'rb')
try: recorded = pickle.load(f)
finally: f.close()
f = open(options.gameToReplay)
try:
recorded = pickle.load(f)
finally:
f.close()
recorded['display'] = args['display']
replayGame(**recorded)
sys.exit(0)
return args
def loadAgent(pacman, nographics):
# Looks through all pythonPath Directories for the right module,
pythonPathStr = os.path.expandvars("$PYTHONPATH")
@@ -594,8 +633,10 @@ def loadAgent(pacman, nographics):
pythonPathDirs.append('.')
for moduleDir in pythonPathDirs:
if not os.path.isdir(moduleDir): continue
moduleNames = [f for f in os.listdir(moduleDir) if f.endswith('gents.py')]
if not os.path.isdir(moduleDir):
continue
moduleNames = [f for f in os.listdir(
moduleDir) if f.endswith('gents.py')]
for modulename in moduleNames:
try:
module = __import__(modulename[:-3])
@@ -603,14 +644,19 @@ def loadAgent(pacman, nographics):
continue
if pacman in dir(module):
if nographics and modulename == 'keyboardAgents.py':
raise Exception('Using the keyboard requires graphics (not text display)')
raise Exception(
'Using the keyboard requires graphics (not text display)')
return getattr(module, pacman)
raise Exception('The agent ' + pacman + ' is not specified in any *Agents.py.')
raise Exception('The agent ' + pacman +
' is not specified in any *Agents.py.')
def replayGame(layout, actions, display):
import pacmanAgents, ghostAgents
import pacmanAgents
import ghostAgents
rules = ClassicGameRules()
agents = [pacmanAgents.GreedyAgent()] + [ghostAgents.RandomGhost(i+1) for i in range(layout.getNumGhosts())]
agents = [pacmanAgents.GreedyAgent()] + [ghostAgents.RandomGhost(i+1)
for i in range(layout.getNumGhosts())]
game = rules.newGame(layout, agents[0], agents[1:], display)
state = game.state
display.initialize(state.data)
@@ -625,6 +671,7 @@ def replayGame( layout, actions, display ):
display.finish()
def runGames(layout, pacman, ghosts, display, numGames, record, numTraining=0, catchExceptions=False, timeout=30):
import __main__
__main__.__dict__['_display'] = display
@@ -642,14 +689,18 @@ def runGames( layout, pacman, ghosts, display, numGames, record, numTraining = 0
else:
gameDisplay = display
rules.quiet = False
game = rules.newGame( layout, pacman, ghosts, gameDisplay, beQuiet, catchExceptions)
game = rules.newGame(layout, pacman, ghosts,
gameDisplay, beQuiet, catchExceptions)
game.run()
if not beQuiet: games.append(game)
if not beQuiet:
games.append(game)
if record:
import time, pickle
fname = ('recorded-game-%d' % (i + 1)) + '-'.join([str(t) for t in time.localtime()[1:6]])
f = open(fname, 'wb')
import time
import pickle
fname = ('recorded-game-%d' % (i + 1)) + \
'-'.join([str(t) for t in time.localtime()[1:6]])
f = file(fname, 'w')
components = {'layout': layout, 'actions': game.moveHistory}
pickle.dump(components, f)
f.close()
@@ -660,11 +711,14 @@ def runGames( layout, pacman, ghosts, display, numGames, record, numTraining = 0
winRate = wins.count(True) / float(len(wins))
print('Average Score:', sum(scores) / float(len(scores)))
print('Scores: ', ', '.join([str(score) for score in scores]))
print('Win Rate: %d/%d (%.2f)' % (wins.count(True), len(wins), winRate))
print('Record: ', ', '.join([ ['Loss', 'Win'][int(w)] for w in wins]))
print('Win Rate: %d/%d (%.2f)' %
(wins.count(True), len(wins), winRate))
print('Record: ', ', '.join(
[['Loss', 'Win'][int(w)] for w in wins]))
return games
if __name__ == '__main__':
"""
The main function called when pacman.py is run
pacmanAgents.py
+19 -8
View File
@@ -18,20 +18,27 @@ import random
import game
import util
class LeftTurnAgent(game.Agent):
"An agent that turns left at every opportunity"
def getAction(self, state):
legal = state.getLegalPacmanActions()
current = state.getPacmanState().configuration.direction
if current == Directions.STOP: current = Directions.NORTH
if current == Directions.STOP:
current = Directions.NORTH
left = Directions.LEFT[current]
if left in legal: return left
if current in legal: return current
if Directions.RIGHT[current] in legal: return Directions.RIGHT[current]
if Directions.LEFT[left] in legal: return Directions.LEFT[left]
if left in legal:
return left
if current in legal:
return current
if Directions.RIGHT[current] in legal:
return Directions.RIGHT[current]
if Directions.LEFT[left] in legal:
return Directions.LEFT[left]
return Directions.STOP
class GreedyAgent(Agent):
def __init__(self, evalFn="scoreEvaluation"):
self.evaluationFunction = util.lookup(evalFn, globals())
@@ -40,13 +47,17 @@ class GreedyAgent(Agent):
def getAction(self, state):
# Generate candidate actions
legal = state.getLegalPacmanActions()
if Directions.STOP in legal: legal.remove(Directions.STOP)
if Directions.STOP in legal:
legal.remove(Directions.STOP)
successors = [(state.generateSuccessor(0, action), action) for action in legal]
scored = [(self.evaluationFunction(state), action) for state, action in successors]
successors = [(state.generateSuccessor(0, action), action)
for action in legal]
scored = [(self.evaluationFunction(state), action)
for state, action in successors]
bestScore = max(scored)[0]
bestActions = [pair[1] for pair in scored if pair[0] == bestScore]
return random.choice(bestActions)
def scoreEvaluation(state):
return state.getScore()
projectParams.py
+3 -3
View File
@@ -12,7 +12,7 @@
# Pieter Abbeel (pabbeel@cs.berkeley.edu).
STUDENT_CODE_DEFAULT = 'searchAgents.py,search.py'
PROJECT_TEST_CLASSES = 'searchTestClasses.py'
PROJECT_NAME = 'Project 1: Search'
STUDENT_CODE_DEFAULT = 'multiAgents.py'
PROJECT_TEST_CLASSES = 'multiagentTestClasses.py'
PROJECT_NAME = 'Project 2: Multiagent search'
BONUS_PIC = False
search.py
-119
View File
@@ -1,119 +0,0 @@
# search.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).
"""
In search.py, you will implement generic search algorithms which are called by
Pacman agents (in searchAgents.py).
"""
import util
class SearchProblem:
"""
This class outlines the structure of a search problem, but doesn't implement
any of the methods (in object-oriented terminology: an abstract class).
You do not need to change anything in this class, ever.
"""
def getStartState(self):
"""
Returns the start state for the search problem.
"""
util.raiseNotDefined()
def isGoalState(self, state):
"""
state: Search state
Returns True if and only if the state is a valid goal state.
"""
util.raiseNotDefined()
def getSuccessors(self, state):
"""
state: Search state
For a given state, this should return a list of triples, (successor,
action, stepCost), where 'successor' is a successor to the current
state, 'action' is the action required to get there, and 'stepCost' is
the incremental cost of expanding to that successor.
"""
util.raiseNotDefined()
def getCostOfActions(self, actions):
"""
actions: A list of actions to take
This method returns the total cost of a particular sequence of actions.
The sequence must be composed of legal moves.
"""
util.raiseNotDefined()
def tinyMazeSearch(problem):
"""
Returns a sequence of moves that solves tinyMaze. For any other maze, the
sequence of moves will be incorrect, so only use this for tinyMaze.
"""
from game import Directions
s = Directions.SOUTH
w = Directions.WEST
return [s, s, w, s, w, w, s, w]
def depthFirstSearch(problem):
"""
Search the deepest nodes in the search tree first.
Your search algorithm needs to return a list of actions that reaches the
goal. Make sure to implement a graph search algorithm.
To get started, you might want to try some of these simple commands to
understand the search problem that is being passed in:
print("Start:", problem.getStartState())
print("Is the start a goal?", problem.isGoalState(problem.getStartState()))
print("Start's successors:", problem.getSuccessors(problem.getStartState()))
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
def breadthFirstSearch(problem):
"""Search the shallowest nodes in the search tree first."""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
def uniformCostSearch(problem):
"""Search the node of least total cost first."""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
def nullHeuristic(state, problem=None):
"""
A heuristic function estimates the cost from the current state to the nearest
goal in the provided SearchProblem. This heuristic is trivial.
"""
return 0
def aStarSearch(problem, heuristic=nullHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
# Abbreviations
bfs = breadthFirstSearch
dfs = depthFirstSearch
astar = aStarSearch
ucs = uniformCostSearch
searchAgents.py
-542
View File
@@ -1,542 +0,0 @@
# searchAgents.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).
"""
This file contains all of the agents that can be selected to control Pacman. To
select an agent, use the '-p' option when running pacman.py. Arguments can be
passed to your agent using '-a'. For example, to load a SearchAgent that uses
depth first search (dfs), run the following command:
> python pacman.py -p SearchAgent -a fn=depthFirstSearch
Commands to invoke other search strategies can be found in the project
description.
Please only change the parts of the file you are asked to. Look for the lines
that say
"*** YOUR CODE HERE ***"
The parts you fill in start about 3/4 of the way down. Follow the project
description for details.
Good luck and happy searching!
"""
from game import Directions
from game import Agent
from game import Actions
import util
import time
import search
class GoWestAgent(Agent):
"An agent that goes West until it can't."
def getAction(self, state):
"The agent receives a GameState (defined in pacman.py)."
if Directions.WEST in state.getLegalPacmanActions():
return Directions.WEST
else:
return Directions.STOP
#######################################################
# This portion is written for you, but will only work #
# after you fill in parts of search.py #
#######################################################
class SearchAgent(Agent):
"""
This very general search agent finds a path using a supplied search
algorithm for a supplied search problem, then returns actions to follow that
path.
As a default, this agent runs DFS on a PositionSearchProblem to find
location (1,1)
Options for fn include:
depthFirstSearch or dfs
breadthFirstSearch or bfs
Note: You should NOT change any code in SearchAgent
"""
def __init__(self, fn='depthFirstSearch', prob='PositionSearchProblem', heuristic='nullHeuristic'):
# Warning: some advanced Python magic is employed below to find the right functions and problems
# Get the search function from the name and heuristic
if fn not in dir(search):
raise AttributeError(fn + ' is not a search function in search.py.')
func = getattr(search, fn)
if 'heuristic' not in func.__code__.co_varnames:
print('[SearchAgent] using function ' + fn)
self.searchFunction = func
else:
if heuristic in globals().keys():
heur = globals()[heuristic]
elif heuristic in dir(search):
heur = getattr(search, heuristic)
else:
raise AttributeError(heuristic + ' is not a function in searchAgents.py or search.py.')
print('[SearchAgent] using function %s and heuristic %s' % (fn, heuristic))
# Note: this bit of Python trickery combines the search algorithm and the heuristic
self.searchFunction = lambda x: func(x, heuristic=heur)
# Get the search problem type from the name
if prob not in globals().keys() or not prob.endswith('Problem'):
raise AttributeError(prob + ' is not a search problem type in SearchAgents.py.')
self.searchType = globals()[prob]
print('[SearchAgent] using problem type ' + prob)
def registerInitialState(self, state):
"""
This is the first time that the agent sees the layout of the game
board. Here, we choose a path to the goal. In this phase, the agent
should compute the path to the goal and store it in a local variable.
All of the work is done in this method!
state: a GameState object (pacman.py)
"""
if self.searchFunction == None: raise Exception("No search function provided for SearchAgent")
starttime = time.time()
problem = self.searchType(state) # Makes a new search problem
self.actions = self.searchFunction(problem) # Find a path
totalCost = problem.getCostOfActions(self.actions)
print('Path found with total cost of %d in %.1f seconds' % (totalCost, time.time() - starttime))
if '_expanded' in dir(problem): print('Search nodes expanded: %d' % problem._expanded)
def getAction(self, state):
"""
Returns the next action in the path chosen earlier (in
registerInitialState). Return Directions.STOP if there is no further
action to take.
state: a GameState object (pacman.py)
"""
if 'actionIndex' not in dir(self): self.actionIndex = 0
i = self.actionIndex
self.actionIndex += 1
if i < len(self.actions):
return self.actions[i]
else:
return Directions.STOP
class PositionSearchProblem(search.SearchProblem):
"""
A search problem defines the state space, start state, goal test, successor
function and cost function. This search problem can be used to find paths
to a particular point on the pacman board.
The state space consists of (x,y) positions in a pacman game.
Note: this search problem is fully specified; you should NOT change it.
"""
def __init__(self, gameState, costFn = lambda x: 1, goal=(1,1), start=None, warn=True, visualize=True):
"""
Stores the start and goal.
gameState: A GameState object (pacman.py)
costFn: A function from a search state (tuple) to a non-negative number
goal: A position in the gameState
"""
self.walls = gameState.getWalls()
self.startState = gameState.getPacmanPosition()
if start != None: self.startState = start
self.goal = goal
self.costFn = costFn
self.visualize = visualize
if warn and (gameState.getNumFood() != 1 or not gameState.hasFood(*goal)):
print('Warning: this does not look like a regular search maze')
# For display purposes
self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
def getStartState(self):
return self.startState
def isGoalState(self, state):
isGoal = state == self.goal
# For display purposes only
if isGoal and self.visualize:
self._visitedlist.append(state)
import __main__
if '_display' in dir(__main__):
if 'drawExpandedCells' in dir(__main__._display): #@UndefinedVariable
__main__._display.drawExpandedCells(self._visitedlist) #@UndefinedVariable
return isGoal
def getSuccessors(self, state):
"""
Returns successor states, the actions they require, and a cost of 1.
As noted in search.py:
For a given state, this should return a list of triples,
(successor, action, stepCost), where 'successor' is a
successor to the current state, 'action' is the action
required to get there, and 'stepCost' is the incremental
cost of expanding to that successor
"""
successors = []
for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
x,y = state
dx, dy = Actions.directionToVector(action)
nextx, nexty = int(x + dx), int(y + dy)
if not self.walls[nextx][nexty]:
nextState = (nextx, nexty)
cost = self.costFn(nextState)
successors.append( ( nextState, action, cost) )
# Bookkeeping for display purposes
self._expanded += 1 # DO NOT CHANGE
if state not in self._visited:
self._visited[state] = True
self._visitedlist.append(state)
return successors
def getCostOfActions(self, actions):
"""
Returns the cost of a particular sequence of actions. If those actions
include an illegal move, return 999999.
"""
if actions == None: return 999999
x,y= self.getStartState()
cost = 0
for action in actions:
# Check figure out the next state and see whether its' legal
dx, dy = Actions.directionToVector(action)
x, y = int(x + dx), int(y + dy)
if self.walls[x][y]: return 999999
cost += self.costFn((x,y))
return cost
class StayEastSearchAgent(SearchAgent):
"""
An agent for position search with a cost function that penalizes being in
positions on the West side of the board.
The cost function for stepping into a position (x,y) is 1/2^x.
"""
def __init__(self):
self.searchFunction = search.uniformCostSearch
costFn = lambda pos: .5 ** pos[0]
self.searchType = lambda state: PositionSearchProblem(state, costFn, (1, 1), None, False)
class StayWestSearchAgent(SearchAgent):
"""
An agent for position search with a cost function that penalizes being in
positions on the East side of the board.
The cost function for stepping into a position (x,y) is 2^x.
"""
def __init__(self):
self.searchFunction = search.uniformCostSearch
costFn = lambda pos: 2 ** pos[0]
self.searchType = lambda state: PositionSearchProblem(state, costFn)
def manhattanHeuristic(position, problem, info={}):
"The Manhattan distance heuristic for a PositionSearchProblem"
xy1 = position
xy2 = problem.goal
return abs(xy1[0] - xy2[0]) + abs(xy1[1] - xy2[1])
def euclideanHeuristic(position, problem, info={}):
"The Euclidean distance heuristic for a PositionSearchProblem"
xy1 = position
xy2 = problem.goal
return ( (xy1[0] - xy2[0]) ** 2 + (xy1[1] - xy2[1]) ** 2 ) ** 0.5
#####################################################
# This portion is incomplete. Time to write code! #
#####################################################
class CornersProblem(search.SearchProblem):
"""
This search problem finds paths through all four corners of a layout.
You must select a suitable state space and successor function
"""
def __init__(self, startingGameState):
"""
Stores the walls, pacman's starting position and corners.
"""
self.walls = startingGameState.getWalls()
self.startingPosition = startingGameState.getPacmanPosition()
top, right = self.walls.height-2, self.walls.width-2
self.corners = ((1,1), (1,top), (right, 1), (right, top))
for corner in self.corners:
if not startingGameState.hasFood(*corner):
print('Warning: no food in corner ' + str(corner))
self._expanded = 0 # DO NOT CHANGE; Number of search nodes expanded
# Please add any code here which you would like to use
# in initializing the problem
"*** YOUR CODE HERE ***"
def getStartState(self):
"""
Returns the start state (in your state space, not the full Pacman state
space)
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
def isGoalState(self, state):
"""
Returns whether this search state is a goal state of the problem.
"""
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
def getSuccessors(self, state):
"""
Returns successor states, the actions they require, and a cost of 1.
As noted in search.py:
For a given state, this should return a list of triples, (successor,
action, stepCost), where 'successor' is a successor to the current
state, 'action' is the action required to get there, and 'stepCost'
is the incremental cost of expanding to that successor
"""
successors = []
for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
# Add a successor state to the successor list if the action is legal
# Here's a code snippet for figuring out whether a new position hits a wall:
# x,y = currentPosition
# dx, dy = Actions.directionToVector(action)
# nextx, nexty = int(x + dx), int(y + dy)
# hitsWall = self.walls[nextx][nexty]
"*** YOUR CODE HERE ***"
self._expanded += 1 # DO NOT CHANGE
return successors
def getCostOfActions(self, actions):
"""
Returns the cost of a particular sequence of actions. If those actions
include an illegal move, return 999999. This is implemented for you.
"""
if actions == None: return 999999
x,y= self.startingPosition
for action in actions:
dx, dy = Actions.directionToVector(action)
x, y = int(x + dx), int(y + dy)
if self.walls[x][y]: return 999999
return len(actions)
def cornersHeuristic(state, problem):
"""
A heuristic for the CornersProblem that you defined.
state: The current search state
(a data structure you chose in your search problem)
problem: The CornersProblem instance for this layout.
This function should always return a number that is a lower bound on the
shortest path from the state to a goal of the problem; i.e. it should be
admissible (as well as consistent).
"""
corners = problem.corners # These are the corner coordinates
walls = problem.walls # These are the walls of the maze, as a Grid (game.py)
"*** YOUR CODE HERE ***"
return 0 # Default to trivial solution
class AStarCornersAgent(SearchAgent):
"A SearchAgent for FoodSearchProblem using A* and your foodHeuristic"
def __init__(self):
self.searchFunction = lambda prob: search.aStarSearch(prob, cornersHeuristic)
self.searchType = CornersProblem
class FoodSearchProblem:
"""
A search problem associated with finding the a path that collects all of the
food (dots) in a Pacman game.
A search state in this problem is a tuple ( pacmanPosition, foodGrid ) where
pacmanPosition: a tuple (x,y) of integers specifying Pacman's position
foodGrid: a Grid (see game.py) of either True or False, specifying remaining food
"""
def __init__(self, startingGameState):
self.start = (startingGameState.getPacmanPosition(), startingGameState.getFood())
self.walls = startingGameState.getWalls()
self.startingGameState = startingGameState
self._expanded = 0 # DO NOT CHANGE
self.heuristicInfo = {} # A dictionary for the heuristic to store information
def getStartState(self):
return self.start
def isGoalState(self, state):
return state[1].count() == 0
def getSuccessors(self, state):
"Returns successor states, the actions they require, and a cost of 1."
successors = []
self._expanded += 1 # DO NOT CHANGE
for direction in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
x,y = state[0]
dx, dy = Actions.directionToVector(direction)
nextx, nexty = int(x + dx), int(y + dy)
if not self.walls[nextx][nexty]:
nextFood = state[1].copy()
nextFood[nextx][nexty] = False
successors.append( ( ((nextx, nexty), nextFood), direction, 1) )
return successors
def getCostOfActions(self, actions):
"""Returns the cost of a particular sequence of actions. If those actions
include an illegal move, return 999999"""
x,y= self.getStartState()[0]
cost = 0
for action in actions:
# figure out the next state and see whether it's legal
dx, dy = Actions.directionToVector(action)
x, y = int(x + dx), int(y + dy)
if self.walls[x][y]:
return 999999
cost += 1
return cost
class AStarFoodSearchAgent(SearchAgent):
"A SearchAgent for FoodSearchProblem using A* and your foodHeuristic"
def __init__(self):
self.searchFunction = lambda prob: search.aStarSearch(prob, foodHeuristic)
self.searchType = FoodSearchProblem
def foodHeuristic(state, problem):
"""
Your heuristic for the FoodSearchProblem goes here.
This heuristic must be consistent to ensure correctness. First, try to come
up with an admissible heuristic; almost all admissible heuristics will be
consistent as well.
If using A* ever finds a solution that is worse uniform cost search finds,
your heuristic is *not* consistent, and probably not admissible! On the
other hand, inadmissible or inconsistent heuristics may find optimal
solutions, so be careful.
The state is a tuple ( pacmanPosition, foodGrid ) where foodGrid is a Grid
(see game.py) of either True or False. You can call foodGrid.asList() to get
a list of food coordinates instead.
If you want access to info like walls, capsules, etc., you can query the
problem. For example, problem.walls gives you a Grid of where the walls
are.
If you want to *store* information to be reused in other calls to the
heuristic, there is a dictionary called problem.heuristicInfo that you can
use. For example, if you only want to count the walls once and store that
value, try: problem.heuristicInfo['wallCount'] = problem.walls.count()
Subsequent calls to this heuristic can access
problem.heuristicInfo['wallCount']
"""
position, foodGrid = state
"*** YOUR CODE HERE ***"
return 0
class ClosestDotSearchAgent(SearchAgent):
"Search for all food using a sequence of searches"
def registerInitialState(self, state):
self.actions = []
currentState = state
while(currentState.getFood().count() > 0):
nextPathSegment = self.findPathToClosestDot(currentState) # The missing piece
self.actions += nextPathSegment
for action in nextPathSegment:
legal = currentState.getLegalActions()
if action not in legal:
t = (str(action), str(currentState))
raise Exception('findPathToClosestDot returned an illegal move: %s!\n%s' % t)
currentState = currentState.generateSuccessor(0, action)
self.actionIndex = 0
print('Path found with cost %d.' % len(self.actions))
def findPathToClosestDot(self, gameState):
"""
Returns a path (a list of actions) to the closest dot, starting from
gameState.
"""
# Here are some useful elements of the startState
startPosition = gameState.getPacmanPosition()
food = gameState.getFood()
walls = gameState.getWalls()
problem = AnyFoodSearchProblem(gameState)
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
class AnyFoodSearchProblem(PositionSearchProblem):
"""
A search problem for finding a path to any food.
This search problem is just like the PositionSearchProblem, but has a
different goal test, which you need to fill in below. The state space and
successor function do not need to be changed.
The class definition above, AnyFoodSearchProblem(PositionSearchProblem),
inherits the methods of the PositionSearchProblem.
You can use this search problem to help you fill in the findPathToClosestDot
method.
"""
def __init__(self, gameState):
"Stores information from the gameState. You don't need to change this."
# Store the food for later reference
self.food = gameState.getFood()
# Store info for the PositionSearchProblem (no need to change this)
self.walls = gameState.getWalls()
self.startState = gameState.getPacmanPosition()
self.costFn = lambda x: 1
self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
def isGoalState(self, state):
"""
The state is Pacman's position. Fill this in with a goal test that will
complete the problem definition.
"""
x,y = state
"*** YOUR CODE HERE ***"
util.raiseNotDefined()
def mazeDistance(point1, point2, gameState):
"""
Returns the maze distance between any two points, using the search functions
you have already built. The gameState can be any game state -- Pacman's
position in that state is ignored.
Example usage: mazeDistance( (2,4), (5,6), gameState)
This might be a useful helper function for your ApproximateSearchAgent.
"""
x1, y1 = point1
x2, y2 = point2
walls = gameState.getWalls()
assert not walls[x1][y1], 'point1 is a wall: ' + str(point1)
assert not walls[x2][y2], 'point2 is a wall: ' + str(point2)
prob = PositionSearchProblem(gameState, start=point1, goal=point2, warn=False, visualize=False)
return len(search.bfs(prob))
searchTestClasses.py
-823
View File
@@ -1,823 +0,0 @@
# searchTestClasses.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).
import sys
import re
import testClasses
import textwrap
# import project specific code
import layout
import pacman
from search import SearchProblem
# helper function for printing solutions in solution files
def wrap_solution(solution):
if type(solution) == type([]):
return '\n'.join(textwrap.wrap(' '.join(solution)))
else:
return str(solution)
def followAction(state, action, problem):
for successor1, action1, cost1 in problem.getSuccessors(state):
if action == action1: return successor1
return None
def followPath(path, problem):
state = problem.getStartState()
states = [state]
for action in path:
state = followAction(state, action, problem)
states.append(state)
return states
def checkSolution(problem, path):
state = problem.getStartState()
for action in path:
state = followAction(state, action, problem)
return problem.isGoalState(state)
# Search problem on a plain graph
class GraphSearch(SearchProblem):
# Read in the state graph; define start/end states, edges and costs
def __init__(self, graph_text):
self.expanded_states = []
lines = graph_text.split('\n')
r = re.match('start_state:(.*)', lines[0])
if r == None:
print("Broken graph:")
print('"""%s"""' % graph_text)
raise Exception("GraphSearch graph specification start_state not found or incorrect on line 0")
self.start_state = r.group(1).strip()
r = re.match('goal_states:(.*)', lines[1])
if r == None:
print("Broken graph:")
print('"""%s"""' % graph_text)
raise Exception("GraphSearch graph specification goal_states not found or incorrect on line 1")
goals = r.group(1).split()
self.goals = [str.strip(g) for g in goals]
self.successors = {}
all_states = set()
self.orderedSuccessorTuples = []
for l in lines[2:]:
if len(l.split()) == 3:
start, action, next_state = l.split()
cost = 1
elif len(l.split()) == 4:
start, action, next_state, cost = l.split()
else:
print("Broken graph:")
print('"""%s"""' % graph_text)
raise Exception("Invalid line in GraphSearch graph specification on line:" + l)
cost = float(cost)
self.orderedSuccessorTuples.append((start, action, next_state, cost))
all_states.add(start)
all_states.add(next_state)
if start not in self.successors:
self.successors[start] = []
self.successors[start].append((next_state, action, cost))
for s in all_states:
if s not in self.successors:
self.successors[s] = []
# Get start state
def getStartState(self):
return self.start_state
# Check if a state is a goal state
def isGoalState(self, state):
return state in self.goals
# Get all successors of a state
def getSuccessors(self, state):
self.expanded_states.append(state)
return list(self.successors[state])
# Calculate total cost of a sequence of actions
def getCostOfActions(self, actions):
total_cost = 0
state = self.start_state
for a in actions:
successors = self.successors[state]
match = False
for (next_state, action, cost) in successors:
if a == action:
state = next_state
total_cost += cost
match = True
if not match:
print('invalid action sequence')
sys.exit(1)
return total_cost
# Return a list of all states on which 'getSuccessors' was called
def getExpandedStates(self):
return self.expanded_states
def __str__(self):
print(self.successors)
edges = ["%s %s %s %s" % t for t in self.orderedSuccessorTuples]
return \
"""start_state: %s
goal_states: %s
%s""" % (self.start_state, " ".join(self.goals), "\n".join(edges))
def parseHeuristic(heuristicText):
heuristic = {}
for line in heuristicText.split('\n'):
tokens = line.split()
if len(tokens) != 2:
print("Broken heuristic:")
print('"""%s"""' % heuristicText)
raise Exception("GraphSearch heuristic specification broken at tokens:" + str(tokens))
state, h = tokens
heuristic[state] = float(h)
def graphHeuristic(state, problem=None):
if state in heuristic:
return heuristic[state]
else:
import pprint
pp = pprint.PrettyPrinter(indent=4)
print("Heuristic:")
pp.pprint(heuristic)
raise Exception("Graph heuristic called with invalid state: " + str(state))
return graphHeuristic
class GraphSearchTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(GraphSearchTest, self).__init__(question, testDict)
self.graph_text = testDict['graph']
self.alg = testDict['algorithm']
self.diagram = testDict['diagram']
self.exactExpansionOrder = testDict.get('exactExpansionOrder', 'True').lower() == "true"
if 'heuristic' in testDict:
self.heuristic = parseHeuristic(testDict['heuristic'])
else:
self.heuristic = None
# Note that the return type of this function is a tripple:
# (solution, expanded states, error message)
def getSolInfo(self, search):
alg = getattr(search, self.alg)
problem = GraphSearch(self.graph_text)
if self.heuristic != None:
solution = alg(problem, self.heuristic)
else:
solution = alg(problem)
if type(solution) != type([]):
return None, None, 'The result of %s must be a list. (Instead, it is %s)' % (self.alg, type(solution))
return solution, problem.getExpandedStates(), None
# Run student code. If an error message is returned, print error and return false.
# If a good solution is returned, printn the solution and return true; otherwise,
# print both the correct and student's solution and return false.
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
gold_solution = [str.split(solutionDict['solution']), str.split(solutionDict['rev_solution'])]
gold_expanded_states = [str.split(solutionDict['expanded_states']), str.split(solutionDict['rev_expanded_states'])]
solution, expanded_states, error = self.getSolInfo(search)
if error != None:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('\t%s' % error)
return False
if solution in gold_solution and (not self.exactExpansionOrder or expanded_states in gold_expanded_states):
grades.addMessage('PASS: %s' % self.path)
grades.addMessage('\tsolution:\t\t%s' % solution)
grades.addMessage('\texpanded_states:\t%s' % expanded_states)
return True
else:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('\tgraph:')
for line in self.diagram.split('\n'):
grades.addMessage('\t %s' % (line,))
grades.addMessage('\tstudent solution:\t\t%s' % solution)
grades.addMessage('\tstudent expanded_states:\t%s' % expanded_states)
grades.addMessage('')
grades.addMessage('\tcorrect solution:\t\t%s' % gold_solution[0])
grades.addMessage('\tcorrect expanded_states:\t%s' % gold_expanded_states[0])
grades.addMessage('\tcorrect rev_solution:\t\t%s' % gold_solution[1])
grades.addMessage('\tcorrect rev_expanded_states:\t%s' % gold_expanded_states[1])
return False
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# open file and write comments
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
handle.write('# This solution is designed to support both right-to-left\n')
handle.write('# and left-to-right implementations.\n')
# write forward solution
solution, expanded_states, error = self.getSolInfo(search)
if error != None: raise Exception("Error in solution code: %s" % error)
handle.write('solution: "%s"\n' % ' '.join(solution))
handle.write('expanded_states: "%s"\n' % ' '.join(expanded_states))
# reverse and write backwards solution
search.REVERSE_PUSH = not search.REVERSE_PUSH
solution, expanded_states, error = self.getSolInfo(search)
if error != None: raise Exception("Error in solution code: %s" % error)
handle.write('rev_solution: "%s"\n' % ' '.join(solution))
handle.write('rev_expanded_states: "%s"\n' % ' '.join(expanded_states))
# clean up
search.REVERSE_PUSH = not search.REVERSE_PUSH
handle.close()
return True
class PacmanSearchTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(PacmanSearchTest, self).__init__(question, testDict)
self.layout_text = testDict['layout']
self.alg = testDict['algorithm']
self.layoutName = testDict['layoutName']
# TODO: sensible to have defaults like this?
self.leewayFactor = float(testDict.get('leewayFactor', '1'))
self.costFn = eval(testDict.get('costFn', 'None'))
self.searchProblemClassName = testDict.get('searchProblemClass', 'PositionSearchProblem')
self.heuristicName = testDict.get('heuristic', None)
def getSolInfo(self, search, searchAgents):
alg = getattr(search, self.alg)
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
start_state = pacman.GameState()
start_state.initialize(lay, 0)
problemClass = getattr(searchAgents, self.searchProblemClassName)
problemOptions = {}
if self.costFn != None:
problemOptions['costFn'] = self.costFn
problem = problemClass(start_state, **problemOptions)
heuristic = getattr(searchAgents, self.heuristicName) if self.heuristicName != None else None
if heuristic != None:
solution = alg(problem, heuristic)
else:
solution = alg(problem)
if type(solution) != type([]):
return None, None, 'The result of %s must be a list. (Instead, it is %s)' % (self.alg, type(solution))
from game import Directions
dirs = Directions.LEFT.keys()
if [el in dirs for el in solution].count(False) != 0:
return None, None, 'Output of %s must be a list of actions from game.Directions' % self.alg
expanded = problem._expanded
return solution, expanded, None
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
gold_solution = [str.split(solutionDict['solution']), str.split(solutionDict['rev_solution'])]
gold_expanded = max(int(solutionDict['expanded_nodes']), int(solutionDict['rev_expanded_nodes']))
solution, expanded, error = self.getSolInfo(search, searchAgents)
if error != None:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('%s' % error)
return False
# FIXME: do we want to standardize test output format?
if solution not in gold_solution:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('Solution not correct.')
grades.addMessage('\tstudent solution length: %s' % len(solution))
grades.addMessage('\tstudent solution:\n%s' % wrap_solution(solution))
grades.addMessage('')
grades.addMessage('\tcorrect solution length: %s' % len(gold_solution[0]))
grades.addMessage('\tcorrect (reversed) solution length: %s' % len(gold_solution[1]))
grades.addMessage('\tcorrect solution:\n%s' % wrap_solution(gold_solution[0]))
grades.addMessage('\tcorrect (reversed) solution:\n%s' % wrap_solution(gold_solution[1]))
return False
if expanded > self.leewayFactor * gold_expanded and expanded > gold_expanded + 1:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('Too many node expanded; are you expanding nodes twice?')
grades.addMessage('\tstudent nodes expanded: %s' % expanded)
grades.addMessage('')
grades.addMessage('\tcorrect nodes expanded: %s (leewayFactor %s)' % (gold_expanded, self.leewayFactor))
return False
grades.addMessage('PASS: %s' % self.path)
grades.addMessage('\tpacman layout:\t\t%s' % self.layoutName)
grades.addMessage('\tsolution length: %s' % len(solution))
grades.addMessage('\tnodes expanded:\t\t%s' % expanded)
return True
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# open file and write comments
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
handle.write('# This solution is designed to support both right-to-left\n')
handle.write('# and left-to-right implementations.\n')
handle.write('# Number of nodes expanded must be with a factor of %s of the numbers below.\n' % self.leewayFactor)
# write forward solution
solution, expanded, error = self.getSolInfo(search, searchAgents)
if error != None: raise Exception("Error in solution code: %s" % error)
handle.write('solution: """\n%s\n"""\n' % wrap_solution(solution))
handle.write('expanded_nodes: "%s"\n' % expanded)
# write backward solution
search.REVERSE_PUSH = not search.REVERSE_PUSH
solution, expanded, error = self.getSolInfo(search, searchAgents)
if error != None: raise Exception("Error in solution code: %s" % error)
handle.write('rev_solution: """\n%s\n"""\n' % wrap_solution(solution))
handle.write('rev_expanded_nodes: "%s"\n' % expanded)
# clean up
search.REVERSE_PUSH = not search.REVERSE_PUSH
handle.close()
return True
from game import Actions
def getStatesFromPath(start, path):
"Returns the list of states visited along the path"
vis = [start]
curr = start
for a in path:
x,y = curr
dx, dy = Actions.directionToVector(a)
curr = (int(x + dx), int(y + dy))
vis.append(curr)
return vis
class CornerProblemTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(CornerProblemTest, self).__init__(question, testDict)
self.layoutText = testDict['layout']
self.layoutName = testDict['layoutName']
def solution(self, search, searchAgents):
lay = layout.Layout([l.strip() for l in self.layoutText.split('\n')])
gameState = pacman.GameState()
gameState.initialize(lay, 0)
problem = searchAgents.CornersProblem(gameState)
path = search.bfs(problem)
gameState = pacman.GameState()
gameState.initialize(lay, 0)
visited = getStatesFromPath(gameState.getPacmanPosition(), path)
top, right = gameState.getWalls().height-2, gameState.getWalls().width-2
missedCorners = [p for p in ((1,1), (1,top), (right, 1), (right, top)) if p not in visited]
return path, missedCorners
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
gold_length = int(solutionDict['solution_length'])
solution, missedCorners = self.solution(search, searchAgents)
if type(solution) != type([]):
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('The result must be a list. (Instead, it is %s)' % type(solution))
return False
if len(missedCorners) != 0:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('Corners missed: %s' % missedCorners)
return False
if len(solution) != gold_length:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('Optimal solution not found.')
grades.addMessage('\tstudent solution length:\n%s' % len(solution))
grades.addMessage('')
grades.addMessage('\tcorrect solution length:\n%s' % gold_length)
return False
grades.addMessage('PASS: %s' % self.path)
grades.addMessage('\tpacman layout:\t\t%s' % self.layoutName)
grades.addMessage('\tsolution length:\t\t%s' % len(solution))
return True
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# open file and write comments
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
print("Solving problem", self.layoutName)
print(self.layoutText)
path, _ = self.solution(search, searchAgents)
length = len(path)
print("Problem solved")
handle.write('solution_length: "%s"\n' % length)
handle.close()
# template = """class: "HeuristicTest"
#
# heuristic: "foodHeuristic"
# searchProblemClass: "FoodSearchProblem"
# layoutName: "Test %s"
# layout: \"\"\"
# %s
# \"\"\"
# """
#
# for i, (_, _, l) in enumerate(doneTests + foodTests):
# f = open("food_heuristic_%s.test" % (i+1), "w")
# f.write(template % (i+1, "\n".join(l)))
# f.close()
class HeuristicTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(HeuristicTest, self).__init__(question, testDict)
self.layoutText = testDict['layout']
self.layoutName = testDict['layoutName']
self.searchProblemClassName = testDict['searchProblemClass']
self.heuristicName = testDict['heuristic']
def setupProblem(self, searchAgents):
lay = layout.Layout([l.strip() for l in self.layoutText.split('\n')])
gameState = pacman.GameState()
gameState.initialize(lay, 0)
problemClass = getattr(searchAgents, self.searchProblemClassName)
problem = problemClass(gameState)
state = problem.getStartState()
heuristic = getattr(searchAgents, self.heuristicName)
return problem, state, heuristic
def checkHeuristic(self, heuristic, problem, state, solutionCost):
h0 = heuristic(state, problem)
if solutionCost == 0:
if h0 == 0:
return True, ''
else:
return False, 'Heuristic failed H(goal) == 0 test'
if h0 < 0:
return False, 'Heuristic failed H >= 0 test'
if not h0 > 0:
return False, 'Heuristic failed non-triviality test'
if not h0 <= solutionCost:
return False, 'Heuristic failed admissibility test'
for succ, action, stepCost in problem.getSuccessors(state):
h1 = heuristic(succ, problem)
if h1 < 0: return False, 'Heuristic failed H >= 0 test'
if h0 - h1 > stepCost: return False, 'Heuristic failed consistency test'
return True, ''
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
solutionCost = int(solutionDict['solution_cost'])
problem, state, heuristic = self.setupProblem(searchAgents)
passed, message = self.checkHeuristic(heuristic, problem, state, solutionCost)
if not passed:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('%s' % message)
return False
else:
grades.addMessage('PASS: %s' % self.path)
return True
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# open file and write comments
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
print("Solving problem", self.layoutName, self.heuristicName)
print(self.layoutText)
problem, _, heuristic = self.setupProblem(searchAgents)
path = search.astar(problem, heuristic)
cost = problem.getCostOfActions(path)
print("Problem solved")
handle.write('solution_cost: "%s"\n' % cost)
handle.close()
return True
class HeuristicGrade(testClasses.TestCase):
def __init__(self, question, testDict):
super(HeuristicGrade, self).__init__(question, testDict)
self.layoutText = testDict['layout']
self.layoutName = testDict['layoutName']
self.searchProblemClassName = testDict['searchProblemClass']
self.heuristicName = testDict['heuristic']
self.basePoints = int(testDict['basePoints'])
self.thresholds = [int(t) for t in testDict['gradingThresholds'].split()]
def setupProblem(self, searchAgents):
lay = layout.Layout([l.strip() for l in self.layoutText.split('\n')])
gameState = pacman.GameState()
gameState.initialize(lay, 0)
problemClass = getattr(searchAgents, self.searchProblemClassName)
problem = problemClass(gameState)
state = problem.getStartState()
heuristic = getattr(searchAgents, self.heuristicName)
return problem, state, heuristic
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
problem, _, heuristic = self.setupProblem(searchAgents)
path = search.astar(problem, heuristic)
expanded = problem._expanded
if not checkSolution(problem, path):
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('\tReturned path is not a solution.')
grades.addMessage('\tpath returned by astar: %s' % expanded)
return False
grades.addPoints(self.basePoints)
points = 0
for threshold in self.thresholds:
if expanded <= threshold:
points += 1
grades.addPoints(points)
if points >= len(self.thresholds):
grades.addMessage('PASS: %s' % self.path)
else:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('\texpanded nodes: %s' % expanded)
grades.addMessage('\tthresholds: %s' % self.thresholds)
return True
def writeSolution(self, moduleDict, filePath):
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
handle.write('# File intentionally blank.\n')
handle.close()
return True
# template = """class: "ClosestDotTest"
#
# layoutName: "Test %s"
# layout: \"\"\"
# %s
# \"\"\"
# """
#
# for i, (_, _, l) in enumerate(foodTests):
# f = open("closest_dot_%s.test" % (i+1), "w")
# f.write(template % (i+1, "\n".join(l)))
# f.close()
class ClosestDotTest(testClasses.TestCase):
def __init__(self, question, testDict):
super(ClosestDotTest, self).__init__(question, testDict)
self.layoutText = testDict['layout']
self.layoutName = testDict['layoutName']
def solution(self, searchAgents):
lay = layout.Layout([l.strip() for l in self.layoutText.split('\n')])
gameState = pacman.GameState()
gameState.initialize(lay, 0)
path = searchAgents.ClosestDotSearchAgent().findPathToClosestDot(gameState)
return path
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
gold_length = int(solutionDict['solution_length'])
solution = self.solution(searchAgents)
if type(solution) != type([]):
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('\tThe result must be a list. (Instead, it is %s)' % type(solution))
return False
if len(solution) != gold_length:
grades.addMessage('FAIL: %s' % self.path)
grades.addMessage('Closest dot not found.')
grades.addMessage('\tstudent solution length:\n%s' % len(solution))
grades.addMessage('')
grades.addMessage('\tcorrect solution length:\n%s' % gold_length)
return False
grades.addMessage('PASS: %s' % self.path)
grades.addMessage('\tpacman layout:\t\t%s' % self.layoutName)
grades.addMessage('\tsolution length:\t\t%s' % len(solution))
return True
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# open file and write comments
handle = open(filePath, 'w')
handle.write('# This is the solution file for %s.\n' % self.path)
print("Solving problem", self.layoutName)
print(self.layoutText)
length = len(self.solution(searchAgents))
print("Problem solved")
handle.write('solution_length: "%s"\n' % length)
handle.close()
return True
class CornerHeuristicSanity(testClasses.TestCase):
def __init__(self, question, testDict):
super(CornerHeuristicSanity, self).__init__(question, testDict)
self.layout_text = testDict['layout']
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
game_state = pacman.GameState()
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
game_state.initialize(lay, 0)
problem = searchAgents.CornersProblem(game_state)
start_state = problem.getStartState()
h0 = searchAgents.cornersHeuristic(start_state, problem)
succs = problem.getSuccessors(start_state)
# cornerConsistencyA
for succ in succs:
h1 = searchAgents.cornersHeuristic(succ[0], problem)
if h0 - h1 > 1:
grades.addMessage('FAIL: inconsistent heuristic')
return False
heuristic_cost = searchAgents.cornersHeuristic(start_state, problem)
true_cost = float(solutionDict['cost'])
# cornerNontrivial
if heuristic_cost == 0:
grades.addMessage('FAIL: must use non-trivial heuristic')
return False
# cornerAdmissible
if heuristic_cost > true_cost:
grades.addMessage('FAIL: Inadmissible heuristic')
return False
path = solutionDict['path'].split()
states = followPath(path, problem)
heuristics = []
for state in states:
heuristics.append(searchAgents.cornersHeuristic(state, problem))
for i in range(0, len(heuristics) - 1):
h0 = heuristics[i]
h1 = heuristics[i+1]
# cornerConsistencyB
if h0 - h1 > 1:
grades.addMessage('FAIL: inconsistent heuristic')
return False
# cornerPosH
if h0 < 0 or h1 <0:
grades.addMessage('FAIL: non-positive heuristic')
return False
# cornerGoalH
if heuristics[len(heuristics) - 1] != 0:
grades.addMessage('FAIL: heuristic non-zero at goal')
return False
grades.addMessage('PASS: heuristic value less than true cost at start state')
return True
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# write comment
handle = open(filePath, 'w')
handle.write('# In order for a heuristic to be admissible, the value\n')
handle.write('# of the heuristic must be less at each state than the\n')
handle.write('# true cost of the optimal path from that state to a goal.\n')
# solve problem and write solution
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
start_state = pacman.GameState()
start_state.initialize(lay, 0)
problem = searchAgents.CornersProblem(start_state)
solution = search.astar(problem, searchAgents.cornersHeuristic)
handle.write('cost: "%d"\n' % len(solution))
handle.write('path: """\n%s\n"""\n' % wrap_solution(solution))
handle.close()
return True
class CornerHeuristicPacman(testClasses.TestCase):
def __init__(self, question, testDict):
super(CornerHeuristicPacman, self).__init__(question, testDict)
self.layout_text = testDict['layout']
def execute(self, grades, moduleDict, solutionDict):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
total = 0
true_cost = float(solutionDict['cost'])
thresholds = [int(x) for x in solutionDict['thresholds'].split()]
game_state = pacman.GameState()
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
game_state.initialize(lay, 0)
problem = searchAgents.CornersProblem(game_state)
start_state = problem.getStartState()
if searchAgents.cornersHeuristic(start_state, problem) > true_cost:
grades.addMessage('FAIL: Inadmissible heuristic')
return False
path = search.astar(problem, searchAgents.cornersHeuristic)
print("path:", path)
print("path length:", len(path))
cost = problem.getCostOfActions(path)
if cost > true_cost:
grades.addMessage('FAIL: Inconsistent heuristic')
return False
expanded = problem._expanded
points = 0
for threshold in thresholds:
if expanded <= threshold:
points += 1
grades.addPoints(points)
if points >= len(thresholds):
grades.addMessage('PASS: Heuristic resulted in expansion of %d nodes' % expanded)
else:
grades.addMessage('FAIL: Heuristic resulted in expansion of %d nodes' % expanded)
return True
def writeSolution(self, moduleDict, filePath):
search = moduleDict['search']
searchAgents = moduleDict['searchAgents']
# write comment
handle = open(filePath, 'w')
handle.write('# This solution file specifies the length of the optimal path\n')
handle.write('# as well as the thresholds on number of nodes expanded to be\n')
handle.write('# used in scoring.\n')
# solve problem and write solution
lay = layout.Layout([l.strip() for l in self.layout_text.split('\n')])
start_state = pacman.GameState()
start_state.initialize(lay, 0)
problem = searchAgents.CornersProblem(start_state)
solution = search.astar(problem, searchAgents.cornersHeuristic)
handle.write('cost: "%d"\n' % len(solution))
handle.write('path: """\n%s\n"""\n' % wrap_solution(solution))
handle.write('thresholds: "2000 1600 1200"\n')
handle.close()
return True
submission_autograder.py
+1 -1
View File
File diff suppressed because one or more lines are too long
testClasses.py
+7 -9
View File
@@ -61,6 +61,7 @@ class PassAllTestsQuestion(Question):
else:
grades.assignFullCredit()
class ExtraCreditPassAllTestsQuestion(Question):
def __init__(self, questionDict, display):
Question.__init__(self, questionDict, display)
@@ -92,11 +93,12 @@ class HackedPartialCreditQuestion(Question):
for testCase, f in self.testCases:
testResult = f(grades)
if "points" in testCase.testDict:
if testResult: points += float(testCase.testDict["points"])
if testResult:
points += float(testCase.testDict["points"])
else:
passed = passed and testResult
## FIXME: Below terrible hack to match q3's logic
# FIXME: Below terrible hack to match q3's logic
if int(points) == self.maxPoints and not passed:
grades.assignZeroCredit()
else:
@@ -116,6 +118,7 @@ class Q6PartialCreditQuestion(Question):
if False in results:
grades.assignZeroCredit()
class PartialCreditQuestion(Question):
"""Fails any test which returns False, otherwise doesn't effect the grades object.
Partial credit tests will add the required points."""
@@ -130,7 +133,6 @@ class PartialCreditQuestion(Question):
return False
class NumberPassedQuestion(Question):
"""Grade is the number of test cases passed."""
@@ -138,9 +140,6 @@ class NumberPassedQuestion(Question):
grades.addPoints([f(grades) for _, f in self.testCases].count(True))
# Template modeling a generic test case
class TestCase(object):
@@ -186,13 +185,13 @@ class TestCase(object):
return False
# This should really be question level?
#
def testPartial(self, grades, points, maxPoints):
grades.addPoints(points)
extraCredit = max(0, points - maxPoints)
regularCredit = points - extraCredit
grades.addMessage('%s: %s (%s of %s points)' % ("PASS" if points >= maxPoints else "FAIL", self.path, regularCredit, maxPoints))
grades.addMessage('%s: %s (%s of %s points)' % (
"PASS" if points >= maxPoints else "FAIL", self.path, regularCredit, maxPoints))
if extraCredit > 0:
grades.addMessage('EXTRA CREDIT: %s points' % (extraCredit,))
@@ -203,4 +202,3 @@ class TestCase(object):
def addMessage(self, message):
self.messages.extend(message.split('\n'))
testParser.py
+1
View File
@@ -15,6 +15,7 @@
import re
import sys
class TestParser(object):
def __init__(self, path):
test_cases/CONFIG
+1 -1
View File
@@ -1 +1 @@
order: "q1 q2 q3 q4 q5 q6 q7 q8"
order: "q1 q2 q3 q4 q5"
test_cases/q7/CONFIG → test_cases/extra/CONFIG
+1 -2
View File
@@ -1,3 +1,2 @@
max_points: "0"
class: "PartialCreditQuestion"
max_points: "4"
depends: "q4"
test_cases/extra/grade-agent.test
+11
View File
@@ -0,0 +1,11 @@
class: "EvalAgentTest"
agentName: "ContestAgent"
layoutName: "contestClassic"
maxTime: "180"
numGames: "5"
scoreThresholds: "2500 2900"
randomSeed: "0"
ghosts: "[DirectionalGhost(1), DirectionalGhost(2), DirectionalGhost(3)]"
test_cases/q1/CONFIG
+2 -2
View File
@@ -1,2 +1,2 @@
max_points: "3"
class: "PassAllTestsQuestion"
max_points: "4"
class: "PartialCreditQuestion"
test_cases/q1/grade-agent.solution
+2
View File
@@ -0,0 +1,2 @@
# This is the solution file for test_cases/q1/grade-agent.test.
# File intentionally blank.
test_cases/q1/grade-agent.test
+18
View File
@@ -0,0 +1,18 @@
class: "EvalAgentTest"
agentName: "ReflexAgent"
layoutName: "openClassic"
maxTime: "120"
numGames: "10"
nonTimeoutMinimum: "10"
scoreThresholds: "500 1000"
winsMinimum: "1"
winsThresholds: "5 10"
randomSeed: "0"
ghosts: "[RandomGhost(1)]"
test_cases/q1/graph_backtrack.solution
-7
View File
@@ -1,7 +0,0 @@
# This is the solution file for test_cases/q1/graph_backtrack.test.
# This solution is designed to support both right-to-left
# and left-to-right implementations.
solution: "1:A->C 0:C->G"
expanded_states: "A D C"
rev_solution: "1:A->C 0:C->G"
rev_expanded_states: "A B C"
test_cases/q1/graph_backtrack.test
-32
View File
@@ -1,32 +0,0 @@
class: "GraphSearchTest"
algorithm: "depthFirstSearch"
diagram: """
B
^
|
*A --> C --> G
|
V
D
A is the start state, G is the goal. Arrows mark
possible state transitions. This tests whether
you extract the sequence of actions correctly even
if your search backtracks. If you fail this, your
nodes are not correctly tracking the sequences of
actions required to reach them.
"""
# The following section specifies the search problem and the solution.
# The graph is specified by first the set of start states, followed by
# the set of goal states, and lastly by the state transitions which are
# of the form:
# <start state> <actions> <end state> <cost>
graph: """
start_state: A
goal_states: G
A 0:A->B B 1.0
A 1:A->C C 2.0
A 2:A->D D 4.0
C 0:C->G G 8.0
"""
test_cases/q1/graph_bfs_vs_dfs.solution
-7
View File
@@ -1,7 +0,0 @@
# This is the solution file for test_cases/q1/graph_bfs_vs_dfs.test.
# This solution is designed to support both right-to-left
# and left-to-right implementations.
solution: "2:A->D 0:D->G"
expanded_states: "A D"
rev_solution: "0:A->B 0:B->D 0:D->G"
rev_expanded_states: "A B D"
test_cases/q1/graph_bfs_vs_dfs.test
-30
View File
@@ -1,30 +0,0 @@
# Graph where BFS finds the optimal solution but DFS does not
class: "GraphSearchTest"
algorithm: "depthFirstSearch"
diagram: """
/-- B
| ^
| |
| *A -->[G]
| | ^
| V |
\-->D ----/
A is the start state, G is the goal. Arrows
mark possible transitions
"""
# The following section specifies the search problem and the solution.
# The graph is specified by first the set of start states, followed by
# the set of goal states, and lastly by the state transitions which are
# of the form:
# <start state> <actions> <end state> <cost>
graph: """
start_state: A
goal_states: G
A 0:A->B B 1.0
A 1:A->G G 2.0
A 2:A->D D 4.0
B 0:B->D D 8.0
D 0:D->G G 16.0
"""
test_cases/q1/graph_infinite.solution
-7
View File
@@ -1,7 +0,0 @@
# This is the solution file for test_cases/q1/graph_infinite.test.
# This solution is designed to support both right-to-left
# and left-to-right implementations.
solution: "0:A->B 1:B->C 1:C->G"
expanded_states: "A B C"
rev_solution: "0:A->B 1:B->C 1:C->G"
rev_expanded_states: "A B C"
test_cases/q1/graph_infinite.test
-30
View File
@@ -1,30 +0,0 @@
# Graph where natural action choice leads to an infinite loop
class: "GraphSearchTest"
algorithm: "depthFirstSearch"
diagram: """
B <--> C
^ /|
| / |
V / V
*A<-/ [G]
A is the start state, G is the goal. Arrows mark
possible state transitions.
"""
# The following section specifies the search problem and the solution.
# The graph is specified by first the set of start states, followed by
# the set of goal states, and lastly by the state transitions which are
# of the form:
# <start state> <actions> <end state> <cost>
graph: """
start_state: A
goal_states: G
A 0:A->B B 1.0
B 0:B->A A 2.0
B 1:B->C C 4.0
C 0:C->A A 8.0
C 1:C->G G 16.0
C 2:C->B B 32.0
"""
test_cases/q1/graph_manypaths.solution
-7
View File
@@ -1,7 +0,0 @@
# This is the solution file for test_cases/q1/graph_manypaths.test.
# This solution is designed to support both right-to-left
# and left-to-right implementations.
solution: "2:A->B2 0:B2->C 0:C->D 2:D->E2 0:E2->F 0:F->G"
expanded_states: "A B2 C D E2 F"
rev_solution: "0:A->B1 0:B1->C 0:C->D 0:D->E1 0:E1->F 0:F->G"
rev_expanded_states: "A B1 C D E1 F"
test_cases/q1/graph_manypaths.test
-39
View File
@@ -1,39 +0,0 @@
class: "GraphSearchTest"
algorithm: "depthFirstSearch"
diagram: """
B1 E1
^ \ ^ \
/ V / V
*A --> C --> D --> F --> [G]
\ ^ \ ^
V / V /
B2 E2
A is the start state, G is the goal. Arrows mark
possible state transitions. This graph has multiple
paths to the goal, where nodes with the same state
are added to the fringe multiple times before they
are expanded.
"""
# The following section specifies the search problem and the solution.
# The graph is specified by first the set of start states, followed by
# the set of goal states, and lastly by the state transitions which are
# of the form:
# <start state> <actions> <end state> <cost>
graph: """
start_state: A
goal_states: G
A 0:A->B1 B1 1.0
A 1:A->C C 2.0
A 2:A->B2 B2 4.0
B1 0:B1->C C 8.0
B2 0:B2->C C 16.0
C 0:C->D D 32.0
D 0:D->E1 E1 64.0
D 1:D->F F 128.0
D 2:D->E2 E2 256.0
E1 0:E1->F F 512.0
E2 0:E2->F F 1024.0
F 0:F->G G 2048.0
"""
test_cases/q1/pacman_1.solution
-40
View File
@@ -1,40 +0,0 @@
# This is the solution file for test_cases/q1/pacman_1.test.
# This solution is designed to support both right-to-left
# and left-to-right implementations.
# Number of nodes expanded must be with a factor of 1.0 of the numbers below.
solution: """
West West West West West West West West West West West West West West
West West West West West West West West West West West West West West
West West West West West South South South South South South South
South South East East East North North North North North North North
East East South South South South South South East East North North
North North North North East East South South South South East East
North North East East East East East East East East South South South
East East East East East East East South South South South South South
South West West West West West West West West West West West West West
West West West West South West West West West West West West West West
"""
expanded_nodes: "146"
rev_solution: """
South South West West West West South South East East East East South
South West West West West South South East East East East South South
West West West West South South South East North East East East South
South South West West West West West West West North North North North
North North North North West West West West West West West North North
North East East East East South East East East North North North West
West North North West West West West West West West West West West
West West West West West West West West West West West West West West
South South South South South South South South South East East East
North North North North North North North East East South South South
South South South East East North North North North North North East
East South South South South East East North North North North East
East East East East South South West West West South South East East
East South South West West West West West West South South West West
West West West South West West West West West South South East East
East East East East East North East East East East East North North
East East East East East East North East East East East East South
South West West West South West West West West West West South South
West West West West West South West West West West West West West West
West
"""
rev_expanded_nodes: "269"
test_cases/q1/pacman_1.test
-27
View File
@@ -1,27 +0,0 @@
# This is a basic depth first search test
class: "PacmanSearchTest"
algorithm: "depthFirstSearch"
# The following specifies the layout to be used
layoutName: "mediumMaze"
layout: """
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% P%
% %%%%%%%%%%%%%%%%%%%%%%% %%%%%%%% %
% %% % % %%%%%%% %% %
% %% % % % % %%%% %%%%%%%%% %% %%%%%
% %% % % % % %% %% %
% %% % % % % % %%%% %%% %%%%%% %
% % % % % % %% %%%%%%%% %
% %% % % %%%%%%%% %% %% %%%%%
% %% % %% %%%%%%%%% %% %
% %%%%%% %%%%%%% %% %%%%%% %
%%%%%% % %%%% %% % %
% %%%%%% %%%%% % %% %% %%%%%
% %%%%%% % %%%%% %% %
% %%%%%% %%%%%%%%%%% %% %% %
%%%%%%%%%% %%%%%% %
%. %%%%%%%%%%%%%%%% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
"""
test_cases/q2/0-eval-function-lose-states-1.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/0-eval-function-lose-states-1.test.
action: "Left"
generated: "lose1 lose2 root"
test_cases/q2/0-eval-function-lose-states-1.test
+30
View File
@@ -0,0 +1,30 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
diagram: """
root
/ \
lose1 lose2
1 0
If your algorithm is returning a different
action, make sure you are calling the
evaluation function on losing states.
"""
num_agents: "2"
start_state: "root"
win_states: ""
lose_states: "lose1 lose2"
successors: """
root Left lose1
root Right lose2
"""
evaluation: """
lose1 1.0
lose2 0.0
"""
test_cases/q2/0-eval-function-lose-states-2.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/0-eval-function-lose-states-2.test.
action: "Right"
generated: "lose1 lose2 root"
test_cases/q2/0-eval-function-lose-states-2.test
+30
View File
@@ -0,0 +1,30 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
diagram: """
root
/ \
lose1 lose2
0 1
If your algorithm is returning a different
action, make sure you are calling the
evaluation function on losing states.
"""
num_agents: "2"
start_state: "root"
win_states: ""
lose_states: "lose1 lose2"
successors: """
root Left lose1
root Right lose2
"""
evaluation: """
lose1 0.0
lose2 1.0
"""
test_cases/q2/0-eval-function-win-states-1.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/0-eval-function-win-states-1.test.
action: "Left"
generated: "root win1 win2"
test_cases/q2/0-eval-function-win-states-1.test
+30
View File
@@ -0,0 +1,30 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
diagram: """
root
/ \
win1 win2
1 0
If your algorithm is returning a different
action, make sure you are calling the
evaluation function on winning states.
"""
num_agents: "2"
start_state: "root"
win_states: "win1 win2"
lose_states: ""
successors: """
root Left win1
root Right win2
"""
evaluation: """
win1 1.0
win2 0.0
"""
test_cases/q2/0-eval-function-win-states-2.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/0-eval-function-win-states-2.test.
action: "Right"
generated: "root win1 win2"
test_cases/q2/0-eval-function-win-states-2.test
+30
View File
@@ -0,0 +1,30 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
diagram: """
root
/ \
win1 win2
0 1
If your algorithm is returning a different
action, make sure you are calling the
evaluation function on winning states.
"""
num_agents: "2"
start_state: "root"
win_states: "win1 win2"
lose_states: ""
successors: """
root Left win1
root Right win2
"""
evaluation: """
win1 0.0
win2 1.0
"""
test_cases/q2/0-lecture-6-tree.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/0-lecture-6-tree.test.
action: "Center"
generated: "A B C D E F G H I max min1 min2 min3"
test_cases/q2/0-lecture-6-tree.test
+50
View File
@@ -0,0 +1,50 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
# Tree from lecture 6 slides
diagram: """
max
/-/ | \--\
/ | \
/ | \
min1 min2 min3
/|\ /|\ /|\
/ | \ / | \ / | \
A B C D E F G H I
3 12 8 5 4 6 14 1 11
"""
num_agents: "2"
start_state: "max"
win_states: "A B C D E F G H I"
lose_states: ""
successors: """
max Left min1
max Center min2
max Right min3
min1 Left A
min1 Center B
min1 Right C
min2 Left D
min2 Center E
min2 Right F
min3 Left G
min3 Center H
min3 Right I
"""
evaluation: """
A 3.0
B 12.0
C 8.0
D 5.0
E 4.0
F 6.0
G 14.0
H 1.0
I 11.0
"""
test_cases/q2/0-small-tree.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/0-small-tree.test.
action: "pacLeft"
generated: "A B C D deeper minLeft minRight root"
test_cases/q2/0-small-tree.test
+36
View File
@@ -0,0 +1,36 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "3"
diagram: """
root
/ \
minLeft minRight
/ \ / \
A B C deeper
4 3 2 |
D
1000
"""
num_agents: "2"
start_state: "root"
win_states: "A C"
lose_states: "B D"
successors: """
root pacLeft minLeft
root pacRight minRight
minLeft gLeft A
minLeft gRight B
minRight gLeft C
minRight gRight deeper
deeper pacLeft D
"""
evaluation: """
A 4.0
B 3.0
C 2.0
D 1000.0
"""
test_cases/q2/1-1-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-1-minmax.test.
action: "Left"
generated: "a b1 b2 c1 c2 cx d1 d2 d3 d4 dx"
test_cases/q2/1-1-minmax.test
+47
View File
@@ -0,0 +1,47 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "3"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
c1 c2 cx
/ \ / \ |
d1 d2 d3 d4 dx
-3 -9 10 6 -3.01
a - max
b - min
c - max
Note that the minimax value of b1 is -3.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
cx Down dx
"""
evaluation: """
d1 -3.0
d2 -9.0
d3 10.0
d4 6.0
dx -3.01
"""
test_cases/q2/1-2-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-2-minmax.test.
action: "Right"
generated: "a b1 b2 c1 c2 cx d1 d2 d3 d4 dx"
test_cases/q2/1-2-minmax.test
+47
View File
@@ -0,0 +1,47 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "3"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
c1 c2 cx
/ \ / \ |
d1 d2 d3 d4 dx
-3 -9 10 6 -2.99
a - max
b - min
c - max
Note that the minimax value of b1 is -3.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
cx Down dx
"""
evaluation: """
d1 -3.0
d2 -9.0
d3 10.0
d4 6.0
dx -2.99
"""
test_cases/q2/1-3-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-3-minmax.test.
action: "Left"
generated: "a b1 b2 c3 c4 cx d5 d6 d7 d8 dx"
test_cases/q2/1-3-minmax.test
+47
View File
@@ -0,0 +1,47 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "3"
diagram: """
/-----a------\
/ \
/ \
b1 b2
| / \
cx c3 c4
| / \ / \
dx d5 d6 d7 d8
4.01 4 -7 0 5
a - max
b - min
c - max
Note that the minimax value of b2 is 4.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 d5 d6 d7 d8 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Down cx
b2 Left c3
b2 Right c4
c3 Left d5
c3 Right d6
c4 Left d7
c4 Right d8
cx Down dx
"""
evaluation: """
d5 4.0
d6 -7.0
d7 0.0
d8 5.0
dx 4.01
"""
test_cases/q2/1-4-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-4-minmax.test.
action: "Right"
generated: "a b1 b2 c3 c4 cx d5 d6 d7 d8 dx"
test_cases/q2/1-4-minmax.test
+47
View File
@@ -0,0 +1,47 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "3"
diagram: """
/-----a------\
/ \
/ \
b1 b2
| / \
cx c3 c4
| / \ / \
dx d5 d6 d7 d8
3.99 4 -7 0 5
a - max
b - min
c - max
Note that the minimax value of b2 is 4.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 d5 d6 d7 d8 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Down cx
b2 Left c3
b2 Right c4
c3 Left d5
c3 Right d6
c4 Left d7
c4 Right d8
cx Down dx
"""
evaluation: """
d5 4.0
d6 -7.0
d7 0.0
d8 5.0
dx 3.99
"""
test_cases/q2/1-5-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-5-minmax.test.
action: "Right"
generated: "A B C D E F G H Z a b1 b2 c1 c2 cx d1 d2 d3 d4 dx"
test_cases/q2/1-5-minmax.test
+75
View File
@@ -0,0 +1,75 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "4"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
c1 c2 cx
/ \ / \ |
d1 d2 d3 d4 dx
/ \ / \ / \ / \ |
A B C D E F G H Z
-3 13 5 9 10 3 -6 8 3.01
a - max
b - min
c - max
d - min
Note the minimax value of b1 is 3.
"""
num_agents: "2"
start_state: "a"
win_states: "A B C D E F G H I J K L M N O P Z"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
c3 Left d5
c3 Right d6
c4 Left d7
c4 Right d8
cx Down dx
d1 Left A
d1 Right B
d2 Left C
d2 Right D
d3 Left E
d3 Right F
d4 Left G
d4 Right H
d5 Left I
d5 Right J
d6 Left K
d6 Right L
d7 Left M
d7 Right N
d8 Left O
d8 Right P
dx Down Z
"""
evaluation: """
A -3.0
B 13.0
C 5.0
D 9.0
E 10.0
F 3.0
G -6.0
H 8.0
Z 3.01
"""
test_cases/q2/1-6-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-6-minmax.test.
action: "Left"
generated: "A B C D E F G H Z a b1 b2 c1 c2 cx d1 d2 d3 d4 dx"
test_cases/q2/1-6-minmax.test
+75
View File
@@ -0,0 +1,75 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "4"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
c1 c2 cx
/ \ / \ |
d1 d2 d3 d4 dx
/ \ / \ / \ / \ |
A B C D E F G H Z
-3 13 5 9 10 3 -6 8 2.99
a - max
b - min
c - max
d - min
Note the minimax value of b1 is 3.
"""
num_agents: "2"
start_state: "a"
win_states: "A B C D E F G H I J K L M N O P Z"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
c3 Left d5
c3 Right d6
c4 Left d7
c4 Right d8
cx Down dx
d1 Left A
d1 Right B
d2 Left C
d2 Right D
d3 Left E
d3 Right F
d4 Left G
d4 Right H
d5 Left I
d5 Right J
d6 Left K
d6 Right L
d7 Left M
d7 Right N
d8 Left O
d8 Right P
dx Down Z
"""
evaluation: """
A -3.0
B 13.0
C 5.0
D 9.0
E 10.0
F 3.0
G -6.0
H 8.0
Z 2.99
"""
test_cases/q2/1-7-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-7-minmax.test.
action: "Left"
generated: "I J K L M N O P Z a b1 b2 c3 c4 cx d5 d6 d7 d8 dx"
test_cases/q2/1-7-minmax.test
+75
View File
@@ -0,0 +1,75 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "4"
diagram: """
/-----a------\
/ \
/ \
b1 b2
| / \
cx c3 c4
| / \ / \
dx d5 d6 d7 d8
| / \ / \ / \ / \
Z I J K L M N O P
-1.99 -1 -9 4 7 2 5 -3 -2
a - max
b - min
c - min
d - max
Note that the minimax value of b2 is -2
"""
num_agents: "3"
start_state: "a"
win_states: "A B C D E F G H I J K L M N O P Z"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Down cx
b2 Left c3
b2 Right c4
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
c3 Left d5
c3 Right d6
c4 Left d7
c4 Right d8
cx Down dx
d1 Left A
d1 Right B
d2 Left C
d2 Right D
d3 Left E
d3 Right F
d4 Left G
d4 Right H
d5 Left I
d5 Right J
d6 Left K
d6 Right L
d7 Left M
d7 Right N
d8 Left O
d8 Right P
dx Down Z
"""
evaluation: """
I -1.0
J -9.0
K 4.0
L 7.0
M 2.0
N 5.0
O -3.0
P -2.0
Z -1.99
"""
test_cases/q2/1-8-minmax.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/1-8-minmax.test.
action: "Right"
generated: "I J K L M N O P Z a b1 b2 c3 c4 cx d5 d6 d7 d8 dx"
test_cases/q2/1-8-minmax.test
+75
View File
@@ -0,0 +1,75 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "4"
diagram: """
/-----a------\
/ \
/ \
b1 b2
| / \
cx c3 c4
| / \ / \
dx d5 d6 d7 d8
| / \ / \ / \ / \
Z I J K L M N O P
-2.01 -1 -9 4 7 2 5 -3 -2
a - max
b - min
c - min
d - max
Note that the minimax value of b2 is -2.01
"""
num_agents: "3"
start_state: "a"
win_states: "A B C D E F G H I J K L M N O P Z"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Down cx
b2 Left c3
b2 Right c4
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
c3 Left d5
c3 Right d6
c4 Left d7
c4 Right d8
cx Down dx
d1 Left A
d1 Right B
d2 Left C
d2 Right D
d3 Left E
d3 Right F
d4 Left G
d4 Right H
d5 Left I
d5 Right J
d6 Left K
d6 Right L
d7 Left M
d7 Right N
d8 Left O
d8 Right P
dx Down Z
"""
evaluation: """
I -1.0
J -9.0
K 4.0
L 7.0
M 2.0
N 5.0
O -3.0
P -2.0
Z -2.01
"""
test_cases/q2/2-1a-vary-depth.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/2-1a-vary-depth.test.
action: "Left"
generated: "a b1 b2 c1 c2 cx"
test_cases/q2/2-1a-vary-depth.test
+52
View File
@@ -0,0 +1,52 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "1"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
-4 c1 c2 9 cx -4.01
/ \ / \ |
d1 d2 d3 d4 dx
-3 -9 10 6 -4.01
a - max
b - min
c - max
Note that the minimax value of b1 is -3, but the depth=1 limited value is -4.
The values next to c1, c2, and cx are the values of the evaluation function, not
necessarily the correct minimax backup.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
cx Down dx
"""
evaluation: """
c1 -4.0
c2 9.0
cx -4.01
d1 -3.0
d2 -9.0
d3 10.0
d4 6.0
dx -4.01
"""
test_cases/q2/2-1b-vary-depth.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/2-1b-vary-depth.test.
action: "Left"
generated: "a b1 b2 c1 c2 cx d1 d2 d3 d4 dx"
test_cases/q2/2-1b-vary-depth.test
+52
View File
@@ -0,0 +1,52 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
-4 c1 c2 9 cx -4.01
/ \ / \ |
d1 d2 d3 d4 dx
-3 -9 10 6 -4.01
a - max
b - min
c - max
Note that the minimax value of b1 is -3, but the depth=1 limited value is -4.
The values next to c1, c2, and cx are the values of the evaluation function, not
necessarily the correct minimax backup.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
cx Down dx
"""
evaluation: """
c1 -4.0
c2 9.0
cx -4.01
d1 -3.0
d2 -9.0
d3 10.0
d4 6.0
dx -4.01
"""
test_cases/q2/2-2a-vary-depth.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/2-2a-vary-depth.test.
action: "Right"
generated: "a b1 b2 c1 c2 cx"
test_cases/q2/2-2a-vary-depth.test
+52
View File
@@ -0,0 +1,52 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "1"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
-4 c1 c2 9 cx -3.99
/ \ / \ |
d1 d2 d3 d4 dx
-3 -9 10 6 -3.99
a - max
b - min
c - max
Note that the minimax value of b1 is -3, but the depth=1 limited value is -4.
The values next to c1, c2, and cx are the values of the evaluation function, not
necessarily the correct minimax backup.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
cx Down dx
"""
evaluation: """
c1 -4.0
c2 9.0
cx -3.99
d1 -3.0
d2 -9.0
d3 10.0
d4 6.0
dx -3.99
"""
test_cases/q2/2-2b-vary-depth.solution
+3
View File
@@ -0,0 +1,3 @@
# This is the solution file for test_cases/q2/2-2b-vary-depth.test.
action: "Left"
generated: "a b1 b2 c1 c2 cx d1 d2 d3 d4 dx"
test_cases/q2/2-2b-vary-depth.test
+52
View File
@@ -0,0 +1,52 @@
class: "GraphGameTreeTest"
alg: "MinimaxAgent"
depth: "2"
diagram: """
/-----a------\
/ \
/ \
b1 b2
/ \ |
-4 c1 c2 9 cx -3.99
/ \ / \ |
d1 d2 d3 d4 dx
-3 -9 10 6 -3.99
a - max
b - min
c - max
Note that the minimax value of b1 is -3, but the depth=1 limited value is -4.
The values next to c1, c2, and cx are the values of the evaluation function, not
necessarily the correct minimax backup.
"""
num_agents: "2"
start_state: "a"
win_states: "d1 d2 d3 d4 dx"
lose_states: ""
successors: """
a Left b1
a Right b2
b1 Left c1
b1 Right c2
b2 Down cx
c1 Left d1
c1 Right d2
c2 Left d3
c2 Right d4
cx Down dx
"""
evaluation: """
c1 -4.0
c2 9.0
cx -3.99
d1 -3.0
d2 -9.0
d3 10.0
d4 6.0
dx -3.99
"""

Some files were not shown because too many files have changed in this diff Show More