def __init__(self, world, position, width=1.6, length=4.0, tire_width=.25, tire_length=.8, skidmarks=None, body_density=1.0):
mass = width * length * body_density
inertia = moment_for_box(mass, width, length)
self.world = world
body = Body(mass, inertia, )
body.position = position
shape = Poly.create_box(body, size=(width, length))
super(Car, self).__init__(world, body, shape)
slot_density = .01
slot_radius = .1
slot_mass = slot_density * (slot_radius ** 2) * pi
slot_inertia = moment_for_circle(slot_mass, 0.0, slot_radius)
#self.slot = Body(slot_mass, slot_inertia)
flpos = position[0] - width / 2.0 - tire_width * 2, position[1] + length / 2.0
self.front_left = Tire(self, flpos, tire_width, tire_length, skidmarks=skidmarks, powered=False, density=body_density)
frpos = position[0] + width / 2.0 + tire_width * 2, position[1] + length / 2.0
self.front_right = Tire(self, frpos, tire_width, tire_length, skidmarks=skidmarks, powered=False, density=body_density)
rlpos = position[0] - width / 2.0 - tire_width * 2, position[1] - length / 2.0
self.rear_left = Tire(self, rlpos, tire_width * 1.5, tire_length, steerable=False, skidmarks=skidmarks, density=body_density)
rrpos = position[0] + width / 2.0 + tire_width * 2, position[1] - length / 2.0
self.rear_right = Tire(self, rrpos, tire_width * 1.5, tire_length, steerable=False, skidmarks=skidmarks, density=body_density)
self.tires = [self.front_left, self.front_right, self.rear_left, self.rear_right]
def __init__(self, space, rect, playfield=None):
super(PlungerAssembly, self).__init__()
self.chute_counter = 0
self.rect = Rect(0, 0, 1, 1)
spring_strength = 100 * plunger_mass
chute_opening = playfield.position + rect.center - (rect.width / 2. -
ball_radius * 4, 0)
plunger_rect = Rect(0, 0, rect.width * .2, ball_radius / 2.)
anchor0 = chute_opening - playfield.position - (ball_radius * 3., 0)
anchor1 = anchor0 + (rect.width * .8, 0)
anchor2 = -plunger_rect.width / 2., 0
plunger_body = Body(plunger_mass, pymunk.inf)
plunger_shape = Poly.create_box(plunger_body, plunger_rect.size)
plunger_shape.layers = 1
plunger_shape.friction = 0.1
plunger_shape.elasticity = 1.0
plunger_shape.collision_type = plunger_type
plunger_body.position = chute_opening + (plunger_rect.width / 2., 0)
j0 = GrooveJoint(playfield, plunger_body, anchor0, anchor1, anchor2)
j1 = DampedSpring(playfield, plunger_body, anchor0, anchor2, 0,
spring_strength, 5)
s0 = Circle(Body(), ball_radius / 2.)
s0.layers = 1
s0.sensor = True
s0.collision_type = sensor0_type
s0.body.position = chute_opening + (ball_radius * 4., 0.0)
s1 = Circle(Body(), ball_radius * 3.)
s1.layers = 1
s1.sensor = True
s1.collision_type = sensor1_type
s1.body.position = chute_opening
def inc_counter(space, arbiter):
self.chute_counter += 1
return True
def dec_counter(space, arbiter):
self.chute_counter -= 1
f = space.add_collision_handler
f(sensor1_type, plunger_type, begin=inc_counter, separate=dec_counter)
self.playfield = playfield
self.plunger_offset = playfield.position - plunger_body.position + (
ball_radius * 3, 0)
self.spring = j1
self.spring_length = rect.width / 2.
self.spring_strength = spring_strength
self.plunger_body = plunger_body
self.ball_chute = Rect(0, 0, ball_radius * 2., ball_radius * 2.)
self.ball_chute.center = chute_opening
self._original_image = pygame.Surface(plunger_rect.size)
self._original_image.fill((192, 255, 255))
self.shapes = [plunger_shape, s0, s1, j0, j1]
self.visible = 0
def add_rect(self, x, y, w, h, dynamic=True):
body = Body(body_type=(Body.STATIC, Body.DYNAMIC)[int(dynamic)])
body.position = x, y
poly = Poly.create_box(body, size=(w, h))
poly.density = Environment.DEFAULT_DENSITY
self.space.add(body, poly)
self.bodies.append(body)
return body
def __init__(self, space, rect, playfield=None):
super(PlungerAssembly, self).__init__()
self.chute_counter = 0
self.rect = pygame.Rect(0, 0, 0, 0)
spring_strength = 100 * plunger_mass
chute_opening = playfield.position + rect.center - (rect.width / 2 - ball_radius * 4, 0)
plunger_rect = pygame.Rect(0, 0, rect.width * .2, ball_radius / 2)
anchor0 = chute_opening - playfield.position - (ball_radius * 3, 0)
anchor1 = anchor0 + (rect.width * .8, 0)
anchor2 = -plunger_rect.width / 2, 0
plunger_body = Body(plunger_mass, pymunk.inf)
plunger_shape = Poly.create_box(plunger_body, plunger_rect.size)
plunger_shape.layers = 1
plunger_shape.friction = 0
plunger_shape.elasticity = 1.0
plunger_shape.collision_type = plunger_type
plunger_body.position = chute_opening + (plunger_rect.width / 2, 0)
j0 = GrooveJoint(playfield, plunger_body, anchor0, anchor1, anchor2)
j1 = DampedSpring(playfield, plunger_body, anchor0, anchor2, 0, spring_strength, 5)
s0 = Circle(Body(), ball_radius / 2)
s0.layers = 1
s0.sensor = True
s0.collision_type = sensor0_type
s0.body.position = chute_opening + (ball_radius * 4, 0)
s1 = Circle(Body(), ball_radius * 3)
s1.layers = 1
s1.sensor = True
s1.collision_type = sensor1_type
s1.body.position = chute_opening
def inc_counter(space, arbiter):
self.chute_counter += 1
return True
def dec_counter(space, arbiter):
self.chute_counter -= 1
f = space.add_collision_handler
f(sensor1_type, plunger_type, begin=inc_counter, separate=dec_counter)
self.playfield = playfield
self.plunger_offset = playfield.position - plunger_body.position + (ball_radius * 3, 0)
self.spring = j1
self.spring_length = rect.width / 2
self.spring_strength = spring_strength
self.plunger_body = plunger_body
self.ball_chute = pygame.Rect(0, 0, ball_radius * 2, ball_radius * 2)
self.ball_chute.center = chute_opening
self._original_image = pygame.Surface(plunger_rect.size)
self._original_image.fill((192, 255, 255))
self.shapes = [plunger_shape, s0, s1, j0, j1]
self.visible = 0
def _create_poly(self):
"""
Create the polygon used for ray-casting. (Ultrasonic sensor)
:return: a Pymunk Poly object.
"""
body = Body(body_type=Body.STATIC)
body.position = Vec2d(self.center_x, self.center_y)
return Poly.create_box(body, (self.width, self.height))
def __init__(
self,
space: Space,
shape_type: str,
pos: Tuple[float, float],
scale: float = 1.,
mass: float = 1,
static: bool = False,
friction: float = 1.,
color: Tuple[float, float, float] = (1., 1., 1.),
):
self.space = space
self.shape_type = shape_type
self.static = static
self._scale = scale
self.color = color
padding = 0.03
if not static:
if self.shape_type == "box":
moment = pymunk.moment_for_box(mass, (self.scale, self.scale))
elif self.shape_type == "circle":
moment = pymunk.moment_for_circle(mass, 0, self.scale / 2.)
else:
raise ValueError(f"Invalid shape_type '{self.shape_type}'")
self.mass = mass
self.body = Body(mass, moment)
self.body.position = pos
self._static_position = None
if self.shape_type == "box":
self.shape = Poly.create_box(self.body, (1, 1))
elif self.shape_type == "circle":
self.shape = Circle(self.body, self.scale / 2. - padding)
# static
else:
self.mass = 0
self.body = self.space.static_body
self._static_position = Vec2d(*pos)
if self.shape_type == "box":
self.shape = Poly(
self.space.static_body,
[(pos[0] + p[0] * scale, pos[1] + p[1] * scale)
for p in SHAPE_TYPES[self.shape_type]["polygon"]])
self.shape.get_vertices()
elif self.shape_type == "circle":
self.shape = Circle(self.space.static_body,
self.scale / 2. - padding,
offset=pos)
self.shape.friction = friction
def create_rect(w=1, h=1, scalar=1, m=1, x=0, y=0, bt=Body.DYNAMIC):
'''
given the width (w), height (h), mass (m), x-position (x), y-position (y),
scalar <to augment default square>, and the body_type (bt).
returns a `rigid body` which is a shapeless object that
has physical properties (mass, position, rotation, velocity, etc)
ALSO returns a Poly which is the Shape that really gets drawn
'''
poly_size = (w * scalar, h * scalar)
poly = Poly.create_box(body=None, size=poly_size)
# moment depends on mass and size.
# bigger poly >> bigger moment.
# more massive >> bigger moment
moment_of_inertia = moment_for_poly(m, poly.get_vertices())
body = Body(mass=m, moment=moment_of_inertia, body_type=bt)
body.position = (x, y)
poly.body = body
return body, poly
def __init__(self, space, rect, playfield=None, win=False, returns=False):
super(Pocket, self).__init__()
color = (220, 100, 0)
inside = rect.inflate(-10, -10)
cover = Poly.create_box(playfield, inside.size, rect.center)
self.shapes = [cover]
if win:
self.shapes.extend((
Segment(playfield, rect.topleft, rect.bottomleft, 1),
Segment(playfield, rect.bottomleft, rect.bottomright, 1),
Segment(playfield, rect.bottomright, rect.topright, 1)))
self._original_image = pygame.Surface(rect.size, pygame.SRCALPHA)
pygame.draw.rect(self._original_image, color, rect)
self.rect = pygame.Rect(rect)
if win:
self.shape.collision_type = pocket_win_type
elif returns:
self.shape.collision_type = pocket_return_type
else:
self.shape.collision_type = pocket_fail_type
def __init__(self, space, rect, playfield=None, win=False, returns=False):
super(Pocket, self).__init__()
color = (220, 100, 0)
inside = rect.inflate(-10, -10)
cover = Poly.create_box(playfield, inside.size, rect.center)
self.shapes = [cover]
if win:
self.shapes.extend(
(Segment(playfield, rect.topleft, rect.bottomleft, 1),
Segment(playfield, rect.bottomleft, rect.bottomright, 1),
Segment(playfield, rect.bottomright, rect.topright, 1)))
self._original_image = pygame.Surface(rect.size, pygame.SRCALPHA)
pygame.draw.rect(self._original_image, color, rect)
self.rect = pygame.Rect(rect)
if win:
self.shape.collision_type = pocket_win_type
elif returns:
self.shape.collision_type = pocket_return_type
else:
self.shape.collision_type = pocket_fail_type
def __init__(self, car, position, width=10.0, length=20.0, steerable=True, skidmarks=None, powered=True, density=1.0):
world = car.world
self.steerable = steerable
self.powered = powered
self.skidding = False
mass = width * length * density
inertia = moment_for_box(mass, width, length)
self.world = world
body = Body(mass, inertia, )
body.position = position
shape= Poly.create_box(body, size=(width, length))
super(Tire, self).__init__(world, body, shape)
## self.bodyDef = box2d.b2BodyDef()
## self.bodyDef.position = position
## body = world.CreateBody(self.bodyDef)
## super(Tire, self).__init__(world, body)
## self.shapeDef = box2d.b2PolygonDef()
## self.shapeDef.density = 1
## self.shapeDef.SetAsBox(width, length)
## self.shap = self.body.CreateShape(self.shapeDef)
## self.body.SetMassFromShapes()
# our joint
joint = PivotJoint(self.body, car.body, self.position)
joint.error_bias = pow(1.0 - 0.1, 60.0) * 10
self.world.add(joint)
#joint = PinJoint(self.body, car.body)
#self.world.add(joint)
self.rot_joint = RotaryLimitJoint(self.body, car.body, 0, 0)
self.world.add(self.rot_joint)
def __init__(self,
arm_anchor_points,
arm_segment_lengths,
target_position,
target_rotation=0,
do_render=False,
sparse=True,
object_size=OBJECT_SIZE):
super().__init__(do_render, sparse, MAX_MOTOR_FORCE)
self.target_size = TARGET_SIZE
self.target_position = target_position
self.target_rotation = target_rotation
self.space.gravity = (0.0, -900.0)
floor = pymunk.Segment(self.space.static_body,
(int(-5 * ENV_SIZE), int(0.17 * ENV_SIZE)),
(int(5 * ENV_SIZE), int(0.17 * ENV_SIZE)),
0.017 * ENV_SIZE)
floor.elasticity = 0.1
floor.friction = 0.5
floor.collision_type = NO_COLLISION_TYPE
self.space.add(floor)
for i, anchor_point in enumerate(arm_anchor_points):
self.add_arm(arm_segment_lengths[i], anchor_point)
self.object_size = (object_size, object_size)
object_mass = TARGET_MASS
object_moment = pymunk.moment_for_box(object_mass, self.object_size)
self.object_body = Body(object_mass, object_moment)
self.object_body.position = ENV_SIZE / 2, object_size / 2 + int(
0.187 * ENV_SIZE)
self.object_shape = Poly.create_box(self.object_body, self.object_size)
self.object_shape.elasticity = 0.1
self.object_shape.friction = 1.0
self.space.add(self.object_body, self.object_shape)
