def applyAction(state, action, ghostIndex):
legal = GhostRules.getLegalActions(state, ghostIndex)
if action not in legal:
raise Exception("Illegal ghost action " + str(action))
ghostState = state.data.agentStates[ghostIndex]
speed = GhostRules.GHOST_SPEED
if ghostState.scaredTimer > 0:
speed /= 2.0
vector = Actions.directionToVector(action, speed)
ghostState.configuration = ghostState.configuration.generateSuccessor(vector)
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 applyAction(state, action):
"""
Edits the state to reflect the results of the action.
"""
legal = PacmanRules.getLegalActions(state)
if action not in legal:
raise Exception("Illegal action " + str(action))
pacmanState = state.data.agentStates[0]
# Update Configuration
vector = Actions.directionToVector(action, PacmanRules.PACMAN_SPEED)
pacmanState.configuration = pacmanState.configuration.generateSuccessor(vector)
# Eat
next = pacmanState.configuration.getPosition()
nearest = nearestPoint(next)
if manhattanDistance(nearest, next) <= 0.5:
# Remove food
PacmanRules.consume(nearest, state)
def applyAction(state, action, agentIndex):
"""
Edits the state to reflect the results of the action.
"""
legal = AgentRules.getLegalActions(state, agentIndex)
if action not in legal:
action = 'STOP'
cost = Costs[action]
state.data.scoreChange += -cost if state.isOnRedTeam(
agentIndex) else cost
if action == 'FROZEN' or action == 'STOP':
return
if action == 'FREEZE':
agentState = state.data.agentStates[agentIndex]
agentState.freezeTimer = 0
position = agentState.configuration.getPosition()
for index in range(state.getNumAgents()):
if index == agentIndex:
continue
otherAgentState = state.data.agentStates[index]
otherPosition = otherAgentState.getPosition()
if otherPosition != None and manhattanDistance(
otherPosition, position) <= 3:
otherAgentState.frozenTimer = FROZEN_TIME
else:
# Update Configuration
agentState = state.data.agentStates[agentIndex]
# Jump Cooldown
if "Jump_" in action:
agentState.jumpTimer = 0
speed = 1.0
# if agentState.isPacman: speed = 0.5
vector = Actions.directionToVector(action, speed)
oldConfig = agentState.configuration
agentState.configuration = oldConfig.generateSuccessor(vector)
# Eat
next = agentState.configuration.getPosition()
nearest = nearestPoint(next)
if next == nearest:
isRed = state.isOnRedTeam(agentIndex)
# Change agent type
agentState.isPacman = [
isRed, state.isRed(agentState.configuration)
].count(True) == 1
# if he's no longer pacman, he's on his own side, so reset the num carrying timer
#agentState.numCarrying *= int(agentState.isPacman)
if agentState.numCarrying > 0 and not agentState.isPacman:
score = agentState.numCarrying if isRed else -1 * agentState.numCarrying
state.data.scoreChange += score
agentState.numReturned += agentState.numCarrying
agentState.numCarrying = 0
redCount = 0
blueCount = 0
for index in range(state.getNumAgents()):
agentState = state.data.agentStates[index]
if index in state.getRedTeamIndices():
redCount += agentState.numReturned
else:
blueCount += agentState.numReturned
if redCount >= (TOTAL_FOOD /
2) - MIN_FOOD or blueCount >= (
TOTAL_FOOD / 2) - MIN_FOOD:
state.data._win = True
if agentState.isPacman and manhattanDistance(nearest, next) <= 0.9:
AgentRules.consume(nearest, state,
state.isOnRedTeam(agentIndex))