def _reset(self):
super(PushBlock, self)._reset()
self.sw_loc = choice(creationutils.empty_locations(self))
self.sw = mi.Switch(location=self.sw_loc)
self._add_item(self.sw)
x, y = choice(creationutils.empty_locations(self))
self.pushable = mi.Pushable(location=(x, y))
self._add_item(self.pushable)
visited, p = creationutils.dijkstra(self, (x, y),
creationutils.pushblock_movefunc)
if self.sw_loc not in visited:
raise MazeException("No path to sw")
self.waypoints = pbwps(p, self.pushable.location, self.sw.location)
x, y = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block]))
self.agent = PushBlockAgent(location=(x, y))
self._add_agent(self.agent, "PushBlockAgent")
visited, _ = creationutils.dijkstra(self, (x, y),
creationutils.agent_movefunc)
if self.waypoints[0] not in visited:
raise MazeException("No path to pushblock")
def _reset(self):
super(Exclusion, self)._reset()
if self.visit_min < 1:
raise MazeException("visit_min is not >= 1")
if self.visit_max == -1:
self.visit_max = self.n_goals
self.visit = list(range(self.n_goals))
shuffle(self.visit)
to_visit = randint(self.visit_min, self.visit_max)
self.exclude = self.visit[to_visit:]
self.visit = self.visit[:to_visit]
self.visit = dict((x, False) for x in self.visit)
self.goals = []
for i in range(self.n_goals):
x, y = choice(creationutils.empty_locations(self))
self.goals.append(mi.Goal(location=(x, y), id=i))
self._add_item(self.goals[i])
x, y = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block]))
self.agent = TogglingAgent(location=(x, y))
self._add_agent(self.agent, "ExclusionAgent")
visited, _ = creationutils.dijkstra(self, (x, y),
creationutils.agent_movefunc)
if not all(goal.location in visited for goal in self.goals):
raise MazeException("No path to goal")
def _reset(self):
super(ConditionedGoals, self)._reset()
x, y = choice(creationutils.empty_locations(self))
self.sw = mi.Switch(
location=(x, y),
nstates=self.n_colors,
start_state=choice(range(self.n_colors)),
)
self._add_item(self.sw)
self.goals = []
for i in range(self.n_goals):
x, y = choice(creationutils.empty_locations(self))
self.goals.append(mi.Goal(location=(x, y), id=i))
self._add_item(self.goals[i])
self.conditions = [randint(0, self.n_goals - 1) for _ in self.goals]
x, y = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block]))
self.agent = TogglingAgent(location=(x, y))
self._add_agent(self.agent, "ConditionedGoalsAgent")
visited, _ = creationutils.dijkstra(self, (x, y),
creationutils.agent_movefunc)
if (self.sw.location not in visited
or not any(self.goals[i].location in visited
for i in set(self.conditions))):
raise MazeException("No path to goal")
def _reset(self):
hole, dim = add_vertical_wall(self)
# Add the pushblock
self.pushable = mi.Pushable(location=hole)
self._add_item(self.pushable)
# Add additional blocks and waters
super(BlockedDoor, self)._reset()
# Add the goal, and agent
loc = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block,
mi.Door]))
self.goal = mi.Goal(location=loc)
self._add_item(self.goal)
loc = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block,
mi.Door]))
self.agent = PushBlockAgent(location=loc)
self._add_agent(self.agent, "BlockedDoorAgent")
self._remove_item(self.pushable.id)
visited, _ = creationutils.dijkstra(self, loc,
creationutils.agent_movefunc)
if self.goal.location not in visited:
raise MazeException("No path to goal")
self._add_item(self.pushable)
def _reset(self):
super(PushBlockCardinal, self)._reset()
x, y = choice(creationutils.empty_locations(self))
self.pushable = mi.Pushable(location=(x, y))
self._add_item(self.pushable)
self.direction = choice([
self.FEATURE.UP,
self.FEATURE.DOWN,
self.FEATURE.LEFT,
self.FEATURE.RIGHT,
])
if self.direction == self.FEATURE.UP:
self.goals = set((i, self.height) for i in range(self.width))
elif self.direction == self.FEATURE.DOWN:
self.goals = set((i, 0) for i in range(self.width))
elif self.direction == self.FEATURE.LEFT:
self.goals = set((0, i) for i in range(self.height))
elif self.direction == self.FEATURE.RIGHT:
self.goals = set((self.width, i) for i in range(self.height))
visited, p = creationutils.dijkstra(self, (x, y),
creationutils.pushblock_movefunc)
if not any(x in visited for x in self.goals):
raise MazeException("No path to goal")
closest = min(self.goals, key=lambda loc: visited[loc])
self.waypoints = pbwps(p, self.pushable.location, closest)
x, y = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block]))
self.agent = PushBlockAgent(location=(x, y))
self._add_agent(self.agent, "PushBlockCardinalAgent")
def _reset(self):
intersection, holes = add_4_walls(self)
# No doors for now
# self.door = mi.Door(location=hole,
# state=choice(range(1, self.switch_states)))
# self._add_item(self.door)
# ad blocks on the holes temporarily
blocked_holes = []
for i in range(len(holes)):
blocked_holes.append(mi.Block(location= holes[i]))
self._add_item(blocked_holes[i])
# Add additional blocks and waters
# only blocks and water have reset methods, and that sprinkles blocs and waters around
super(TrapKey, self)._reset()
# empty the wall opening if they have been blocked
for i in range(len(holes)):
self._remove_item(blocked_holes[i].id)
# Add the goal
loc = choice(creationutils.empty_locations(
self, bad_blocks=[mi.Block, mi.Trap, mi.Water])) # bad blocks where the goal can't be placed
self.goal = mi.Goal(location=loc)
self._add_item(self.goal)
# # no switches for now
# side = choice([-1, 1])
# # for adding switch to the opposite side of the goal
# def mask_func(x, y):
# return side * ((x, y)[1 - dim] - hole[1 - dim]) > 0
# loc = choice(creationutils.empty_locations(
# self, bad_blocks=[mi.Block, mi.Door, mi.Goal], mask=mask_func))
# self.sw = mi.Switch(location=loc, nstates=self.switch_states)
# self._add_item(self.sw)
# add agent
loc = choice(creationutils.empty_locations(
self, bad_blocks=[mi.Block, mi.Trap]))
self.agent = TriggerAgent(location=loc)
self._add_agent(self.agent, "TrapKeyAgent")
# check if goal can be visited or not
visited, _ = creationutils.dijkstra(self, loc,
creationutils.agent_movefunc)
if self.goal.location not in visited :
raise MazeException("No path to goal")
def _reset(self):
super(SingleGoal, self)._reset()
loc = choice(creationutils.empty_locations(self))
self.goal = mi.Goal(location=loc)
self._add_item(self.goal)
loc = choice(creationutils.empty_locations(self,
bad_blocks=[mi.Block]))
self.agent = MovingAgent(location=loc)
self._add_agent(self.agent, "SingleGoalAgent")
visited, _ = creationutils.dijkstra(self, loc,
creationutils.agent_movefunc)
if self.goal.location not in visited:
raise MazeException("No path to goal")
def _get_placement_locs(self, agent_loc, n_required):
for _ in range(10):
visited, _ = creationutils.dijkstra(self, agent_loc,
creationutils.agent_movefunc)
empty_locs = set(
creationutils.empty_locations(
self, bad_blocks=[maze_items.Block, TaxiAgent]))
reachable_locs = list(empty_locs & set(visited))
n_lack = max(n_required - len(reachable_locs), 0)
if n_lack == 0:
break
self._remove_adjacent_blocks(reachable_locs + [
agent_loc,
], n_lack)
else:
raise MazeException('There is no enough space to place game items')
return reachable_locs
def _reset(self):
super(MultiGoals, self)._reset()
self.goals = []
for i in range(self.n_goals):
x, y = choice(creationutils.empty_locations(self))
self.goals.append(mi.Goal(location=(x, y), id=i))
self._add_item(self.goals[i])
shuffle(self.goals)
self.v = 0
x, y = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block]))
self.agent = MovingAgent(location=(x, y))
self._add_agent(self.agent, "MultiGoalsAgent")
visited, _ = creationutils.dijkstra(self, (x, y),
creationutils.agent_movefunc)
if not all(goal.location in visited for goal in self.goals):
raise MazeException("No path to goal")
def _reset(self):
super(GotoHidden, self)._reset()
self.goals = []
for i in range(self.n_goals):
x, y = choice(creationutils.empty_locations(self))
self.goals.append(mi.Goal(location=(x, y), id=i, visible=False))
self._add_item(self.goals[i])
self.goal = choice(self.goals)
x, y = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block]))
self.agent = MovingAgent(location=(x, y))
self._add_agent(self.agent, "GotoHiddenAgent")
visited, _ = creationutils.dijkstra(self, (x, y),
creationutils.agent_movefunc)
if self.goal.location not in visited:
raise MazeException("No path to goal")
def _reset(self):
hole, dim = add_vertical_wall(self)
# Add the door
self.door = mi.Door(location=hole,
state=choice(range(1, self.switch_states)))
self._add_item(self.door)
# Add additional blocks and waters
super(LightKey, self)._reset()
# Add the goal, agent, and switch
loc = choice(
creationutils.empty_locations(self, bad_blocks=[mi.Block,
mi.Door]))
self.goal = mi.Goal(location=loc)
self._add_item(self.goal)
side = choice([-1, 1])
def mask_func(x, y):
return side * ((x, y)[1 - dim] - hole[1 - dim]) > 0
loc = choice(
creationutils.empty_locations(
self, bad_blocks=[mi.Block, mi.Door, mi.Goal], mask=mask_func))
self.sw = mi.Switch(location=loc, nstates=self.switch_states)
self._add_item(self.sw)
loc = choice(
creationutils.empty_locations(self,
bad_blocks=[mi.Block, mi.Door],
mask=mask_func))
self.agent = SwitchesAgent(location=loc)
self._add_agent(self.agent, "LightKeyAgent")
visited, _ = creationutils.dijkstra(self, loc,
creationutils.agent_movefunc)
if self.goal.location not in visited or self.sw.location not in visited:
raise MazeException("No path to goal")
def _calculate_approximate_reward(self):
'''Greedy solution that visits each switch in turn'''
best = 1e100
sw_colors = [sw.state for sw in self._switches]
print(sw_colors)
for i, sw in enumerate(self._switches):
tmp = [(sw.state - c) % self.switch_states for c in sw_colors]
# Heuristic for perferring not needing to flip switches
best = min(best, sum(x if x > 0 else -2 for x in tmp))
to_visit = [sw.location for sw in self._switches]
loc = self.agent.location
r = 0
for i, sw in enumerate(self._switches):
visited, path = creationutils.dijkstra(
self, loc, creationutils.agent_movefunc, True)
ind, loc = min(enumerate(to_visit), key=lambda x: visited[x[1]])
r -= visited[loc] # Reward is negative of path
to_visit.remove(loc)
return super(Switches,
self)._calculate_approximate_reward() + \
r - best * self.turn_penalty
def _reset(self):
super(Switches, self)._reset()
loc = choice(creationutils.empty_locations(self,
bad_blocks=[mi.Block]))
self.agent = SwitchesAgent(location=loc)
self._add_agent(self.agent, "SwitchesAgent")
visited, _ = creationutils.dijkstra(self, loc,
creationutils.agent_movefunc)
self._switches = []
for _ in range(self.n_switches):
loc = choice(creationutils.empty_locations(self))
self._switches.append(
mi.Switch(
location=loc,
nstates=self.switch_states,
start_state=choice(range(self.switch_states)),
))
self._add_item(self._switches[-1])
if loc not in visited:
raise MazeException("No path to goal")
def _est(game, s, e):
'''shorthand to estimate reward for an agent to move from s to e'''
visited, path = creationutils.dijkstra(
game, s, creationutils.agent_movefunc, True)
return -visited[e] # Returns distance, which is negation of reward