def getAction(self,state):
walls = api.walls(state)
width,height = api.corners(state)[-1]
legal = api.legalActions(state)
me = api.whereAmI(state)
food = api.food(state)
ghosts = api.ghosts(state)
capsules = api.capsules(state)
direction = Directions.STOP
x, y = me
if not hasattr(self, 'map'):
self.createMap(walls, width + 1, height + 1)
self.checkForCapsules(capsules, legal, ghosts)
legal = self.solveLoop(ghosts, legal)
if len(ghosts):
self.memorizeGhosts(ghosts)
if self.counter < 0:
for ghost in ghosts:
legal = self.checkForGhosts(ghost, me, legal)
direction = self.pickMove(me, legal, width + 1, height + 1, food)
self.updatePosition(me, 1, self.map)
self.printMap(self.map)
self.last = direction
return direction
def initialize(self, state):
# get location of all visible food
foods = api.food(state)
#get location of all corners
corners = api.corners(state)
#get location of all visible capsules
capsules = api.capsules(state)
# Get the actions we can try, and remove "STOP" if that is one of them.
legal = api.legalActions(state)
#get location of all visible walls
walls = api.walls(state)
#get pacmans position
pacman = api.whereAmI(state)
x = pacman[0]
y = pacman[1]
if self.map == None:
width = 0
height = 0
for corner in corners:
if corner[0] > width:
width = corner[0]
if corner[1] > height:
height = corner[1]
self.map = [["?" for y in range(height)] for x in range(width)]
for wall in walls:
self.map[wall[0]][wall[1]] = "W"
for food in foods:
self.map[food[0]][food[1]] = "F"
for capsule in capsules:
self.map[capsule[0]][capsule[1]] = "F"
self.map[x][y] = "0"
self.init = True
def valueIterationSmall(self, state, reward, gamma, V1):
# Similar to valueIteration function
# does not calculate buffers around ghosts (cause it would be too small)
# meant for maps smaller than 10 x 10
corners = api.corners(state)
walls = api.walls(state)
food = api.food(state)
ghosts = api.ghosts(state)
capsules = api.capsules(state)
maxWidth = self.getLayoutWidth(corners) - 1
maxHeight = self.getLayoutHeight(corners) - 1
if not (0 < gamma <= 1):
raise ValueError("MDP must have a gamma between 0 and 1.")
# Implement Bellman equation with 10-loop iteration
# Since smaller maps do not require as big of a value iteration loop
loops = 100
while loops > 0:
V = V1.copy() # This will store the old values
for i in range(maxWidth):
for j in range(maxHeight):
# Exclude any food because in this case it is the terminal state
if (i, j) not in walls and (i, j) not in food and (
i, j) not in ghosts and (i, j) not in capsules:
V1[(i,
j)] = reward + gamma * self.getTransition(i, j, V)
loops -= 1
def getAction(self, state):
"""
The function to work out next intended action carried out.
Parameters:
None
Returns:
Directions: Intended action that Pacman will carry out.
"""
current_pos = api.whereAmI(state)
corners = api.corners(state)
food = api.food(state)
ghosts = api.ghosts(state)
ghost_scared_time = api.ghostStatesWithTimes(state)[0][1]
walls = api.walls(state)
legal = api.legalActions(state)
capsules = api.capsules(state)
protected_coords = walls + ghosts + [current_pos]
width = max(corners)[0] + 1
height = max(corners, key=itemgetter(1))[1] + 1
board = self.create_board(width, height, -0.04)
board.set_position_values(food, 1)
board.set_position_values(walls, 'x')
board.set_position_values(capsules, 2)
if ghost_scared_time < 5:
board.set_position_values(ghosts, -3)
# for i in range(height):
# for j in range(width):
# print board[i, j],
# print
# print
print "GHOST LIST: ", ghosts
for x, y in ghosts:
# set the surrounding area around the ghost to half the reward of the ghost
# avoids changing the reward of the ghost itself, the pacman and the walls
# print "GHOST Coordinates: " + str(x) + " " + str(y)
x_coordinates = [x - 1, x, x + 1]
y_coordinates = [y - 1, y, y + 1]
# print "X/Y Coordinates: " + str(x_coordinates) + " " + str(y_coordinates)
for x_coord in x_coordinates:
for y_coord in y_coordinates:
if (x_coord, y_coord) not in protected_coords:
# print("index: " + str((board.convert_y(y_coord), x_coord)))
converted_y = board.convert_y(y_coord)
# print "VALUE: " + str(board[board.convert_y(y), x])
board[converted_y,
x_coord] = board[board.convert_y(y), x] / 2
# print "VALUE PART 2: " + str(board[converted_y, x_coord])
board = self.value_iteration(state, board)
expected_utility = self.calculate_expected_utility(
state, board, abs(current_pos[1] - (height - 1)), current_pos[0])
return max([(utility, action) for utility, action in expected_utility
if action in legal])[1]
def updateFoodInMap(self, state):
# First, make all grid elements thataren't walls with a reward - 0.02.
map(lambda s: self.map.setValue(s[0], s[1], ('-0.02', 0)), self.states)
food = api.food(state)
food += api.capsules(state)
map(
lambda i: self.map.setValue(food[i][0], food[i][1],
(self.initialFood / len(food), 0)),
range(len(food)))
def getAction(self, state):
# Demonstrates the information that Pacman can access about the state
# of the game.
# What are the current moves available
legal = api.legalActions(state)
print "Legal moves: ", legal
# Where is Pacman?
pacman = api.whereAmI(state)
print "Pacman position: ", pacman
# Where are the ghosts?
print "Ghost positions:"
theGhosts = api.ghosts(state)
for i in range(len(theGhosts)):
print theGhosts[i]
print "timer"
moreGhosts = api.ghostStatesWithTimes(state)
for i in range(len(moreGhosts)):
print moreGhosts[i]
# How far away are the ghosts?
print "Distance to ghosts:"
for i in range(len(theGhosts)):
print util.manhattanDistance(pacman, theGhosts[i])
# Where are the capsules?
print "Capsule locations:"
print api.capsules(state)
# Where is the food?
print "Food locations: "
print api.food(state)
# Where are the walls?
print "Wall locations: "
print api.walls(state)
# getAction has to return a move. Here we pass "STOP" to the
# API to ask Pacman to stay where they are.
return api.makeMove(Directions.STOP, legal)
def getAction(self, state):
"""
The function to work out next intended action carried out.
Parameters:
None
Returns:
Directions: Intended action that Pacman will carry out.
"""
current_pos = api.whereAmI(state)
food = api.food(state)
# make sure all ghost coordinates are ints rather than floats
ghosts = [(int(x), int(y)) for x, y in api.ghosts(state)]
legal = api.legalActions(state)
capsules = api.capsules(state)
food_multiplier = (
(0.8 * len(food) / float(self.initial_num_food))**2) + 6
ghost_multiplier = (
(0.2 * len(food) / float(self.initial_num_food))**2) + 3
board = Board(self.width, self.height, -0.04)
board.set_position_values(self.walls, 'x')
board.set_position_values(capsules, 2 * food_multiplier)
board.set_position_values(food, 1 * food_multiplier)
board.set_position_values(ghosts, -7 * ghost_multiplier)
# rewards of ghosts, walls and current position cannot be overridden
protected_pos = set(ghosts + self.walls + [current_pos])
# setting a much more negative reward for potential positions ghosts can occupy
# in two moves.
for ghost in ghosts:
# loop through potential positions that the ghost can occupy if it were
# to move now
for pos in self.get_next_pos(ghost):
if pos not in protected_pos:
# set the reward value of surrounding positions of ghosts to -6 *
# ghost multiplier.
board[int(board.convert_y(pos[1])),
int(pos[0])] = -6 * ghost_multiplier
for position in self.get_next_pos(pos):
# loop through potential positions that the ghost can occupy if
# it were to move two times.
if position not in protected_pos:
board[int(board.convert_y(position[1])),
int(position[0])] = -6 * ghost_multiplier
board = self.value_iteration(state, board) # call value iteration
expected_utility = self.calculate_expected_utility(
state, board, board.convert_y(current_pos[1]), current_pos[0])
# returns action associated to the max utility out of all the legal actions.
return api.makeMove(
max([(utility, action) for utility, action in expected_utility
if action in legal])[1], legal)
def __update_positions(self, state):
'''
Repaints the grid according to the passed in state. Updating the
position of pacman, the ghosts, the food, the capsules, and the blank
spaces.
In addition calculates the number of filled spaces and stores this value
statically on Point, for later use in the reward function.
Args:
state: Current game state.
'''
Grid.FILL_COUNT = 0
points = {
Dispositions.FOOD: api.food(state),
Dispositions.CAPSULE: api.capsules(state),
Dispositions.GHOST_HOSTILE: [
ghost
for ghost, time in api.ghost_states_with_times(state)
if time <= Grid.GHOST_SAFE_TIME
],
Dispositions.GHOST_EDIBLE: [
ghost
for ghost, time in api.ghost_states_with_times(state)
if time > Grid.GHOST_SAFE_TIME
],
}
for disposition, coordinates in points.iteritems():
for x, y in coordinates:
if disposition in {Dispositions.FOOD, Dispositions.CAPSULE}:
Grid.FILL_COUNT += 1
coordinate = Coordinate(x, y) # because ghost x, y are floats
self[coordinate].disposition = disposition
for coordinate, point in self:
point.min_ghost_distance = Point.min_distance(
coordinate, points[Dispositions.GHOST_HOSTILE]
)
MDPAgent.set_gamma(len(api.food(state) + api.capsules(state)))
def getAction(self, state):
pacman = api.whereAmI(state)
x = pacman[0]
y = pacman[1]
food = api.food(state)
capsule = api.capsules(state)
# Get the actions we can try, and remove "STOP" if that is one of them.
legal = state.getLegalPacmanActions()
walls = api.walls(state)
q = Queue.Queue()
if Directions.STOP in legal:
legal.remove(Directions.STOP)
if Directions.WEST in legal:
#print "West"
q.put(((x-1,y), Directions.WEST))
if Directions.EAST in legal:
#print "East"
q.put(((x+1,y), Directions.EAST))
if Directions.NORTH in legal:
#print "North"
q.put(((x,y+1), Directions.NORTH))
if Directions.SOUTH in legal:
#print "South"
q.put(((x,y-1), Directions.SOUTH))
#print food
#print q.toString()
while not q.empty():
possible = q.get()
position = possible[0]
x = position[0]
y = position[1]
print position
if position in (food or capsules):
print "moving"
return api.makeMove(possible[1], legal)
else:
#print "searching"
if (x-1,y) not in walls:
q.put(((x-1,y), possible[1]))
if (x+1,y) not in walls:
q.put(((x+1,y), possible[1]))
if (x,y+1) not in walls:
q.put(((x,y+1), possible[1]))
if (x,y-1) not in walls:
q.put(((x,y-1), possible[1]))
def updateMap(self, state):
ghost = api.ghosts(state)
ghostStates = api.ghostStates(state)
capsule = api.capsules(state)
food = api.food(state)
wall = api.walls(state)
for node in self.mapDictionary:
if node in wall:
self.mapDictionary.update({node: 'X'})
return self.mapDictionary
def initialize(self, state):
#sets the reward of each grid
self.reward = None
#set the utility of each grid
self.utility = None
# get location of all visible food
foods = api.food(state)
#get location of all corners
corners = api.corners(state)
#get location of all visible capsules
capsules = api.capsules(state)
#get location of all visible walls
walls = api.walls(state)
#get pacmans position
pacman = api.whereAmI(state)
#pacman's x position
pacmanX = pacman[0]
#pacman's y position
pacmanY = pacman[1]
#if the internal map has not been initialized
if self.reward == None and self.utility == None:
#finds the dimension of the map by location the extremes, in this case the corners
width = 0
height = 0
for corner in corners:
if corner[0] > width:
width = corner[0]
if corner[1] > height:
height = corner[1]
#once the size of the map has been identified, initialize the rewards of each position with the approriate value
self.reward = [[self.baseReward for y in range(height+1)] for x in range(width+1)]
#do the same with the utility, however with random values between 0 and 1
self.utility = [[random() for y in range(height+1)] for x in range(width+1)]
#now add in all the information pacman knows initially. starting with all known locations of food
for food in foods:
#set the reward of food to the value defined above
self.reward[food[0]][food[1]] = self.foodReward
#self.utility[food[0]][food[1]] = self.foodReward
#set the reward of capsules with the reward defined above
for capsule in capsules:
self.reward[capsule[0]][capsule[1]] = self.capsuleReward
#self.utility[capsule[0]][capsule[1]] = self.capsuleReward
#now mark the location of the walls on the map, using "W"
for wall in walls:
self.reward[wall[0]][wall[1]] = "W"
self.utility[wall[0]][wall[1]] = "W"
#set init to true as the map has been initialized
self.init = True
def addConsumablesToMap(self, state):
# First, make all grid elements that aren't walls blank.
for i in range(self.map.getWidth()):
for j in range(self.map.getHeight()):
if self.map.getValue(i, j) != '%':
self.map.setValue(i, j, 0)
food = api.food(state)
for i in range(len(food)):
self.map.setValue(food[i][0], food[i][1], 5)
bigPillEnergy = api.capsules(state)
for i in range(len(bigPillEnergy)):
self.map.setValue(bigPillEnergy[i][0],bigPillEnergy[i][1],15)
self.dankMap = self.map
def updateMap(self, state):
corners = api.corners(state)
ghosts = api.ghosts(state)
me = api.whereAmI(state)
walls = api.walls(state)
capsules = api.capsules(state)
foods = api.food(state)
# Width and Height of Map
width, height = corners[3][0] + 1, corners[3][1] + 1
# Generate empty world Map
if (self.worldMap is None):
self.worldMap = [[[' ', self.emptyReward, 0, Directions.STOP]
for x in range(width)] for y in range(height)]
self.setMap(me[0], me[1], ['M', self.meReward, 0, Directions.STOP])
for food in foods:
self.setMap(food[0], food[1],
['F', self.foodReward, 0, Directions.STOP])
for capsule in capsules:
self.setMap(capsule[0], capsule[1],
['C', self.capsuleReward, 0, Directions.STOP])
for wall in walls:
self.setMap(wall[0], wall[1],
['W', self.wallReward, 0, Directions.STOP])
for ghost in ghosts:
self.setMap(ghost[0], ghost[1],
['G', self.ghostReward, 0, Directions.STOP])
else:
self.clearMapKeepState(state)
self.setThing(me[1], me[0], 'M')
for food in foods:
self.setThing(food[1], food[0], 'F')
for capsule in capsules:
self.setThing(capsule[1], capsule[0], 'C')
for wall in walls:
self.setThing(wall[1], wall[0], 'W')
for ghost in ghosts:
self.setThing(ghost[1], ghost[0], 'G')
self.setReward(me[0], me[1], self.meReward)
for food in foods:
self.setReward(food[0], food[1], self.foodReward)
for capsule in capsules:
self.setReward(capsule[0], capsule[1], self.capsuleReward)
for wall in walls:
self.setReward(wall[0], wall[1], self.wallReward)
for ghost in ghosts:
self.setReward(ghost[0], ghost[1], self.ghostReward)
def getAction(self, state):
legal = api.legalActions(state)
if Directions.STOP in legal:
legal.remove(Directions.STOP)
coners = api.corners(state)
pacman = api.whereAmI(state)
food = api.food(state)
Capsules = api.capsules(state)
ghosts = api.ghosts(state)
if len(self.detected) == 0:
self.states.push((pacman, Directions.STOP))
if not self.states.isEmpty():
self.detected.append(pacman)
success_node = []
for directs in legal:
if directs == Directions.WEST:
success_node.append((pacman[0] - 1, pacman[1]))
if directs == Directions.EAST:
success_node.append((pacman[0] + 1, pacman[1]))
if directs == Directions.NORTH:
success_node.append((pacman[0], pacman[1] + 1))
if directs == Directions.SOUTH:
success_node.append((pacman[0], pacman[1] - 1))
for index in range(len(success_node)):
if not success_node[index] in self.detected and (
success_node[index] in food
or success_node[index] in Capsules):
self.states.push((success_node[index], legal[index]))
return (api.makeMove(legal[index], legal))
last, acted = self.states.pop()
if acted == Directions.NORTH:
return (api.makeMove(Directions.SOUTH, legal))
if acted == Directions.SOUTH:
return (api.makeMove(Directions.NORTH, legal))
if acted == Directions.WEST:
return (api.makeMove(Directions.EAST, legal))
if acted == Directions.EAST:
return (api.makeMove(Directions.WEST, legal))
return (api.makeMove(Directions.STOP, legal))
def addFoodInMap(self, state):
# First, make all grid elements that aren't walls with a reward - 0.02.
[
self.map.setValue(i, j, ('-0.02', 0))
for i in range(self.map.getWidth())
for j in range(self.map.getHeight())
]
food = api.food(state)
food += api.capsules(state)
self.initialFood = len(food)
map(
lambda i: self.map.setValue(food[i][0], food[i][1],
(self.initialFood, 0)),
range(len(food)))
def initialize(self, state):
#print "initializing map"
#sets the path of pacman to be empty
self.path = []
#sets the internal map of pacman to be empty
self.map = None
# get location of all visible food
foods = api.food(state)
#get location of all corners
corners = api.corners(state)
#get location of all visible capsules
capsules = api.capsules(state)
# Get the actions we can try, and remove "STOP" if that is one of them.
#get location of all visible walls
walls = api.walls(state)
#get pacmans position
pacman = api.whereAmI(state)
pacmanX = pacman[0]
pacmanY = pacman[1]
#if the internal map has not been initialized
if self.map == None:
#finds the dimension of the map by location the extremes, in this case the corners
width = 0
height = 0
for corner in corners:
if corner[0] > width:
width = corner[0]
if corner[1] > height:
height = corner[1]
#once the size of the map has been identified, fill it up with "?", as pacman does not know what is in there
self.map = [["?" for y in range(height+1)] for x in range(width+1)]
#now add in all the information pacman knows initially. starting with all known locations of food
for food in foods:
#use "F" to mark food on the map
self.map[food[0]][food[1]] = "F"
#now mark the location of capsules on the map, this time using "C"
for capsule in capsules:
self.map[capsule[0]][capsule[1]] = "C"
#now mark the location of the walls on the map, using "W"
for wall in walls:
self.map[wall[0]][wall[1]] = "W"
#last pacman knows where it is, so mark that as "P"
self.map[pacmanX][pacmanY] = "P"
#set init to true as the map has been initialized
self.init = True
def bellmanUpdate(
self, state
): #preforms bellmans over the entire map using bellmans equation on each cell
ghostList = api.ghosts(state)
foodList = api.food(state)
wallList = api.walls(state)
scaredTime = api.ghostStatesWithTimes(state)[0][1]
capsuleList = api.capsules(state)
width = self.map.width
height = self.map.height
done = False
while not done: #loops over map preforming bellmans until previous map from the last iteration is equal to the map at the end of the new iteration
oldMap = deepcopy(self.map)
for x in range(0, width):
for y in range(0, height):
if oldMap[x][y] != None:
bestUtil = -1000
moves = [
oldMap[x][y + 1], oldMap[x + 1][y],
oldMap[x][y - 1], oldMap[x - 1][y]
] # list of all possible moves from the current cell
for i in range(
len(moves)
): # finds the best util possible based on all legal moves to uses in value iteration
if moves[i] != None:
tutil = moves[i] * 0.8
if moves[i - 1] != None:
tutil += moves[i - 1] * 0.1
else:
tutil += oldMap[x][y] * 0.1
if moves[(i + 1) % 4] != None:
tutil += moves[(i + 1) % 4] * 0.1
else:
tutil += oldMap[x][y] * 0.1
if tutil > bestUtil:
bestUtil = deepcopy(tutil)
self.map[x][y] = (bestUtil * 0.9) + self.reward(
x, y, state, ghostList, foodList, capsuleList,
scaredTime,
wallList) #bellmans equation using rewards functon
done = self.checkSame(
oldMap, self.map
) #checks to see whether old map is the same as new map
def initialize(self, state):
#sets the reward of each grid
self.reward = None
#set the utility of each grid
self.utility = None
# get location of all visible food
foods = api.food(state)
#get location of all corners
corners = api.corners(state)
#get location of all visible capsules
capsules = api.capsules(state)
#get location of all visible walls
walls = api.walls(state)
#get pacmans position
pacman = api.whereAmI(state)
pacmanX = pacman[0]
pacmanY = pacman[1]
#if the internal map has not been initialized
if self.reward == None and self.utility == None:
#finds the dimension of the map by location the extremes, in this case the corners
width = 0
height = 0
for corner in corners:
if corner[0] > width:
width = corner[0]
if corner[1] > height:
height = corner[1]
#once the size of the map has been identified, fill it up with "?", as pacman does not know what is in there
self.reward = [[-1 for y in range(height + 1)]
for x in range(width + 1)]
self.utility = [[random() for y in range(height + 1)]
for x in range(width + 1)]
#now add in all the information pacman knows initially. starting with all known locations of food
for food in foods:
#use "F" to mark food on the map
self.reward[food[0]][food[1]] = 10
#now mark the location of capsules on the map, this time using "C"
for capsule in capsules:
self.reward[capsule[0]][capsule[1]] = 5
#now mark the location of the walls on the map, using "W"
for wall in walls:
self.reward[wall[0]][wall[1]] = "W"
self.utility[wall[0]][wall[1]] = "W"
#set init to true as the map has been initialized
self.init = True
def updatefood(self, state):
foodloc = tuple(api.food(state))
capsules = api.capsules(state)
# initially assigning same values to all places in the map
for i in range(len(self.pcMap)):
self.valueMap[self.pcMap[i]] = 0
# Assign values in the map based on the objects present in the map
for i in range(len(self.pcMap)):
# Assign for Food
if self.pcMap[i] in foodloc:
self.valueMap[self.pcMap[i]] = 1
# Assign for Capsules
if self.pcMap[i] in capsules:
self.valueMap[self.pcMap[i]] = 2
def initialRewardMap(self, state):
foods = api.food(state)
ghosts = map(lambda x: ((int(x[0][0]), int(x[0][1])), x[1]),
self.current_ghosts_states)
capsules = api.capsules(state)
pacman = api.whereAmI(state)
# find the real distance for ghosts to every points and take the minimum distance between different ghosts
if ghosts:
walkDistanceMapOfGhosts = self.getGhostWalkDistance(
tuple(map(int, ghosts[-1][0])), self.ghosts_facing[-1],
ghosts[-1][1])
else:
walkDistanceMapOfGhosts = Grid(self.reward_map.getWidth(),
self.reward_map.getHeight())
for ghost in ghosts[0:-1]:
walkDistanceMapOfGhosts = walkDistanceMapOfGhosts.minimumValueOnMap(
self.getGhostWalkDistance(
tuple(map(int, ghost[0])),
self.ghosts_facing[ghosts.index(ghost)], ghost[1]))
# the distance between pacman and ghost
distance_pacman_to_ghost = walkDistanceMapOfGhosts.getValue(
pacman[0], pacman[1])
# smallGird
if self.is_small_grid:
# max ghost distance 17
# if the pacman is too close the ghost the pacman will try the closest food
# otherwise eat the food in bottom left
if distance_pacman_to_ghost <= 2:
self.rewardMapFunction(foods, capsules,
map(lambda x: x[0], ghosts),
walkDistanceMapOfGhosts, 1, 2, 1, 3, -5)
else:
self.rewardMapFunction([foods[0]], capsules,
map(lambda x: x[0], ghosts),
walkDistanceMapOfGhosts, 1, 2, 1, 3, -3)
else:
self.rewardMapFunction(foods, capsules,
map(lambda x: x[0], ghosts),
walkDistanceMapOfGhosts, 0, 1.5, 2, 12, -5)
# delete the distance map
del walkDistanceMapOfGhosts
def createMap(
self, state
): #initialises the 3 maps that will be used throughout the solver
ghostList = api.ghosts(state)
wallList = api.walls(state)
foodList = api.food(state)
capsuleList = api.capsules(state)
#creates three maps, self.map will be the main map that holds utility, grassfireMap1 will be the distance between the first ghost and each food, grassfireMap2 does the samething but with the second ghost
self.map = deepcopy(state.getFood())
self.grassfireMap1 = deepcopy(self.map)
self.grassfireMap2 = deepcopy(self.map)
width = self.map.width
height = self.map.height
#initialises each map wall = None, every other cell is 0 for the main map and -5 for the ghost-food distance map
for x in range(width):
for y in range(height):
if (x, y) in wallList:
self.map[x][y] = None
self.grassfireMap1[x][y] = None
self.grassfireMap2[x][y] = None
elif (x, y) in foodList:
self.map[x][y] = 0
self.grassfireMap1[x][y] = -5
self.grassfireMap2[x][y] = -5
elif (x, y) in ghostList:
self.map[x][y] = 0
self.grassfireMap1[x][y] = -5
self.grassfireMap2[x][y] = -5
elif (x, y) in capsuleList:
self.map[x][y] = 0
self.grassfireMap1[x][y] = -5
self.grassfireMap2[x][y] = -5
else:
self.map[x][y] = 0
self.grassfireMap1[x][y] = -5
self.grassfireMap2[x][y] = -5
#iterates over each ghost and updates each map accordingly using grass fire algorithm
i = 0
for ghost in ghostList:
self.grassfire(ghost[0], ghost[1], wallList, i)
i += 1
def updateMap(self, state):
# get location of all visible food
foods = api.food(state)
#get location of all visible capsules
capsules = api.capsules(state)
#get location of all visible walls
walls = api.walls(state)
#now add in all the information pacman knows initially. starting with all known locations of food
for food in foods:
#use "F" to mark food on the map
self.reward[food[0]][food[1]] = 10
#now mark the location of capsules on the map, this time using "C"
for capsule in capsules:
self.reward[capsule[0]][capsule[1]] = 5
#now mark the location of the walls on the map, using "W"
for wall in walls:
self.reward[wall[0]][wall[1]] = "W"
self.utility[wall[0]][wall[1]] = "W"
def __init__(self, state):
# The constructor identifies the size of the map through the corners, and then calls a number of functions
# that begin to populate the detail of the map
TR = self.getCorners(api.corners(state))[
3] # Capture the TR coordinate for map building
width = TR[0] + 2
height = TR[1] + 2
self.width = width
self.height = height
self.matrix = [[0 for x in range(width)] for y in range(height)]
# We call these functions to populate the map with walls, food, capsules and ghosts
self.assignWalls(api.walls(state))
self.assignFood(api.food(state))
self.assignCapsules(api.capsules(state))
self.assignGhosts(api.ghosts(state))
# We call this function to create a list of locations that should be iterated. (i.e. not walls)
self.identifyLocationsToIterate()
def getValueMap(self, state, reward):
"""
This method helps to map rewards to the state of each grid that contains food
It gives each coordinate of food an R(s) value
It also updates each coordinate of food to no reward when it finds
that Pacman has already eaten it
This is the initial state that will have to be value-iterated for each change in state
of ghost and pacman
returns a dictionary of coordinates and their assigned utility values
"""
pacman = api.whereAmI(state)
food = api.food(state)
capsules = api.capsules(state)
self.reward = reward
if pacman not in self.visited:
self.visited.append(pacman)
for i in food:
if i not in self.foodMap:
self.foodMap.append(i)
foodsMap = dict.fromkeys(self.foodMap, self.reward)
# make a dictionary of capsules and give a reward value of 0 since it's neutral
capsuleMap = dict.fromkeys(capsules, 0)
#join these two together to get a complete map of legal squares
valueMap = {}
valueMap.update(foodsMap)
valueMap.update(capsuleMap)
#Check: If key in food-list is in visited list,
#Set value of food in valueMap dictionary to 0
#update value of the dictionary key
for key in self.foodMap:
if key in self.visited:
valueMap[key] = 0
return valueMap
def map_reward(self, state, size):
weight_reward = {}
(map_x, map_y) = size
wall = api.walls(state)
food = api.food(state)
ghost = api.ghosts(state)
capsule = api.capsules(state)
for i in range(map_x + 1):
for j in range(map_y + 1):
if (i, j) in food:
weight_reward[(i, j)] = self.weight_food
elif (i, j) in capsule:
weight_reward[(i, j)] = self.weight_capsule
elif (i, j) in wall:
weight_reward[(i, j)] = self.weight_wall
elif (i, j) in ghost:
weight_reward[(i, j)] = self.weight_blank
else:
weight_reward[(i, j)] = self.weight_blank
return weight_reward
def valIterS (self,state,discount,reward):
pacman = api.whereAmI(state)
walls= api.walls(state)
food = api.food(state)
ghosts = api.ghosts(state)
bigPillEnergy = api.capsules(state)
corners = api.corners(state)
for i in range(self.getLayoutWidth(corners) - 1):
for j in range (self.getLayoutHeight(corners) - 1):
if (i,j) not in walls and (i,j)not in ghosts and (i,j) not in bigPillEnergy and (i,j) not in food:
if len(food)<=1:
u = self.MaxU(i,j)
#when the food is less 1 or 0 (could be pointless when it's 0 but just making sure),
# we want the pacman to eat the last food as soon as possible
else:
u = self.MinU(i,j)
# However, when the food is more than 1. Since it's a small grid, avoiding the ghost(s) is priority
bellman = reward + discount* u
self.dankMap.setValue(i,j,bellman)
def makeMap(self, state):
grid = []
self.valueMap = {}
foodloc = tuple(api.food(state))
corners = api.corners(state)
walls = api.walls(state)
capsules = api.capsules(state)
tempH = -1
tempW = -1
for i in range(len(corners)):
if corners[i][1] > tempH:
tempH = corners[i][1]
if corners[i][0] > tempW:
tempW = corners[i][0]
height = tempH + 1
width = tempW + 1
for i in range(width):
for j in range(height):
grid.append((i, j))
# creates a map where pacman can move around
self.pcMap = (tuple(set(grid) - set(walls)))
# print "pcMap",self.pcMap
# initially assigning same values to all places in the map
for i in range(len(self.pcMap)):
self.valueMap[self.pcMap[i]] = 0
# Assign values in the map based on the objects present in the map
for i in range(len(self.pcMap)):
#Assign for Food
if self.pcMap[i] in foodloc:
self.valueMap[self.pcMap[i]] = 1
#Assign for Capsules
if self.pcMap[i] in capsules:
self.valueMap[self.pcMap[i]] = 2
def foodWithinRange(self, state):
# Determines whether pacman can currently see food
cur = api.whereAmI(state)
foodAndCapsules = api.union(api.food(state), api.capsules(state))
for x in range(1, 6):
#Food seen south of pacman
if (cur[0], cur[1] - x) in foodAndCapsules:
return True
#Food seen west of pacman
if (cur[0] - x, cur[1]) in foodAndCapsules:
return True
#Food seen north of pacman
if (cur[0], cur[1] + x) in foodAndCapsules:
return True
#Food seen east of pacman
if (cur[0] + x, cur[1]) in foodAndCapsules:
return True
#No food seen
return False
def updateState(self, state):
# Update Legal Moves
self.legal = api.legalActions(state)
# Update Current Location
self.currentLocation = api.whereAmI(state)
# Update Position of Corners
self.corners = api.corners(state)
# Update Position of Food
self.foods = api.food(state)
# Update Position of Ghosts
self.ghosts = api.ghosts(state)
# Update Position of Capsules
self.capsules = api.capsules(state)
# Update Position of Walls
self.walls = api.walls(state)
def generateEntityGrid(self, state):
# initialize 2d array with correct dimensions from state
(w, h) = api.corners(state)[3]
entityGrid = [[" " for x in range(w + 1)] for y in range(h + 1)]
# populate known information
(x, y) = api.whereAmI(state)
entityGrid[y][x] = "p"
for (x, y) in api.food(state):
entityGrid[y][x] = "f"
for (x, y) in api.capsules(state):
entityGrid[y][x] = "c"
for (x, y) in api.ghosts(state):
entityGrid[int(y)][int(x)] = "g"
for (x, y) in api.walls(state):
entityGrid[y][x] = "w"
return entityGrid
