def registerInitialState(self, gameState):
CaptureAgent.registerInitialState(self, gameState)
self.teamIndices = CaptureAgent.getTeam(
self,
gameState) #Array representing the indices of every ally Agent
self.opponentIndices = CaptureAgent.getOpponents(
self,
gameState) #Array representing the indices of every oponent Agent
if self.index == self.teamIndices[
0]: #Determine which index information about this Agent can be found. That includes who it's going after (if it's on defense) and where it is
self.teamOrder = 0
elif self.index == self.teamIndices[1]:
self.teamOrder = 1
position = gameState.getAgentPosition(
self.index
) #This figures out where the boundary between either side is
gameMap = gameState.getWalls()
boundary = gameMap.width / 2
if position[0] < boundary:
self.leftEdge = 0 #The farthest left the Agent can go and still be on it's home side
self.rightEdge = boundary #The farthest left the Agent can go and be on the opponent side
self.boundary = boundary - 1 #The place on the home side closest to the far side
else:
self.leftEdge = boundary #All these variables are the same as above.
self.rightEdge = gameMap.width
self.boundary = boundary
def registerInitialState(self, gameState):
CaptureAgent.registerInitialState(self, gameState)
self.myAgents = CaptureAgent.getTeam(self, gameState)
self.opponentsAgents = CaptureAgent.getOpponents(self, gameState)
self.myFoods = CaptureAgent.getFood(self, gameState).asList()
self.opponentsFoods = CaptureAgent.getFoodYouAreDefending(
self, gameState).asList()
def registerInitialState(self, gameState):
"""
This method handles the initial setup of the
agent to populate useful fields (such as what team
we're on).
A distanceCalculator instance caches the maze distances
between each pair of positions, so your agents can use:
self.distancer.getDistance(p1, p2)
IMPORTANT: This method may run for at most 15 seconds.
"""
'''
Make sure you do not delete the following line. If you would like to
use Manhattan distances instead of maze distances in order to save
on initialization time, please take a look at
CaptureAgent.registerInitialState in captureAgents.py.
'''
self.start = gameState.getAgentPosition(self.index)
self.team = CaptureAgent.getTeam(self, gameState)
self.food = CaptureAgent.getFood(self, gameState)
self.foodDefending = CaptureAgent.getFoodYouAreDefending(
self, gameState)
self.opponents = CaptureAgent.getOpponents(self, gameState)
print("Start: ", self.start, "Team: ", self.team, "Food: ", self.food,
"Food Defending:", self.foodDefending, "Opponent: ",
self.opponents)
CaptureAgent.registerInitialState(self, gameState)
'''
def getFeatures(self, gameState, action):
food = gameState.getBlueFood()
wall = gameState.getWalls()
ghosts = []
opponentAgents = CaptureAgent.getOpponents(self, gameState)
if opponentAgents:
for opponent in opponentAgents:
opponentPosition = gameState.getAgentPosition(opponent)
opponentIsPacman = gameState.getAgentState(opponent).isPacman
if opponentPosition and not opponentIsPacman:
ghosts.append(opponentPosition)
counter = util.Counter()
successor = self.getSuccessor(gameState, action)
counter['successorScore'] = self.getScore(successor)
counter["bias"] = 1.0
x, y = gameState.getAgentPosition(self.index)
dx, dy = Actions.directionToVector(action)
nextX, nextY = int(x + dx), int(y + dy)
counter["ghost1Away"] = sum(
(nextX, nextY) in Actions.getLegalNeighbors(g, wall)
for g in ghosts)
if not counter["ghost1Away"] and food[nextX][nextY]:
counter["eatFood"] = 1.0
dist = self.closestFood((nextX, nextY), food, wall)
if dist is not None:
counter["closestPellet"] = float(dist) / (wall.width * wall.height)
counter.divideAll(10.0)
return counter
def getFeatures(self, gameState, action):
# Extract the grid of food and wall locations
if self.red:
food = gameState.getBlueFood()
else:
food = gameState.getRedFood()
walls = gameState.getWalls()
ghosts = []
opAgents = CaptureAgent.getOpponents(self, gameState)
# Get ghost locations and states if observable
if opAgents:
for opponent in opAgents:
opPos = gameState.getAgentPosition(opponent)
opIsPacman = gameState.getAgentState(opponent).isPacman
if opPos and not opIsPacman:
ghosts.append(opPos)
# Initialize features
features = util.Counter()
successor = self.getSuccessor(gameState, action)
# Successor Score
features['successorScore'] = self.getScore(successor)
# Bias
features["bias"] = 1.0
# compute the location of pacman after he takes the action
x, y = gameState.getAgentPosition(self.index)
dx, dy = Actions.directionToVector(action)
next_x, next_y = int(x + dx), int(y + dy)
# Number of Ghosts 1-step away
features["#-of-ghosts-1-step-away"] = sum(
(next_x, next_y) in Actions.getLegalNeighbors(g, walls)
for g in ghosts)
# if there is no danger of ghosts then add the food feature
if not features["#-of-ghosts-1-step-away"] and food[next_x][next_y]:
features["eats-food"] = 1.0
# Number of Ghosts scared
# features['#-of-scared-ghosts'] = sum(gameState.getAgentState(opponent).scaredTimer != 0 for opponent in opAgents)
# Closest food
dist = self.closestFood((next_x, next_y), food, walls)
if dist is not None:
# make the distance a number less than one otherwise the update
# will diverge wildly
features["closest-food"] = float(dist) / (walls.width *
walls.height)
# Normalize and return
features.divideAll(10.0)
return features
def getFeatures(self, gameState, action):
food = self.getFood(gameState)
walls = gameState.getWalls()
ghosts = []
opponents = CaptureAgent.getOpponents(self, gameState)
# Gets visible ghost locations and states
if opponents:
for opponent in opponents:
opp_pos = gameState.getAgentPosition(opponent)
op_is_pacman = gameState.getAgentState(opponent).isPacman
if opp_pos and not op_is_pacman:
ghosts.append(opp_pos)
# Initializes features
features = util.Counter()
successor = self.getSuccessor(gameState, action)
features['successorScore'] = self.getScore(successor)
features["bias"] = 1.0
# Computes the location of pacman after it takes the action
x, y = gameState.getAgentPosition(self.index)
dx, dy = Actions.directionToVector(action)
next_x, next_y = int(x + dx), int(y + dy)
# Number of ghosts 1-step away
features["#-of-ghosts-1-step-away"] = sum(
(next_x, next_y) in Actions.getLegalNeighbors(ghost, walls)
for ghost in ghosts)
myPos = gameState.getAgentState(self.index).getPosition()
# Check for ghosts & add the food feature
if not features["#-of-ghosts-1-step-away"] and food[next_x][next_y]:
features["eats-food"] = 1.0
# Finds closest food
dist = self.closestFood((next_x, next_y), food, walls)
if dist is not None:
features["closest-food"] = float(dist) / (walls.width *
walls.height)
if gameState.data.agentStates[self.index].numCarrying > 5:
print("Enough food! Going home...")
distHome = self.getMazeDistance(myPos, self.start)
features["eats-food"] = 0.0
features["go-home"] = distHome
# Normalizes all the features and returns
features.divideAll(10.0)
print(features)
return features
def registerInitialState(self, gameState): """ This method handles the initial setup of the agent to populate useful fields (such as what team we're on). """ CaptureAgent.registerInitialState(self, gameState) self.myAgents = CaptureAgent.getTeam(self, gameState) self.opAgents = CaptureAgent.getOpponents(self, gameState) self.myFoods = CaptureAgent.getFood(self, gameState).asList() self.opFoods = CaptureAgent.getFoodYouAreDefending(self, gameState).asList()
def aStarSearch(self, gameState, start, searchPos, foodOrGhost):
import util
# Initilization
opponentList = CaptureAgent.getOpponents(self, gameState)
getWalls = self.getDeepWalls(
) # get deep copy of teh walls and edit for walls
if foodOrGhost == 1: #1 = Food or capsule else ghost
for i in opponentList:
checkNone = gameState.getAgentPosition(i)
if checkNone is not None:
x, y = checkNone
getWalls[x][y] = True
adjacentNodes = util.PriorityQueue()
visitedNodes = [] #List holding nodes already visited
#Start by pushing the start node into the priority queue
adjacentNodes.push((start, [start], 0),
(0 + self.getMazeDistance(start, searchPos)))
#Pop the initial point from the priority queue
(state, goalDirection, cost) = adjacentNodes.pop()
#adding the point to the visited list
visitedNodes.append(
(state, cost + self.getMazeDistance(start, searchPos)))
while state != searchPos: #while we do not find the goal point
neighbours = Actions.getLegalNeighbors(
state, getWalls) #get the point's succesors
for node in neighbours:
visitedExist = False
totalCost = cost + 1
for (currentState, costToCurrentState) in visitedNodes:
# Check the closed list to find if there are any nodes at the same level with cost less than the total cost
if (node == currentState) and (costToCurrentState <=
totalCost):
visitedExist = True
break
if not visitedExist:
# push the point with priority num of its total cost
adjacentNodes.push(
(node, goalDirection + [node], cost + 1),
(cost + 1 + self.getMazeDistance(node, searchPos)))
visitedNodes.append(
(node, cost + 1)) # add this point to visited list
if (adjacentNodes.isEmpty()):
return 0
(state, goalDirection, cost) = adjacentNodes.pop()
return len(goalDirection)
def getFeatures(self, gameState, action):
features = util.Counter()
successor = self.getSuccessor(gameState, action)
opponentList = CaptureAgent.getOpponents(
self, gameState) # get opponents indices
foodList = self.getFood(successor).asList()
if (gameState.getAgentState(self.index).numCarrying <
4): # eat 4 food and submit to score
features['successorScore'] = -len(foodList)
else: # keep eating food
myPos = successor.getAgentState(self.index).getPosition()
defendFood = self.getFoodYouAreDefending(gameState).asList()
features['successorScore'] = -min(
[self.getMazeDistance(myPos, self.start)])
#calculating distance from the visible opponents
gDist = 0
minGhost = 9999
for i in opponentList:
checkNone = gameState.getAgentPosition(i)
if checkNone is not None:
myPos = successor.getAgentState(self.index).getPosition()
gDist = self.aStarSearch(gameState, myPos, checkNone, 0)
if gDist < 3:
if gDist < minGhost:
minGhost = gDist
if (minGhost == 9999): minGhost = 0
features['distanceToGhost'] = minGhost
# get the capsule a-star distance
capsule = self.getCapsules(gameState)
if len(capsule) != 0:
myPos = successor.getAgentState(self.index).getPosition()
features['distanceToCapsule'] = min([
self.aStarSearch(gameState, myPos, caps, 1) for caps in capsule
])
else:
features['distanceToCapsule'] = 0
# get food distance
myPos = successor.getAgentState(self.index).getPosition()
minDistance = min(
[self.aStarSearch(gameState, myPos, food, 1) for food in foodList])
features['distanceToFood'] = minDistance
return features
def registerInitialState(self, gameState):
CaptureAgent.registerInitialState(self, gameState)
self.teamIndices = CaptureAgent.getTeam(self, gameState)
self.opponentIndices = CaptureAgent.getOpponents(self, gameState)
self.enemyPos = [None, None]
position = gameState.getAgentPosition(
self.index
) #This figures out where the boundary between either side is
gameMap = gameState.getWalls()
boundary = gameMap.width / 2
if position[0] < boundary:
self.leftEdge = 0
self.rightEdge = boundary
else:
self.leftEdge = boundary
self.rightEdge = gameMap.width
def evalute_state_one_agent_defensive(self, agent_position, agent_index,
agent_is_on_enemy_team,
team_mate_position):
if self.check_if_valid_coordinates(self.root_agent_object.middle):
distance_to_middle_factor = CaptureAgent.getMazeDistance(
self.root_agent_object, agent_position,
self.root_agent_object.middle)
else:
distance_to_middle_factor = 0
if self.check_if_valid_coordinates(self.root_agent_object.upperHalf):
distance_to_upper_half = CaptureAgent.getMazeDistance(
self.root_agent_object, agent_position,
self.root_agent_object.upperHalf)
else:
distance_to_upper_half = 0
if self.check_if_valid_coordinates(self.root_agent_object.lowerHalf):
distance_to_lower_half = CaptureAgent.getMazeDistance(
self.root_agent_object, agent_position,
self.root_agent_object.lowerHalf)
else:
distance_to_lower_half = 0
enemies = [
self.node_state.getAgentState(i) for i in
CaptureAgent.getOpponents(self.root_agent_object, self.node_state)
]
invaders = [
a for a in enemies if a.isPacman and a.getPosition() != None
]
number_of_invaders = len(invaders)
invader_distance = 0
if len(invaders) > 0:
dists = [
CaptureAgent.getMazeDistance(self.root_agent_object,
agent_position, a.getPosition())
for a in invaders
]
invader_distance = min(dists)
distance_from_each_other = CaptureAgent.getMazeDistance(
self.root_agent_object, agent_position, team_mate_position)
state_value = number_of_invaders * (-9999) + invader_distance * (-1000) + distance_to_middle_factor * (-200) + \
distance_to_lower_half*(-50) + distance_to_upper_half*(-50) + distance_from_each_other * (200)
return state_value
def aStarSearch(self, gameState, start, searchPos, foodOrGhost):
import util
opponentList = CaptureAgent.getOpponents(self, gameState)
#getWalls1 = self.walls
getWalls = self.getDeepWalls()
if foodOrGhost == 1: #1 = Food or capsule else ghost
for i in opponentList:
checkNone = gameState.getAgentPosition(i)
if checkNone is not None:
x, y = checkNone
getWalls[x][y] = True
adjacentNodes = util.PriorityQueue()
visitedNodes = []
adjacentNodes.push((start, [start], 0),
(0 + self.getMazeDistance(start, searchPos)))
#Pop the initial point from the priority queue
(state, goalDirection, cost) = adjacentNodes.pop()
#adding the point to the visited list
visitedNodes.append(
(state, cost + self.getMazeDistance(start, searchPos)))
while state != searchPos: #while we do not find the goal point
neighbours = Actions.getLegalNeighbors(
state, self.walls) #get the point's succesors
for node in neighbours:
visitedExist = False
totalCost = cost + 1
for (currentState, costToCurrentState) in visitedNodes:
if (node == currentState) and (costToCurrentState <=
totalCost):
visitedExist = True
break
if not visitedExist:
adjacentNodes.push(
(node, goalDirection + [node], cost + 1),
(cost + 1 + self.getMazeDistance(node, searchPos)))
visitedNodes.append((node, cost + 1))
(state, goalDirection, cost) = adjacentNodes.pop()
return len(goalDirection)
def registerInitialState(self, gameState):
CaptureAgent.registerInitialState(self, gameState)
self.init = gameState.getAgentState(self.index).getPosition()
self.epsilon = 0.0#exploration prob
self.alpha = 0.1 #learning rate
self.discountRate = 0.8
self.dangeFood = []
self.mode = 1
self.weights1 = {'closest-food': 2.35219445732408, 'bias': 2.579502234147277, 'closest-capsule': 2.473714473123398}
self.weights2 = {'closest-food': 1.02910769618005556, 'bias': -6.112936837778204, 'closest-ghosts': -10.11587156566253, 'closest-capsule': 1.257363246901937, 'num-of-walls': -10.4903928122119086, 'time-of-scared-ghosts': 1.6265815562445105, 'reverse': -2.732599631268455}
self.weights3 = {'bias': -0.1619191782335229, 'closest-ghosts': -18.645334316865307, 'num-of-walls': -10.45335435502801, 'distance-back-to-home': 2.0996715469522775, 'time-of-scared-ghosts': 0.7966612961334337, 'reverse': -2.732599631268455,'closest-capsule': 4.523232232232323}
self.weights4 = {'bias': 6.802602309336149, 'distance-back-to-home': 12.7541385540534}
self.finish = False
self.myAgents = CaptureAgent.getTeam(self, gameState)
self.opAgents = CaptureAgent.getOpponents(self, gameState)
self.myFoods = CaptureAgent.getFood(self, gameState).asList()
self.opFoods = CaptureAgent.getFoodYouAreDefending(self, gameState).asList()
self.lostFoods = []
self.gamescore = 0
self.midWidth = gameState.data.layout.width / 2
self.height = gameState.data.layout.height
self.width = gameState.data.layout.width
self.midHeight = gameState.data.layout.height / 2
def getThirdFeatures(self, gameState, action):
nextState = self.getSuccessor(gameState, action)
self.ghosts = []
opAgents = CaptureAgent.getOpponents(self,nextState)
# Get ghost locations and states if observable
if opAgents:
for opponent in opAgents:
opPos = nextState.getAgentPosition(opponent)
opIsPacman = nextState.getAgentState(opponent).isPacman
if opPos and not opIsPacman:
currentPos = gameState.getAgentPosition(self.index)
nopPos = gameState.getAgentPosition(opponent)
dis = abs(currentPos[0]-nopPos[0])+abs(currentPos[1]-nopPos[1])
if dis<= 5:
ghost=[]
ghost.append(opPos)
ghost.append(opponent)
self.ghosts.append(ghost)
# Initialize features
features = util.Counter()
reverse = self.reverseDirection(action)
if reverse == gameState.getAgentState(self.index).configuration.direction:
features["reverse"]=1
# print("reverse")
else:
features["reverse"]=0
# print("notreverse")
# features['num-of-carry'] = nextState.getAgentState(self.index).numCarrying
if self.red:
self.middle = int((gameState.data.layout.width - 2)/2 )
else:
self.middle = int((gameState.data.layout.width - 2)/2 + 1)
self.boundary = []
for i in range(1, gameState.data.layout.height - 1):
if not gameState.hasWall(self.middle, i):
self.boundary.append((self.middle, i))
if gameState.getAgentState(self.index):
distance_to_boundary = 10000
for each in self.boundary:
distance = self.getMazeDistance(nextState.getAgentPosition(self.index),each)
if distance<distance_to_boundary:
distance_to_boundary = distance
if distance_to_boundary ==0:
features['distance-back-to-home']=2
else :
features['distance-back-to-home'] = 1.0/distance_to_boundary
else :
features['distance-back-to-home'] = 0
# Bias
features["bias"] = 1.0
legalActions = nextState.getLegalActions(self.index)
legalActions.remove(Directions.STOP)
features['num-of-walls'] = max(self.getDeathRoad(gameState,action),self.getDeathRound(gameState,action))
# compute the location of pacman after he takes the action
if(self.getDeathRoad(gameState,action)>=8):
food = self.getDeathFood(gameState,action)
for each in food:
if each[1]>5:
self.dangeFood.append(each[0])
if(len(self.getCapsules(nextState))>1):
if len(self.getCapsules(gameState))==len(self.getCapsules(nextState))+1:
features['closest-capsule']=2.0
else:
minCap = 10000
for each in self.getCapsules(nextState):
if minCap > self.getMazeDistance(nextState.getAgentPosition(self.index),each):
minCap = self.getMazeDistance(nextState.getAgentPosition(self.index),each)
features['closest-capsule'] = 1.0/minCap
elif(len(self.getCapsules(nextState))==1):
if len(self.getCapsules(gameState))==2:
features['closest-capsule']=2.0
else:
features['closest-capsule'] = 1.0/self.getMazeDistance(nextState.getAgentPosition(self.index),self.getCapsules(gameState)[0])
else:
if(len(self.getCapsules(gameState))>0):
features['closest-capsule']=2.0
else :
features['closest-capsule']=0.0
if len(self.ghosts)==0:
features['time-of-scared-ghosts']=0
features['closest-ghosts']=0
self.scareTimer = 0
else:
features['time-of-scared-ghosts'] = min(nextState.getAgentState(opponent).scaredTimer for opponent in opAgents)
if(min(nextState.getAgentState(opponent).scaredTimer for opponent in opAgents)>10):
self.scareTimer = 1
features['time-of-scared-ghosts']=1
else:
features['time-of-scared-ghosts']=0
self.scareTimer = 0
if len(self.ghosts)==1:
ghostIndex = self.ghosts[0][1]
pos = gameState.getAgentState(ghostIndex).getPosition()
nextpos = nextState.getAgentState(ghostIndex).getPosition()
posDis = self.getMazeDistance(gameState.getAgentState(self.index).getPosition(),pos)
nextDis = self.getMazeDistance(nextState.getAgentState(self.index).getPosition(),nextpos)
if abs(posDis-nextDis)>5:
# print("!!!!!!!!!!!!!!!!!!!!!!!!!!")
features['closest-ghosts'] = 2
# print("222222222222222222222")
else :
# print("333333333333333333")
features['closest-ghosts'] = 1.0/self.getMazeDistance(nextState.getAgentPosition(self.index),self.ghosts[0][0])
else:
ghostIndex1 = self.ghosts[0][1]
pos1 = gameState.getAgentState(ghostIndex1).getPosition()
nextpos1 = nextState.getAgentState(ghostIndex1).getPosition()
ghostIndex2 = self.ghosts[1][1]
pos2 = gameState.getAgentState(ghostIndex2).getPosition()
nextpos2 = nextState.getAgentState(ghostIndex2).getPosition()
posDis1 = self.getMazeDistance(gameState.getAgentState(self.index).getPosition(),pos1)
nextDis1 = self.getMazeDistance(nextState.getAgentState(self.index).getPosition(),nextpos1)
posDis2 = self.getMazeDistance(gameState.getAgentState(self.index).getPosition(),pos2)
nextDis2 = self.getMazeDistance(nextState.getAgentState(self.index).getPosition(),nextpos2)
if abs(posDis1-nextDis1)>5 or abs(posDis2-nextDis2)>5:
# print("!!!!!!!!!!!!!!!!!!!!!!!!!!")
features['closest-ghosts'] = 2
# print("222222222222222222222")
else :
# print("333333333333333333")
if posDis1==posDis2:
features['closest-ghosts'] = 1.0/(nextDis1+nextDis2)*2
else:
features['closest-ghosts'] = 1.0/min(nextDis1,nextDis2)
features.divideAll(100)
return features
def getSecondFeatures(self, gameState, action):
nextState = self.getSuccessor(gameState, action)
food = self.getFood(gameState)
nextfood = self.getFood(nextState)
walls = gameState.getWalls()
self.ghosts = []
opAgents = CaptureAgent.getOpponents(self,nextState)
# Get ghost locations and states if observable
if opAgents:
for opponent in opAgents:
opPos = nextState.getAgentPosition(opponent)
opIsPacman = nextState.getAgentState(opponent).isPacman
if opPos and not opIsPacman:
currentPos = gameState.getAgentPosition(self.index)
nopPos = gameState.getAgentPosition(opponent)
dis = abs(currentPos[0]-nopPos[0])+abs(currentPos[1]-nopPos[1])
if dis<= 5:
ghost=[]
ghost.append(opPos)
ghost.append(opponent)
self.ghosts.append(ghost)
# Initialize features
features = util.Counter()
reverse = self.reverseDirection(action)
if reverse == gameState.getAgentState(self.index).configuration.direction:
features["reverse"]=1
# print("reverse")
else:
features["reverse"]=0
# print("notreverse")
features["bias"] = 1.0
legalActions = nextState.getLegalActions(self.index)
legalActions.remove(Directions.STOP)
features['num-of-walls'] = max(self.getDeathRoad(gameState,action),self.getDeathRound(gameState,action))
if(self.getDeathRoad(gameState,action)>=8):
deathfood = self.getDeathFood(gameState,action)
for each in deathfood:
if each[1]>5:
self.dangeFood.append(each[0])
# compute the location of pacman after he takes the action
if len(self.ghosts)==0:
# print("0000000000000000000000000")
features['time-of-scared-ghosts']=0
features['closest-ghosts']=0
self.scareTimer = 0
else:
features['time-of-scared-ghosts'] = min(nextState.getAgentState(opponent).scaredTimer for opponent in opAgents)
if(min(nextState.getAgentState(opponent).scaredTimer for opponent in opAgents)>10):
self.scareTimer = 1
features['time-of-scared-ghosts']=1
else:
features['time-of-scared-ghosts']=0
self.scareTimer = 0
# print("next",nextState.getAgentState(self.ghosts[0][1]).getPosition()[0]," inital",nextState.getInitialAgentPosition(self.ghosts[0][1])[0])
if len(self.ghosts)==1:
ghostIndex = self.ghosts[0][1]
pos = gameState.getAgentState(ghostIndex).getPosition()
nextpos = nextState.getAgentState(ghostIndex).getPosition()
posDis = self.getMazeDistance(gameState.getAgentState(self.index).getPosition(),pos)
nextDis = self.getMazeDistance(nextState.getAgentState(self.index).getPosition(),nextpos)
if abs(posDis-nextDis)>5:
# print("!!!!!!!!!!!!!!!!!!!!!!!!!!")
features['closest-ghosts'] = 2
# print("222222222222222222222")
else :
# print("333333333333333333")
features['closest-ghosts'] = 1.0/nextDis
else:
ghostIndex1 = self.ghosts[0][1]
pos1 = gameState.getAgentState(ghostIndex1).getPosition()
nextpos1 = nextState.getAgentState(ghostIndex1).getPosition()
ghostIndex2 = self.ghosts[1][1]
pos2 = gameState.getAgentState(ghostIndex2).getPosition()
nextpos2 = nextState.getAgentState(ghostIndex2).getPosition()
posDis1 = self.getMazeDistance(gameState.getAgentState(self.index).getPosition(),pos1)
nextDis1 = self.getMazeDistance(nextState.getAgentState(self.index).getPosition(),nextpos1)
posDis2 = self.getMazeDistance(gameState.getAgentState(self.index).getPosition(),pos2)
nextDis2 = self.getMazeDistance(nextState.getAgentState(self.index).getPosition(),nextpos2)
if abs(posDis1-nextDis1)>5 or abs(posDis2-nextDis2)>5:
# print("!!!!!!!!!!!!!!!!!!!!!!!!!!")
features['closest-ghosts'] = 2
# print("222222222222222222222")
else :
# print("333333333333333333")
if posDis1==posDis2:
features['closest-ghosts'] = 1.0/(nextDis1+nextDis2)*2
else:
features['closest-ghosts'] = 1.0/min(nextDis1,nextDis2)
if(len(self.getCapsules(nextState))>1):
if len(self.getCapsules(gameState))==len(self.getCapsules(nextState))+1:
features['closest-capsule']=2.0
else:
minCap = 10000
for each in self.getCapsules(nextState):
if minCap > self.getMazeDistance(nextState.getAgentPosition(self.index),each):
minCap = self.getMazeDistance(nextState.getAgentPosition(self.index),each)
features['closest-capsule'] = 1.0/minCap
elif(len(self.getCapsules(nextState))==1):
if len(self.getCapsules(gameState))==2:
features['closest-capsule']=2.0
else:
features['closest-capsule'] = 1.0/self.getMazeDistance(nextState.getAgentPosition(self.index),self.getCapsules(gameState)[0])
else:
if(len(self.getCapsules(gameState))>0):
features['closest-capsule']=2.0
else :
features['closest-capsule']=0.0
# Closest food
# if len()
if self.index ==self.getTeam(gameState)[0]:
dist = self.halfUpperClosestFood(nextState.getAgentPosition(self.index), nextfood, walls,nextState)
if len(food.asList()) == len(nextfood.asList() ) and not dist ==0:
# make the distance a number less than one otherwise the update
# will diverge wildly
features["closest-food"] = 1.0/float(dist)
# print("The distance is",dist)
else :
features["closest-food"] = 2
else:
dist = self.halfLowerClosestFood(nextState.getAgentPosition(self.index), nextfood, walls,nextState)
if len(food.asList()) == len(nextfood.asList() ) and not dist ==0:
# make the distance a number less than one otherwise the update
# will diverge wildly
features["closest-food"] = 1.0/float(dist)
# print("The distance is",dist)
else :
features["closest-food"] = 2
features.divideAll(100)
return features
def chooseOfAction(self, gameState):
# Pick Action
ghost=[]
ghostIndex = 0
opAgents = CaptureAgent.getOpponents(self,gameState)
currentPos = gameState.getAgentPosition(self.index)
# Get ghost locations and states if observable
if opAgents:
for opponent in opAgents:
opPos = gameState.getAgentPosition(opponent)
opIsPacman = gameState.getAgentState(opponent).isPacman
if opPos and not opIsPacman:
dis = abs(currentPos[0]-opPos[0])+abs(currentPos[1]-opPos[1])
if dis<=6:
ghost.append(opPos)
ghostIndex = opponent
if len(self.getFood(gameState).asList())>2:
if len(ghost) ==0 :
if gameState.getAgentState(self.index).numCarrying>1 and gameState.data.timeleft<200:
self.weights =self.weights4
print("444444444444444444444")
else:
self.weights = self.weights1
print("111111111111111111111")
else:
if min([self.getMazeDistance(gameState.getAgentPosition(self.index),a) for a in ghost])>6:
self.weights = self.weights1
print("111111111111111111111")
else:
if gameState.getAgentState(ghostIndex).scaredTimer<10:
if gameState.data.timeleft<200 :
if gameState.getAgentState(self.index).numCarrying>2:
self.weights = self.weights3
print("33333333333333333333")
else:
self.weights = self.weights2
print("2222222222222222222222")
else:
if gameState.getAgentState(self.index).numCarrying>10:
if self.red:
middle = int((gameState.data.layout.width - 2)/2 )
else:
middle = int((gameState.data.layout.width - 2)/2 + 1)
if abs(gameState.getAgentPosition(self.index)[0]-middle) < middle/2:
self.weights = self.weights3
print("33333333333333333333")
else :
self.weights = self.weights2
print("2222222222222222222222")
else:
self.weights = self.weights2
print("2222222222222222222222")
else :
self.weights = self.weights1
print("111111111111111111111")
else :
if len(ghost) ==0:
self.weights = self.weights4
print("44444444444444444444")
else:
if gameState.getAgentState(ghostIndex).scaredTimer<10:
self.weights = self.weights3
print("33333333333333333333")
else:
self.weights = self.weights4
print("44444444444444444444")
legalActions = gameState.getLegalActions(self.index)
legalActions.remove(Directions.STOP)
action = None
if len(legalActions) != 0:
prob = util.flipCoin(self.epsilon)
if prob:
action = random.choice(legalActions)
else:
if self.weights ==self.weights1:
action = self.getSafePolicy(gameState)
else:
action = self.getPolicy(gameState)
if self.weights == self.weights2:
food = self.getFeatures(gameState,action)["closest-food"]
ghost = self.getFeatures(gameState,action)["closest-ghosts"]
print(food*100,ghost*100)
if not gameState.getAgentState(self.index).isPacman:
if self.red:
if self.finish:
self.mode =2
else:
if self.finish:
self.mode = 2
return action
