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)
reverse = Actions.reverseDirection(conf.direction)
if Directions.STOP in possibleActions:
possibleActions.remove(Directions.STOP)
if reverse in possibleActions and len(possibleActions) > 1:
possibleActions.remove(reverse)
return possibleActions
def getLegalActions(state):
"""
Returns a list of possible actions.
"""
return Actions.getPossibleActions(
state.getPacmanState().configuration, state.data.layout.walls
)
def get_action(self, game_state): # Read variables from state ghost_state = game_state.get_ghost_state(self.agent_idx) legal_actions = game_state.get_legal_actions(self.agent_idx) pos = game_state.get_ghost_position(self.agent_idx) is_scared = ghost_state.scared_timer > 0 action_vectors = [Actions.direction_to_vector(a) for a in legal_actions] new_positions = [(pos[0] + a[0], pos[1] + a[1]) for a in action_vectors] pacman_position = game_state.get_pacman_position() # Select best actions given the state distances_to_pacman = [manhattan_distance(pos, pacman_position) for pos in new_positions] if is_scared: best_score = max(distances_to_pacman) best_prob = self.prob_scared else: best_score = min(distances_to_pacman) best_prob = self.prob_attack best_actions = [action for action, distance in zip(legal_actions, distances_to_pacman) if distance == best_score] # choose action selection_prob = [0] * len(legal_actions) for idx, action in enumerate(legal_actions): if action in best_actions: selection_prob[idx] += best_prob / len(best_actions) selection_prob[idx] += (1 - best_prob) / len(legal_actions) action = np.random.choice(legal_actions, p = selection_prob) return action
def getLegalActions(state, agentIndex):
"""
Returns a list of legal actions (which are both possible & allowed)
"""
agentState = state.getAgentState(agentIndex)
conf = agentState.configuration
possibleActions = Actions.getPossibleActions(conf,
state.data.layout.walls)
if AgentRules.canFreeze(agentState):
possibleActions.append('FREEZE')
return AgentRules.filterForAllowedActions(agentState, possibleActions)
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))