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):
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(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):
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 _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 _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 add_vertical_wall(game):
size = (game.width, game.height)
dim = choice([0, 1])
line = randint(1, size[1 - dim] - 2)
opening = randint(0, size[dim] - 1)
for i in range(size[dim]):
if i != opening:
loc = [line, line]
loc[dim] = i
game._add_item(mi.Block(location=loc))
loc = [line, line]
loc[dim] = opening
return loc, dim
def _reset(self):
super(TaxiGame, self)._reset()
agent_loc = choice(
creationutils.empty_locations(self, bad_blocks=[maze_items.Block]))
self.agent = self.agent_cls(location=agent_loc)
self._add_agent(self.agent, "TaxiAgent")
n_items = 2
placement_locs = self._get_placement_locs(agent_loc, n_items)
target_loc, psg_loc = rnd.sample(placement_locs, n_items)
self.target = maze_items.Goal(location=target_loc)
self._add_item(self.target)
self.passenger = Passenger(location=psg_loc)
self._add_item(self.passenger)
self.episode_steps = 0
def _reset(self):
super(TaxiMultiTask, self)._reset()
#print('=============RESET====================')
self.current_task = None
n_items = 2 #passenger, target
loc_agent = choice(
creationutils.empty_locations(self, bad_blocks=[maze_items.Block]))
self.agent = self.agent_cls(location=loc_agent)
self._add_agent(self.agent, "TaxiAgent")
placement_locs = self._get_placement_locs(loc_agent, n_items)
loc_target, loc_pass = rnd.sample(placement_locs, n_items)
init_state, tasks = self._get_new_config()
# check relationship between locations of the passenger and the taxi locations
if init_state.pRt == Relation.FAR:
self.passenger = Passenger(location=loc_pass)
self._add_item(self.passenger)
else:
self.passenger = Passenger(location=loc_agent)
self._add_item(self.passenger)
if init_state.pRt == Relation.INSIDE:
self.agent.actions['pickup']()
assert self.passenger.is_pickedup, "Can't put a passenger into a taxi for init_state={}".format(
init_state)
self.target = maze_items.Goal(location=loc_target)
self._add_item(self.target)
self.current_task = 0
self.episode_steps = 0
detailed_state = dict(loc_a=self.agent.location,
loc_p=self.passenger.location,
loc_t=self.target.location,
is_picked_up=self.passenger.is_pickedup)
self.current_config = MultiTaskEpisodeConfig(init_state=detailed_state,
tasks=tasks)
def _get_new_config(self, params=None):
return choice(self.episode_configs)