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):
        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 _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 _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")