def build_world_step(self, env, floor, floor_size):
env.metadata['box_size'] = self.box_size
self.curr_n_boxes = env._random_state.randint(self.n_boxes[0],
self.n_boxes[1] + 1)
env.metadata['curr_n_boxes'] = np.zeros((self.n_boxes[1]))
env.metadata['curr_n_boxes'][:self.curr_n_boxes] = 1
env.metadata['curr_n_boxes'] = env.metadata['curr_n_boxes'].astype(
np.bool)
self.curr_n_elongated_boxes = env._random_state.randint(
self.n_elongated_boxes[0],
min(self.n_elongated_boxes[1], self.curr_n_boxes) + 1)
self.box_size_array = self.box_size * np.ones((self.curr_n_boxes, 3))
if self.curr_n_elongated_boxes > 0:
# sample number of x-aligned boxes
n_xaligned = env._random_state.randint(
self.curr_n_elongated_boxes + 1)
self.box_size_array[:n_xaligned, :] = self.box_size * np.array(
[3.3, 0.3, 1.0])
self.box_size_array[n_xaligned:self.curr_n_elongated_boxes, :] = (
self.box_size * np.array([0.3, 3.3, 1.0]))
env.metadata['box_size_array'] = self.box_size_array
successful_placement = True
for i in range(self.curr_n_boxes):
char = chr(ord('A') + i % 26)
geom = Geom("box",
self.box_size_array[i, :],
name=f'moveable_box{i}')
geom.set_material(Material(texture="chars/" + char + ".png"))
geom.add_transform(set_geom_attr_transform('mass', self.box_mass))
if self.mark_box_corners:
for j, (x, y) in enumerate([[0, 0], [0, 1], [1, 0], [1, 1]]):
geom.mark(f'moveable_box{i}_corner{j}',
relative_xyz=(x, y, 0.5),
rgba=[1., 1., 1., 0.])
if self.friction is not None:
geom.add_transform(
set_geom_attr_transform('friction', self.friction))
if self.box_only_z_rot:
geom.add_transform(
remove_hinge_axis_transform(np.array([1.0, 0.0, 0.0])))
geom.add_transform(
remove_hinge_axis_transform(np.array([0.0, 1.0, 0.0])))
if self.placement_fn is not None:
_placement_fn = (self.placement_fn[i] if isinstance(
self.placement_fn, list) else self.placement_fn)
pos, _ = rejection_placement(env, _placement_fn, floor_size,
self.box_size_array[i, :2])
if pos is not None:
floor.append(geom, placement_xy=pos)
else:
successful_placement = False
else:
floor.append(geom)
return successful_placement
def build_world_step(self, env, floor, floor_size):
env.metadata['n_agents'] = self.n_agents
successful_placement = True
for i in range(self.n_agents):
env.metadata.pop(f"agent{i}_initpos", None)
for i in range(self.n_agents):
obj = ObjFromXML("particle_hinge", name=f"agent{i}")
if self.friction is not None:
obj.add_transform(
set_geom_attr_transform('friction', self.friction))
if self.color is not None:
_color = (self.color[i] if isinstance(
self.color[0], (list, tuple, np.ndarray)) else self.color)
obj.add_transform(set_geom_attr_transform('rgba', _color))
if not self.damp_z:
obj.add_transform(set_joint_damping_transform(1, 'tz'))
if self.placement_fn is not None:
_placement_fn = (self.placement_fn[i] if isinstance(
self.placement_fn, list) else self.placement_fn)
obj_size = get_size_from_xml(obj)
pos, pos_grid = rejection_placement(env, _placement_fn,
floor_size, obj_size)
if pos is not None:
floor.append(obj, placement_xy=pos)
# store spawn position in metadata. This allows sampling subsequent agents
# close to previous agents
env.metadata[f"agent{i}_initpos"] = pos_grid
else:
successful_placement = False
else:
floor.append(obj)
return successful_placement
def walls_to_mujoco(floor, floor_size, grid_size, walls, friction=None):
'''
Take a list of walls in grid frame and add them to the floor in the worldgen frame.
Args:
floor (worldgen.Floor): floor
floor_size (float): size of floor
grid_size (int): size of placement grid
walls (Wall list): list of walls
friction (float): wall friction
'''
wall_width = floor_size / grid_size / 2
grid_cell_length = floor_size / grid_size
for i, wall in enumerate(walls):
if wall.is_vertical:
wall_length_grid = (wall.pt2[1] - wall.pt1[1] + 1)
offset = np.array([-1, 1])
else:
wall_length_grid = (wall.pt2[0] - wall.pt1[0] + 1)
offset = np.array([1, -1])
# Convert to mujoco frame
wall_length = wall_length_grid * grid_cell_length
# Subtract 1 grid_cell_length such that walls originate and end in the center of a grid cell
# Subtract 1 wall_width such that perpendicular walls do not intersect at the center of a
# grid cell
wall_length -= grid_cell_length + wall_width
if wall.is_vertical:
size = (wall_width, wall_length, wall.height)
else:
size = (wall_length, wall_width, wall.height)
# Position of object should be in the middle of a grid cell (add 0.5) shifted by
# the wall width such that corners don't overlap
pos = np.array([wall.pt1[0] + 0.5, wall.pt1[1] + 0.5]) / grid_size
pos += offset * wall_width / floor_size / 2
# Convert from mujoco to worldgen scale
scale_x = (floor_size - size[0]) / floor_size
scale_y = (floor_size - size[1]) / floor_size
pos = pos / np.array([scale_x, scale_y])
geom = Geom('box', size, name=f"wall{i}")
geom.mark_static()
geom.add_transform(set_geom_attr_transform('rgba', wall.rgba))
geom.add_transform(set_geom_attr_transform('group', 1))
if friction is not None:
geom.add_transform(set_geom_attr_transform('friction', friction))
floor.append(geom, placement_xy=pos)
def build_world_step(self, env, floor, floor_size):
successful_placement = True
env.metadata['curr_n_ramps'] = np.ones((self.n_ramps)).astype(np.bool)
for i in range(self.n_ramps):
char = chr(ord('A') + i % 26)
geom = geom = ObjFromXML('ramp', name=f"ramp{i}")
geom.set_material(Material(texture="chars/" + char + ".png"))
if self.friction is not None:
geom.add_transform(
set_geom_attr_transform('friction', self.friction))
if self.placement_fn is not None:
_placement_fn = (self.placement_fn[i] if isinstance(
self.placement_fn, list) else self.placement_fn)
pos, _ = rejection_placement(env, _placement_fn, floor_size,
get_size_from_xml(geom))
if pos is not None:
floor.append(geom, placement_xy=pos)
else:
successful_placement = False
else:
floor.append(geom)
return successful_placement
def build_world_step(self, env, floor, floor_size):
for k, v in self.kwargs.items():
floor.add_transform(set_geom_attr_transform(k, v))
return True
