def setup(self, *args, **kwargs):
super().setup(*args, **kwargs)
self._setup_body()
assert self.body is not None
self.body.position = self.init_pos
self.body.angle = self.init_angle
self.add_to_space(self.body)
# Main body position and angle should be set before calling setup on the
# extra bodies since they might depend on those values.
self._setup_extra_bodies()
self.add_to_space(*self.extra_bodies)
self._setup_control_body()
assert self.control_body is not None
self._setup_shape()
self._setup_extra_shapes()
assert self.shape is not None
self.add_to_space(self.shape)
self.add_to_space(self.extra_shapes)
self._setup_graphic()
self._setup_extra_graphics()
assert self.graphic_bodies
self.xform = r.Transform()
self.robot_compound = r.Compound(
[*self.graphic_bodies, *self.extra_graphic_bodies])
self.robot_compound.add_transform(self.xform)
self.viewer.add_geom(self.robot_compound)
def setup(self, *args, **kwargs):
super().setup(*args, **kwargs)
# thick line segments around the edges
arena_body = pm.Body(body_type=pm.Body.STATIC)
rad = self.seg_rad
points = [
(self.left - rad, self.top + rad),
(self.right + rad, self.top + rad),
(self.right + rad, self.bottom - rad),
(self.left - rad, self.bottom - rad),
]
arena_segments = []
for start_point, end_point in zip(points, points[1:] + points[:1]):
segment = pm.Segment(arena_body, start_point, end_point, rad)
segment.friction = 0.8
arena_segments.append(segment)
self.add_to_space(*arena_segments)
width = self.right - self.left
height = self.top - self.bottom
arena_square = r.make_rect(width, height, True)
arena_square.color = (1, 1, 1)
arena_square.outline_color = COLORS_RGB["grey"]
txty = (self.left + width / 2, self.bottom + height / 2)
centre_xform = r.Transform(translation=txty)
arena_square.add_transform(centre_xform)
self.viewer.add_geom(arena_square)
def _setup_extra_graphics(self):
super()._setup_extra_graphics()
light_robot_color = lighten_rgb(self.robot_color, 4)
self.finger_xforms = []
finger_outer_geoms = []
finger_inner_geoms = []
for finger_outer_subshapes, finger_inner_verts, finger_side in zip(
self.finger_shapes, self.finger_inner_vertices, [-1, 1]):
finger_xform = r.Transform()
self.finger_xforms.append(finger_xform)
for finger_subshape in finger_outer_subshapes:
vertices = [(v.x, v.y) for v in finger_subshape.get_vertices()]
finger_outer_geom = r.Poly(vertices, False)
finger_outer_geom.color = self.robot_color
finger_outer_geom.add_transform(finger_xform)
finger_outer_geoms.append(finger_outer_geom)
for vertices in finger_inner_verts:
finger_inner_geom = r.Poly(vertices, False)
finger_inner_geom.color = light_robot_color
finger_inner_geom.add_transform(finger_xform)
finger_inner_geoms.append(finger_inner_geom)
for geom in finger_outer_geoms:
self.viewer.add_geom(geom)
for geom in finger_inner_geoms:
self.viewer.add_geom(geom)
def _setup_extra_graphics(self):
self.eye_shapes = []
self.pupil_transforms = []
for x_sign in [-1, 1]:
eye = r.make_circle(0.2 * self.radius, 100, outline=False)
eye.color = (1.0, 1.0, 1.0) # White color.
eye_base_transform = r.Transform(translation=(x_sign *
self.eye_txty[0],
self.eye_txty[1]))
eye.add_transform(eye_base_transform)
pupil = r.make_circle(0.12 * self.radius, 100, outline=False)
pupil.color = (0.1, 0.1, 0.1) # Black color.
pupil_transform = r.Transform()
pupil.add_transform(
r.Transform(translation=(0, self.radius * 0.07)))
pupil.add_transform(pupil_transform)
pupil.add_transform(eye_base_transform)
self.pupil_transforms.append(pupil_transform)
self.eye_shapes.extend([eye, pupil])
self.extra_graphic_bodies.extend(self.eye_shapes)
def setup(self, *args, **kwargs):
super().setup(*args, **kwargs)
# the space only needs a sensor body
self.goal_body = pm.Body(body_type=pm.Body.STATIC)
self.goal_shape = pm.Poly.create_box(self.goal_body, (self.w, self.h))
self.goal_shape.sensor = True
self.goal_body.position = (self.x + self.w / 2, self.y - self.h / 2)
self.add_to_space(self.goal_body, self.goal_shape)
# Graphics.
outer_color = self.base_color
inner_color = lighten_rgb(self.base_color, times=2)
inner_rect = r.make_rect(self.w, self.h, True, dashed=self.dashed)
inner_rect.color = inner_color
inner_rect.outline_color = outer_color
self.goal_xform = r.Transform()
inner_rect.add_transform(self.goal_xform)
self.viewer.add_geom(inner_rect)
def setup(self, *args, **kwargs) -> None:
super().setup(*args, **kwargs)
# Physics. This joint setup was taken form tank.py in the pymunk
# examples.
if self.shape_type == ShapeType.SQUARE:
side_len = math.sqrt(math.pi) * self.shape_size
shapes = self._make_square(side_len)
elif self.shape_type == ShapeType.CIRCLE:
shapes = self._make_circle()
elif self.shape_type == ShapeType.STAR:
star_npoints = 5
star_out_rad = 1.3 * self.shape_size
star_in_rad = 0.5 * star_out_rad
shapes, convex_parts = self._make_star(star_npoints, star_out_rad,
star_in_rad)
else:
# These are free-form shapes b/c no helpers exist in Pymunk.
try:
factor, num_sides = POLY_TO_FACTOR_SIDE_PARAMS[self.shape_type]
except KeyError:
raise NotImplementedError("haven't implemented",
self.shape_type)
side_len = factor * gtools.regular_poly_circ_rad_to_side_length(
num_sides, self.shape_size)
shapes, poly_verts = self._make_regular_polygon(
num_sides, side_len)
for shape in shapes:
shape.friction = 0.5
self.add_to_space(shape)
trans_joint = pm.PivotJoint(self.space.static_body, self.shape_body,
(0, 0), (0, 0))
trans_joint.max_bias = 0
trans_joint.max_force = self.phys_vars.shape_trans_joint_max_force
self.add_to_space(trans_joint)
rot_joint = pm.GearJoint(self.space.static_body, self.shape_body, 0.0,
1.0)
rot_joint.max_bias = 0
rot_joint.max_force = self.phys_vars.shape_rot_joint_max_force
self.add_to_space(rot_joint)
# Graphics.
geoms_outer = []
if self.shape_type == ShapeType.SQUARE:
geoms = [r.make_square(side_len, outline=True)]
elif self.shape_type == ShapeType.CIRCLE:
geoms = [r.make_circle(self.shape_size, 100, True)]
elif self.shape_type == ShapeType.STAR:
star_short_verts = gtools.compute_star_verts(
star_npoints,
star_out_rad - SHAPE_LINE_THICKNESS,
star_in_rad - SHAPE_LINE_THICKNESS,
)
short_convex_parts = autogeom.convex_decomposition(
star_short_verts + star_short_verts[:1], 0)
geoms = []
for part in short_convex_parts:
geoms.append(r.Poly(part, outline=False))
geoms_outer = []
for part in convex_parts:
geoms_outer.append(r.Poly(part, outline=False))
elif (self.shape_type == ShapeType.OCTAGON
or self.shape_type == ShapeType.HEXAGON
or self.shape_type == ShapeType.PENTAGON
or self.shape_type == ShapeType.TRIANGLE):
geoms = [r.Poly(poly_verts, outline=True)]
else:
raise NotImplementedError("haven't implemented", self.shape_type)
if self.shape_type == ShapeType.STAR:
for g in geoms_outer:
g.color = darken_rgb(self.color)
for g in geoms:
g.color = self.color
else:
for g in geoms:
g.color = self.color
g.outline_color = darken_rgb(self.color)
self.shape_xform = r.Transform()
shape_compound = r.Compound(geoms_outer + geoms)
shape_compound.add_transform(self.shape_xform)
self.viewer.add_geom(shape_compound)