if self.carrying:
if self.carrying.color == self.targetColor and \
self.carrying.type == self.targetType:
reward = self._reward()
done = True
else:
reward = 0
done = True
return obs, reward, done, info
class FetchEnv5x5N2(FetchEnv):
def __init__(self):
super().__init__(size=5, numObjs=2)
class FetchEnv6x6N2(FetchEnv):
def __init__(self):
super().__init__(size=6, numObjs=2)
register(id='MiniGrid-Fetch-5x5-N2-v0',
entry_point='envs.gym_minigrid.envs:FetchEnv5x5N2')
register(id='MiniGrid-Fetch-6x6-N2-v0',
entry_point='envs.gym_minigrid.envs:FetchEnv6x6N2')
register(id='MiniGrid-Fetch-8x8-N3-v0',
entry_point='envs.gym_minigrid.envs:FetchEnv')
class LavaCrossingS9N2Env(CrossingEnv):
def __init__(self):
super().__init__(size=9, num_crossings=2)
class LavaCrossingS9N3Env(CrossingEnv):
def __init__(self):
super().__init__(size=9, num_crossings=3)
class LavaCrossingS11N5Env(CrossingEnv):
def __init__(self):
super().__init__(size=11, num_crossings=5)
register(id='MiniGrid-LavaCrossingS9N1-v0',
entry_point='envs.gym_minigrid.envs:LavaCrossingEnv')
register(id='MiniGrid-LavaCrossingS9N2-v0',
entry_point='envs.gym_minigrid.envs:LavaCrossingS9N2Env')
register(id='MiniGrid-LavaCrossingS9N3-v0',
entry_point='envs.gym_minigrid.envs:LavaCrossingS9N3Env')
register(id='MiniGrid-LavaCrossingS11N5-v0',
entry_point='envs.gym_minigrid.envs:LavaCrossingS11N5Env')
class SimpleCrossingEnv(CrossingEnv):
def __init__(self):
super().__init__(size=9, num_crossings=1, obstacle_type=Wall)
if room.locked:
self.grid.set(*room.doorPos, Door(color, is_locked=True))
else:
self.grid.set(*room.doorPos, Door(color))
# Select a random room to contain the key
while True:
keyRoom = self._rand_elem(self.rooms)
if keyRoom != lockedRoom:
break
keyPos = keyRoom.rand_pos(self)
self.grid.set(*keyPos, Key(lockedRoom.color))
# Randomize the player start position and orientation
self.start_pos = self.place_agent(top=(lWallIdx, 0),
size=(rWallIdx - lWallIdx, height))
# Generate the mission string
self.mission = ('get the %s key from the %s room, '
'unlock the %s door and '
'go to the goal') % (lockedRoom.color, keyRoom.color,
lockedRoom.color)
def step(self, action):
obs, reward, done, info = MiniGridEnv.step(self, action)
return obs, reward, done, info
register(id='MiniGrid-LockedRoom-v0',
entry_point='envs.gym_minigrid.envs:LockedRoom')
ox, oy = (self.agent_pos[0] + u, self.agent_pos[1] + v)
tx, ty = self.target_pos
# If we picked up the wrong object, terminate the episode
if action == self.actions.pickup and self.carrying:
if self.carrying.type != self.move_type or self.carrying.color != self.moveColor:
done = True
# If successfully dropping an object near the target
if action == self.actions.drop and preCarrying:
if self.grid.get(ox, oy) is preCarrying:
if abs(ox - tx) <= 1 and abs(oy - ty) <= 1:
reward = self._reward()
done = True
return obs, reward, done, info
class PutNear8x8N3(PutNearEnv):
def __init__(self):
super().__init__(size=8, numObjs=3)
register(
id='MiniGrid-PutNear-6x6-N2-v0',
entry_point='envs.gym_minigrid.envs:PutNearEnv'
)
register(
id='MiniGrid-PutNear-8x8-N3-v0',
entry_point='envs.gym_minigrid.envs:PutNear8x8N3'
)
num_cols=2,
room_size=room_size,
max_steps=8 * room_size**2,
seed=seed)
def _gen_grid(self, width, height):
super()._gen_grid(width, height)
# Make sure the two rooms are directly connected by a locked door
door, _ = self.add_door(0, 0, 0, locked=True)
# Add a key to unlock the door
self.add_object(0, 0, 'key', door.color)
self.place_agent(0, 0)
self.door = door
self.mission = "open the door"
def step(self, action):
obs, reward, done, info = super().step(action)
if action == self.actions.toggle:
if self.door.is_open:
reward = self._reward()
done = True
return obs, reward, done, info
register(id='MiniGrid-Unlock-v0', entry_point='envs.gym_minigrid.envs:Unlock')
class KeyCorridorS4R3(KeyCorridor):
def __init__(self, seed=None):
super().__init__(room_size=4, num_rows=3, seed=seed)
class KeyCorridorS5R3(KeyCorridor):
def __init__(self, seed=None):
super().__init__(room_size=5, num_rows=3, seed=seed)
class KeyCorridorS6R3(KeyCorridor):
def __init__(self, seed=None):
super().__init__(room_size=6, num_rows=3, seed=seed)
register(id='MiniGrid-KeyCorridorS3R1-v0',
entry_point='envs.gym_minigrid.envs:KeyCorridorS3R1')
register(id='MiniGrid-KeyCorridorS3R2-v0',
entry_point='envs.gym_minigrid.envs:KeyCorridorS3R2')
register(id='MiniGrid-KeyCorridorS3R3-v0',
entry_point='envs.gym_minigrid.envs:KeyCorridorS3R3')
register(id='MiniGrid-KeyCorridorS4R3-v0',
entry_point='envs.gym_minigrid.envs:KeyCorridorS4R3')
register(id='MiniGrid-KeyCorridorS5R3-v0',
entry_point='envs.gym_minigrid.envs:KeyCorridorS5R3')
register(id='MiniGrid-KeyCorridorS6R3-v0',
entry_point='envs.gym_minigrid.envs:KeyCorridorS6R3')
if j + 1 < 2:
self.grid.horz_wall(xL, yB, room_w)
pos = (self._rand_int(xL + 1, xR), yB)
self.grid.set(*pos, None)
# Randomize the player start position and orientation
if self._agent_default_pos is not None:
self.start_pos = self._agent_default_pos
self.grid.set(*self._agent_default_pos, None)
self.start_dir = self._rand_int(
0, 4) # assuming random start direction
else:
self.place_agent()
if self._goal_default_pos is not None:
goal = Goal()
self.grid.set(*self._goal_default_pos, goal)
goal.init_pos, goal.cur_pos = self._goal_default_pos
else:
self.place_obj(Goal())
self.mission = 'Reach the goal'
def step(self, action):
obs, reward, done, info = MiniGridEnv.step(self, action)
return obs, reward, done, info
register(id='MiniGrid-FourRooms-v0',
entry_point='envs.gym_minigrid.envs:FourRoomsEnv')
def step(self, action):
obs, reward, done, info = MiniGridEnv.step(self, action)
ax, ay = self.agent_pos
tx, ty = self.target_pos
# Toggle/pickup action terminates the episode
if action == self.actions.toggle:
done = True
# Reward performing the done action next to the target object
if action == self.actions.done:
if abs(ax - tx) <= 1 and abs(ay - ty) <= 1:
reward = self._reward()
done = True
return obs, reward, done, info
class GotoEnv8x8N2(GoToObjectEnv):
def __init__(self):
super().__init__(size=8, numObjs=2)
register(id='MiniGrid-GoToObject-6x6-N2-v0',
entry_point='envs.gym_minigrid.envs:GoToObjectEnv')
register(id='MiniGrid-GoToObject-8x8-N2-v0',
entry_point='envs.gym_minigrid.envs:GotoEnv8x8N2')
class DynamicObstaclesEnv6x6(DynamicObstaclesEnv):
def __init__(self):
super().__init__(size=6, n_obstacles=3)
class DynamicObstaclesRandomEnv6x6(DynamicObstaclesEnv):
def __init__(self):
super().__init__(size=6, agent_start_pos=None, n_obstacles=3)
class DynamicObstaclesEnv16x16(DynamicObstaclesEnv):
def __init__(self):
super().__init__(size=16, n_obstacles=8)
register(id='MiniGrid-Dynamic-Obstacles-5x5-v0',
entry_point='envs.gym_minigrid.envs:DynamicObstaclesEnv5x5')
register(id='MiniGrid-Dynamic-Obstacles-Random-5x5-v0',
entry_point='envs.gym_minigrid.envs:DynamicObstaclesRandomEnv5x5')
register(id='MiniGrid-Dynamic-Obstacles-6x6-v0',
entry_point='envs.gym_minigrid.envs:DynamicObstaclesEnv6x6')
register(id='MiniGrid-Dynamic-Obstacles-Random-6x6-v0',
entry_point='envs.gym_minigrid.envs:DynamicObstaclesRandomEnv6x6')
register(id='MiniGrid-Dynamic-Obstacles-8x8-v0',
entry_point='envs.gym_minigrid.envs:DynamicObstaclesEnv')
register(id='MiniGrid-Dynamic-Obstacles-16x16-v0',
entry_point='envs.gym_minigrid.envs:DynamicObstaclesEnv16x16')
self.mission = "use the key to open the door and then get to the goal"
class DoorKeyEnv5x5(DoorKeyEnv):
def __init__(self):
super().__init__(size=5)
class DoorKeyEnv6x6(DoorKeyEnv):
def __init__(self):
super().__init__(size=6)
class DoorKeyEnv16x16(DoorKeyEnv):
def __init__(self):
super().__init__(size=16)
register(
id='MiniGrid-DoorKey-5x5-v0',
entry_point='envs.gym_minigrid.envs:DoorKeyEnv5x5'
)
register(
id='MiniGrid-DoorKey-6x6-v0',
entry_point='envs.gym_minigrid.envs:DoorKeyEnv6x6'
)
register(
id='MiniGrid-DoorKey-8x8-v0',
entry_point='envs.gym_minigrid.envs:DoorKeyEnv'
)
register(
id='MiniGrid-DoorKey-16x16-v0',
entry_point='envs.gym_minigrid.envs:DoorKeyEnv16x16'
super()._gen_grid(width, height)
# Add a box to the room on the right
obj, _ = self.add_object(1, 0, kind="box")
# Make sure the two rooms are directly connected by a locked door
door, pos = self.add_door(0, 0, 0, locked=True)
# Block the door with a ball
color = self._rand_color()
self.grid.set(pos[0] - 1, pos[1], Ball(color))
# Add a key to unlock the door
self.add_object(0, 0, 'key', door.color)
self.place_agent(0, 0)
self.obj = obj
self.mission = "pick up the %s %s" % (obj.color, obj.type)
def step(self, action):
obs, reward, done, info = super().step(action)
if action == self.actions.pickup:
if self.carrying and self.carrying == self.obj:
reward = self._reward()
done = True
return obs, reward, done, info
register(id='MiniGrid-BlockedUnlockPickup-v0',
entry_point='envs.gym_minigrid.envs:BlockedUnlockPickup')
success = self._placeRoom(numLeft - 1,
roomList=roomList,
minSz=minSz,
maxSz=maxSz,
entryDoorWall=nextEntryWall,
entryDoorPos=exitDoorPos)
if success:
break
return True
class MultiRoomEnvN2S4(MultiRoomEnv):
def __init__(self):
super().__init__(minNumRooms=2, maxNumRooms=2, maxRoomSize=4)
class MultiRoomEnvN6(MultiRoomEnv):
def __init__(self):
super().__init__(minNumRooms=6, maxNumRooms=6)
register(id='MiniGrid-MultiRoom-N2-S4-v0',
entry_point='envs.gym_minigrid.envs:MultiRoomEnvN2S4',
reward_threshold=1000.0)
register(id='MiniGrid-MultiRoom-N6-v0',
entry_point='envs.gym_minigrid.envs:MultiRoomEnvN6',
reward_threshold=1000.0)
reward = self._reward()
done = True
if tuple(self.agent_pos) == self.failure_pos:
reward = 0
done = True
return obs, reward, done, info
class MemoryS17Random(MemoryEnv):
def __init__(self, seed=None):
super().__init__(seed=seed, size=17, random_length=True)
register(
id='MiniGrid-MemoryS17Random-v0',
entry_point='envs.gym_minigrid.envs:MemoryS17Random',
)
class MemoryS13Random(MemoryEnv):
def __init__(self, seed=None):
super().__init__(seed=seed, size=13, random_length=True)
register(
id='MiniGrid-MemoryS13Random-v0',
entry_point='envs.gym_minigrid.envs:MemoryS13Random',
)
class MemoryS13(MemoryEnv):
pos = (self._rand_int(xL + 1, xR - 1), yB)
color = self._rand_elem(COLOR_NAMES)
self.grid.set(*pos, Door(color))
# Randomize the player start position and orientation
self.place_agent()
# Place random objects in the world
types = ['key', 'ball', 'box']
for i in range(0, 12):
objType = self._rand_elem(types)
objColor = self._rand_elem(COLOR_NAMES)
if objType == 'key':
obj = Key(objColor)
elif objType == 'ball':
obj = Ball(objColor)
elif objType == 'box':
obj = Box(objColor)
self.place_obj(obj)
# No explicit mission in this environment
self.mission = ''
def step(self, action):
obs, reward, done, info = MiniGridEnv.step(self, action)
return obs, reward, done, info
register(id='MiniGrid-Playground-v0',
entry_point='envs.gym_minigrid.envs:PlaygroundV0')
class EmptyEnv16x16(EmptyEnv):
def __init__(self):
super().__init__(size=16)
class EmptyRandomEnv16x16(EmptyEnv):
def __init__(self):
super().__init__(size=16, agent_start_pos=None)
class EmptyRandomEnv80x80(EmptyEnv):
def __init__(self):
super().__init__(size=80, agent_start_pos=None)
register(id='MiniGrid-Empty-5x5-v0',
entry_point='envs.gym_minigrid.envs:EmptyEnv5x5')
register(id='MiniGrid-Empty-Random-5x5-v0',
entry_point='envs.gym_minigrid.envs:EmptyRandomEnv5x5')
register(id='MiniGrid-Empty-6x6-v0',
entry_point='envs.gym_minigrid.envs:EmptyEnv6x6')
register(id='MiniGrid-Empty-Random-6x6-v0',
entry_point='envs.gym_minigrid.envs:EmptyRandomEnv6x6')
register(id='MiniGrid-Empty-8x8-v0',
entry_point='envs.gym_minigrid.envs:EmptyEnv')
register(id='MiniGrid-Empty-16x16-v0',
entry_point='envs.gym_minigrid.envs:EmptyEnv16x16')
class ObstructedMaze_2Dlhb(ObstructedMaze_Full):
def __init__(self, seed=None):
super().__init__((2, 1), True, True, 1, 4, seed)
class ObstructedMaze_1Q(ObstructedMaze_Full):
def __init__(self, seed=None):
super().__init__((1, 1), True, True, 1, 5, seed)
class ObstructedMaze_2Q(ObstructedMaze_Full):
def __init__(self, seed=None):
super().__init__((1, 1), True, True, 2, 11, seed)
register(id="MiniGrid-ObstructedMaze-1Dl-v0",
entry_point="envs.gym_minigrid.envs:ObstructedMaze_1Dl")
register(id="MiniGrid-ObstructedMaze-1Dlh-v0",
entry_point="envs.gym_minigrid.envs:ObstructedMaze_1Dlh")
register(id="MiniGrid-ObstructedMaze-1Dlhb-v0",
entry_point="envs.gym_minigrid.envs:ObstructedMaze_1Dlhb")
register(id="MiniGrid-ObstructedMaze-2Dl-v0",
entry_point="envs.gym_minigrid.envs:ObstructedMaze_2Dl")
register(id="MiniGrid-ObstructedMaze-2Dlh-v0",
entry_point="envs.gym_minigrid.envs:ObstructedMaze_2Dlh")
register(id="MiniGrid-ObstructedMaze-2Dlhb-v0",
entry_point="envs.gym_minigrid.envs:ObstructedMaze_2Dlhb")
# Place the lava rows
for i in range(self.width - 6):
self.grid.set(3 + i, 1, Lava())
self.grid.set(3 + i, self.strip2_row, Lava())
# Place the agent
if self.agent_start_pos is not None:
self.start_pos = self.agent_start_pos
self.start_dir = self.agent_start_dir
else:
self.place_agent()
self.mission = "get to the green goal square"
class DistShift1(DistShiftEnv):
def __init__(self):
super().__init__(strip2_row=2)
class DistShift2(DistShiftEnv):
def __init__(self):
super().__init__(strip2_row=5)
register(id='MiniGrid-DistShift1-v0',
entry_point='envs.gym_minigrid.envs:DistShift1')
register(id='MiniGrid-DistShift2-v0',
entry_point='envs.gym_minigrid.envs:DistShift2')
