def __init__(self, segment_info, starting_position, angle=0,):
"""
:param segment_info: SegmentInfo object containing all pre-defined segment constants
:param starting_position: (x, y) tuple of location of attachment point
:param angle: angle in radians relative to vertical, in absolute coordinates
:return: nothing
"""
length = segment_info.length
inertia = pymunk.moment_for_segment(segment_info.mass, (length / 2, 0), (-length / 2, 0), 1)
self.body = pymunk.Body(segment_info.mass, inertia)
self.length = length
x = length * math.sin(angle)
y = -length * math.cos(angle)
self.body.position = (starting_position[0] + x / 2, starting_position[1] + y / 2)
self.body.angle = angle
self.body.velocity = segment_info.start_speed
self.shape = pymunk.Segment(self.body, (0, length / 2), (0, -length / 2), SEGMENT_WIDTH)
self.shape.collision_type = segment_info.collision_type
self.shape.friction = FRICTION
image = segment_info.image
if image is not None:
ratio = length / image.get_height() * IMAGE_SIZE_RATIO
new_width = int(image.get_width() * ratio)
image = pygame.transform.scale(image, (new_width, int(length * IMAGE_SIZE_RATIO)))
self.image = image
def create_segments(self):
#scale = 0.3 # o reduce the size of the object (high resolution images)
#topymunk = [self.frame_size[0], self.frame_size[1]]
#window_center = [self.transform.tx, self.transform.ty]
#print(" >" , topymunk)
for i in range(len(self.segments) - 1):
# radius is the thickness of the segment
sa = self.from_profile_to_pymunk(
pointp=self.segments[i]
) #[self.segments[i][0], topymunk[1] - self.segments[i][1]]
sb = self.from_profile_to_pymunk(
pointp=self.segments[i + 1]
) #[self.segments[i+1][0], topymunk[1] - self.segments[i+1][1]]
moment_piece = pymunk.moment_for_segment(
mass=self.segment_mass,
a=sa,
b=sb,
radius=self.segment_thickness)
body = pymunk.Body(mass=self.segment_mass,
moment=moment_piece,
body_type=pymunk.Body.KINEMATIC)
piece = pymunk.Segment(body, sa, sb, radius=self.segment_thickness)
piece.color = (133, 153, 0)
#body.position = x, y
self.bodies_segments.append(body)
self.shapes_segments.append(piece)
def __init__(self, space, base_body, body_pos, length, angle, mass=1, thickness=5):
b = body_pos
dif = (math.sin(angle) * length, math.cos(angle) * length)
v = b + dif
base_dif = body_pos - base_body.position
link_body = pymunk.Body(mass, mass * length * length / 3)
link_body.position = body_pos
self.link = pymunk.Segment(link_body, (0,0), dif, thickness)
self.link.filter = pymunk.ShapeFilter(categories=0b1, mask=0b0)
link_body.moment = pymunk.moment_for_segment(mass, self.link.a, self.link.b, thickness)
link_body.center_of_gravity = (self.link.a + self.link.b)/2.0
base_motor = pymunk.SimpleMotor(base_body, link_body, 0)
base_joint = pymunk.PinJoint(base_body, link_body, base_dif, (0,0))
base_joint.error_bias = 0.0001
base_clamp = pymunk.RotaryLimitJoint(base_body, link_body, (-3*math.pi/4), (3*math.pi/4))
space.add(self.link, link_body, base_motor, base_joint, base_clamp)
print("Body pos: " + str(link_body.position))
print("COG pos: " + str(link_body.center_of_gravity))
print("a" + str(self.link.a))
print("b" + str(self.link.b))
self.motor = base_motor
self.body = link_body
self.start_tip = v
def __init__(self,
name,
space,
p1,
p2,
width,
density=DEFAULT_DENSITY,
elasticity=DEFAULT_ELASTICITY,
friction=DEFAULT_FRICTION,
color=DEFAULT_COLOR):
PGObject.__init__(self, name, "Segment", space, color, density,
friction, elasticity)
self.r = width / 2
area = areaForSegment(p1, p2, self.r)
mass = density * area
if mass == 0:
self._cpShape = pm.Segment(space.static_body, p1, p2, self.r)
self._cpShape.elasticity = elasticity
self._cpShape.friction = friction
self._cpShape.collision_type = COLTYPE_SOLID
self._cpShape.name = name
space.add(self._cpShape)
else:
pos = pm.Vec2d((p1[0] + p2[0]) / 2., (p1[1] + p2[1]) / 2.)
v1 = pm.Vec2d(p1) - pos
v2 = pm.Vec2d(p2) - pos
imom = pm.moment_for_segment(mass, v1, v2, 0)
self._cpBody = pm.Body(mass, imom)
self._cpShape = pm.Segment(self._cpBody, v1, v2, self.r)
self._cpShape.elasticity = elasticity
self._cpShape.friction = friction
self._cpShape.collision_type = COLTYPE_SOLID
self._cpShape.name = name
self._cpBody.position = pos
space.add(self._cpBody, self._cpShape)
def create_segment(a=None, b=None, collision_type=None, elasticity=None,
friction=None, mass=None, moment=None, position=None,
radius=None, **extras):
if _lacks_moment(mass, moment):
moment = pymunk.moment_for_segment(mass, a, b)
body = _create_body(mass, moment, position)
shape = pymunk.Segment(body, a, b, radius)
return _configure_shape(shape, elasticity, friction, collision_type)
def addSegment(self, actorID, **kwargs):
'''Create a line segment shape and body'''
if kwargs['moment'] == -1:
kwargs['moment'] = pymunk.moment_for_segment(kwargs['mass'], kwargs['vertices'][0], kwargs['vertices'][1])
body = self.createBody(kwargs['isStatic'], kwargs['mass'], kwargs['moment'], kwargs['pos'])
shape = pymunk.Segment(body, kwargs['vertices'][0], kwargs['vertices'][1], kwargs['thickness'])
self.addShape(actorID, body, shape, kwargs['elasticity'], kwargs['collisionType'])
def _body(self):
if self.static == False:
mass = 20
inertia = pymunk.moment_for_segment(mass, self.a, self.b)
body = pymunk.Body(mass, inertia)
else:
body = pymunk.Body(pymunk.inf, pymunk.inf)
return body
def testGeneral(self):
p.version
p.inf
p.chipmunk_version
m = p.moment_for_box(1, 2, 3)
self.assertAlmostEqual(m, 1.08333333333)
m = p.moment_for_segment(1, Vec2d(-1, 0), Vec2d(1, 0))
self.assertAlmostEqual(m, 0.33333333333)
def __init__(self, node, mass=100):
a = (0,0)
b = util.transformVector((node.pos2.x - node.pos1.x,node.pos2.y - node.pos1.y))
inertia = pymunk.moment_for_segment(mass, a,b)
BaseBody.__init__(self, node, mass, inertia)
self.shape = pymunk.Segment(self, a, b, node.strokewidth)
self.shape.elasticity=1
self.shape.friction = 0
self.shape.collision_type = ShieldCollisionType
def testGeneral(self):
p.version
p.inf
p.chipmunk_version
m = p.moment_for_box(1, 2, 3)
self.assertAlmostEqual(m, 1.08333333333)
m = p.moment_for_segment(1, Vec2d(-1,0), Vec2d(1,0))
self.assertAlmostEqual(m, 0.33333333333)
def __init__(self, space):
self.mass = 0
self.space = space
self.vertices = ((0, 50), (800, 50))
self.moment = pymunk.moment_for_segment(self.mass, *self.vertices, 3)
self.body = pymunk.Body(self.mass, self.moment, pymunk.Body.STATIC)
self.shape = (pymunk.Segment(self.body, *self.vertices, 3))
self.shape.density = 10000000
self.shape.friction = 1
self.shape.elasticity = 0.7
self.addes = [self.body, self.shape]
def make_spinner(self, mode, pos, angle, speed, length, material=0):
evalues = [0.12, 1.1, 0.12]
fvalues = [2.0, 0.5, 0.1]
colors = [ (255,50,50), (50,255,50), (50,50,255)]
if mode == "free":
mass = 1e2
spinner = pymunk.Body(mass, pymunk.moment_for_segment( mass, (0,length), (0,-length)))
elif mode == "drag":
mass = 1e4
spinner = pymunk.Body(mass, pymunk.moment_for_segment( mass, (0,length), (0,-length)))
else:
spinner = pymunk.Body(pymunk.inf,pymunk.inf)
spinner.mode = mode
spinner.position = pos
spinner.home_pos = pos
spinner.angle = angle
spinner.angular_velocity = speed
spinner.material = material
spinner.length = length
if mode == "drag":
spinner.draggable = True
shape = pymunk.Segment(spinner, (0,length), (0,-length), length/8.5)
shape.elasticity = evalues[material]
shape.friction = fvalues[material]
shape.color = colors[material]
shape.collision_type = COLL_SPINNER
shape.layers = LAYER_FX_DYNAMICS | LAYER_DYNAMICS
shape.material = material
spinner.shape = shape
rot_body = pymunk.Body()
rot_body.position = pos
#rot_joint = pymunk.PinJoint( spinner, rot_body, (0,0), (0,0))
rot_joint = pymunk.PivotJoint( spinner, rot_body, (0,0), (0,0))
self.space.add( spinner, shape, rot_joint)
self.spinners.append( spinner)
return spinner
def testMomentHelpers(self):
m = p.moment_for_circle(1,2,3,(1,2))
self.assertAlmostEqual(m, 11.5)
m = p.moment_for_segment(1, (-10,0), (10,0), 1)
self.assertAlmostEqual(m, 40.6666666666)
m = p.moment_for_poly(1, [(0,0), (10,10), (10,0)], (1,2), 3)
self.assertAlmostEqual(m, 98.3333333333)
m = p.moment_for_box(1, (2, 3))
self.assertAlmostEqual(m, 1.08333333333)
def recalculate_inertia(body): if body.mass == 0: return inertia = 0 for shape in body.shapes: if isinstance(shape, pymunk.Circle): inertia += pymunk.moment_for_circle(area_of_circle(shape.radius), 0, shape.radius, shape.offset) if isinstance(shape, pymunk.Poly): pnts = shape.get_points() inertia += pymunk.moment_for_poly(area_of_poly(pnts), pnts, shape.offset) if isinstance(shape, pymunk.Segment): inertia += pymunk.moment_for_segment((shape.a-shape.b).length, shape.a, shape.b) body.moment = body.mass*inertia
def testMomentHelpers(self):
m = p.moment_for_circle(1, 2, 3, (1, 2))
self.assertAlmostEqual(m, 11.5)
m = p.moment_for_segment(1, (-10, 0), (10, 0), 1)
self.assertAlmostEqual(m, 40.6666666666)
m = p.moment_for_poly(1, [(0, 0), (10, 10), (10, 0)], (1, 2), 3)
self.assertAlmostEqual(m, 98.3333333333)
m = p.moment_for_box(1, (2, 3))
self.assertAlmostEqual(m, 1.08333333333)
def add_segment(self,
p1: Union[tuple[float, float], Vector],
p2: Union[tuple[float, float], Vector],
mass: float,
radius: float,
friction: float = .99,
elasticity: float = 0,
is_static: bool = False) -> pymunk.Segment:
"""
new static Segment body with uniform mass repartition
Parameters
----------
p1 : Union[tuple[float, float], Vector]
position of the first vertex
p2 : Union[tuple[float, float], Vector]
position of the second vertex
mass: float
mass of segment
radius : float
radius of segment
Options
-------
fiction : float, (optional)
defaults to .99
elasticity : float, (optional)
defaults to 0
is_static : bool, (optional)
defaults to False
"""
a = p1[0], p1[1]
b = p2[0], p2[1]
inertia = pymunk.moment_for_segment(mass, a, b, radius)
opt = {
"body_type":
pymunk.Body.STATIC if is_static else pymunk.Body.DYNAMIC
}
body = pymunk.Body(mass, inertia, **opt)
shape = pymunk.Segment(body, a, b, radius)
shape.friction = friction
shape.elasticity = elasticity
if not is_static:
body.position = self._get_center(a, b)
body.center_of_gravity = shape.center_of_gravity
self._space.add(body, shape)
self._all_shapes.add(shape)
return shape
def add_crank_arm(self):
mass = 1
radius = 1
length = 80
a = (STARTING_X, STARTING_Y - TORSO_HEIGHT / 2)
b = (STARTING_X + CRANK_ARM_LEN, STARTING_Y - TORSO_HEIGHT / 2)
moment = pymunk.moment_for_segment(mass, (0, 0), (0, length), radius)
body = pymunk.Body(mass, moment)
#body= pymunk.Body(body_type = pymunk.Body.STATIC)
body.position = (0, 0)
body.velocity = (0, 0)
arm = pymunk.Segment(body, a, b, radius)
return body, arm
def get_inertia(self, shape, mass):
if self.agent_shape == 'rectangle':
inertia = pymunk.moment_for_poly(mass, shape.get_vertices())
elif self.agent_shape == 'circle':
radius = shape.radius
inertia = pymunk.moment_for_circle(mass, radius, radius)
elif self.agent_shape == 'segment':
a = shape.a
b = shape.b
radius = shape.radius
inertia = pymunk.moment_for_segment(mass, a, b, radius)
return inertia
def add_segment(self, space, vertice):
mass = 1000
radius = 16
moment = pymunk.moment_for_segment(mass, (0, 0), (0, 10), radius)
body = pymunk.Body(mass, moment)
shape = pymunk.Poly(body, vertice, None, radius)
shape.elasticity = 0.9
space.add(shape)
return shape
def build_physics(self, space):
moment = pymunk.moment_for_segment(self.mass, (-self.dsize, 0),
(self.dsize, 0), self.width * 2)
self.body = pymunk.Body(self.mass, moment, pymunk.Body.DYNAMIC)
self.body.position = (self.offset, self.dsize)
border = build_borders(-self.dsize, self.dsize, -self.width,
self.width)
self.shape = pymunk.Poly(self.body, border)
#self.shape.friction = 1
for l in self.limbs:
l.build_physics(space)
space.add(self.body, self.shape)
self.update(0)
def __init__(self, mass, space, screen):
self.mass = mass
self.screen = screen
self.segment_moment = pymunk.moment_for_segment(
self.mass, (0, 750), (1000, 750), 2) #end points and thickness
self.segment_body = pymunk.Body(self.mass, self.segment_moment,
pymunk.Body.STATIC)
self.segment_body.position = 0, 0
self.segment_shape = pymunk.Segment(self.segment_body, (0, 750),
(1000, 750), 2)
self.segment_shape.elasticity = 1
self.segment_shape.id = 4
space.add(self.segment_body, self.segment_shape)
def add_torso(self):
fixed_pin = pymunk.Body(body_type=pymunk.Body.STATIC)
mass = 1
width = 1
a = (STARTING_X, STARTING_Y + TORSO_HEIGHT / 2)
b = (STARTING_X, STARTING_Y - TORSO_HEIGHT / 2)
moment = pymunk.moment_for_segment(mass, (0, 0), (0, TORSO_HEIGHT),
width)
body = pymunk.Body(mass, moment)
#body= pymunk.Body(body_type = pymunk.Body.STATIC)
body.position = (0, 0)
pin_joint = pymunk.PinJoint(fixed_pin, body, (0, 0), (0, 0))
torso = pymunk.Segment(body, a, b, width)
return body, torso, pin_joint
def __init__(self, segment_type="Fixed"):
if segment_type == "Fixed":
self.segment_moment = pymunk.moment_for_segment(
20, (75, 75), (800, 15), 5)
self.segment_body = pymunk.Body(20,
self.segment_moment,
body_type=pymunk.Body.KINEMATIC)
self.segment_shape = pymunk.Segment(self.segment_body, (75, 75),
(800, 15), 5)
self.segment_shape.elasticity = 0.1
self.segment_shape.friction = 0.94
elif segment_type == "Rotating":
self.segment_moment = pymunk.moment_for_segment(
20, (75, 75), (800, 15), 5)
self.segment_body = pymunk.Body(20, self.segment_moment)
self.segment_shape = pymunk.Segment(self.segment_body, (75, 75),
(800, 15), 5)
self.segment_shape.elasticity = 0.1
self.segment_shape.friction = 0.94
else:
print(
"This shouldn't happen. Enter valid ball type!(Book, Domino)")
super().__init__(self.segment_body, self.segment_shape)
def create_segment(a=None,
b=None,
collision_type=None,
elasticity=None,
friction=None,
mass=None,
moment=None,
position=None,
radius=None,
**extras):
if _lacks_moment(mass, moment):
moment = pymunk.moment_for_segment(mass, a, b)
body = _create_body(mass, moment, position)
shape = pymunk.Segment(body, a, b, radius)
return _configure_shape(shape, elasticity, friction, collision_type)
def __init__(self, id, x, y, angle, length):
self.length = length
self.previousPosition = [x, y]
self.startingPosition = [x, y]
self.beamID = id
self.angle = angle
self.moment = pymunk.moment_for_segment(
self.mass, (x, y),
(int(x + (math.cos(math.radians(angle)) * self.length)),
int(y + (math.sin(math.radians(angle)) * self.length))),
self.thickness)
self.body = pymunk.Body(self.mass, self.moment)
self.body.position = x, y
self.shape = pymunk.Segment(self.body, (x, y),
(x + (math.cos(angle) * self.length), y +
(math.sin(angle) * self.length)),
self.thickness)
self.shape.friction = 1
self.shape.collision_type = 1
def create_segment(
p1=(0, 0), p2=(0, 1), thicc=1, x=0, y=0, m=1, scalar=1,
bt=Body.DYNAMIC):
'''
given point_1 (p1), point_2 (p2), thickness (thicc),
x-position (x), y-position (y), mass (m),
scalar <to augment the length>, body_type (bt)
return (body, shape) tuple for a line segment
'''
given_bt = bt
bt = Body.DYNAMIC if given_bt == 'dynamic' else Body.DYNAMIC
bt = Body.STATIC if given_bt == 'static' else Body.DYNAMIC
bt = Body.KINEMATIC if given_bt == 'kinematic' else Body.DYNAMIC
p2 = (p2[0] * scalar, p2[1] * scalar)
moment = moment_for_segment(mass=m, a=p1, b=p2, radius=thicc)
body = Body(mass=m, moment=moment, body_type=bt)
shape = Segment(body=body, a=p1, b=p2, radius=thicc)
body.position = (x, y)
return body, shape
def create_segments(self):
segment_thickness = 5.0
center = [self.x, self.y]
for i in range(len(self.segments) - 1):
# radius is the thickness of the segment
sa = (np.array(center) + np.array(self.segments[i])).tolist()
sb = (np.array(center) + np.array(self.segments[i + 1])).tolist()
moment_piece = pymunk.moment_for_segment(
mass=self.segment_mass,
a=sa,
b=sb,
radius=self.segment_thickness)
body = pymunk.Body(mass=self.segment_mass,
moment=moment_piece,
body_type=pymunk.Body.KINEMATIC)
piece = pymunk.Segment(body, sa, sb, radius=self.segment_thickness)
piece.color = (133, 153, 0)
#body.position = x, y
self.bodies_segments.append(body)
self.shapes_segments.append(piece)
def load_segment(tmxobject, map_height, static_body, defaults):
"""
Creates a pymunk.Segment parsed from a TiledObject instance.
:param TiledObject tmxobject: A TiledObject instance that represents a \
line segment with two points, A to B.
:param int map_height: The height of the TiledMap that the TiledObject \
was loaded from in pixels.
:rtype: pymunk.Segment
:return: A pymunk.Segment shape instance.
"""
segment_defaults = defaults["pymunktmx_segment"]
shape_attrs = get_shape_attrs(tmxobject, segment_defaults)
body_attrs = get_body_attrs(tmxobject, segment_defaults)
radius = shape_attrs[u"radius"]
shape = None
if body_attrs[u"static"]:
verts = [(p[0], map_height - p[1]) for p in tmxobject.points]
shape = pymunk.Segment(static_body, verts[0], verts[1], radius)
else:
x = float(tmxobject.x)
y = float(float(map_height) - tmxobject.y)
mass = body_attrs[u"mass"]
verts = [(p[0] - x, map_height - p[1] - y)
for p in tmxobject.points]
moment = pymunk.moment_for_segment(mass, verts[0], verts[1])
body = pymunk.Body(mass, moment)
set_attrs(body_attrs, body,
skip_keys=[u"position", u"mass", u"static"])
body.position = (x, y)
shape = pymunk.Segment(body, verts[0], verts[1], radius)
set_attrs(shape_attrs, shape, skip_keys=[u"radius"])
return [shape]
def build_physics(self, space):
moment = pymunk.moment_for_segment(self.mass, (0, 0),
(0, -self.length), self.width)
if isinstance(self.parent, Limb):
self.attpos = (0, -self.parent.length)
self.body = pymunk.Body(self.mass, moment, pymunk.Body.DYNAMIC)
self.body.position = self.attpos[0] + self.parent.body.position[0], \
self.attpos[1] + self.parent.body.position[1] + self.length / 2
#border = build_borders(self.width,-self.width,0,-self.length)
self.shape = pymunk.Segment(self.body, (0, 0), (0, -self.length),
self.width)
self.shape.friction = 20
#self.shape.elasticity = 0.5
self.joint = pymunk.constraint.PinJoint(self.parent.body, self.body,
self.attpos, (0, 0))
self.joint.distance = 0
self.joint.collide_bodies = False
self.mussle = pymunk.constraint.DampedRotarySpring(
self.parent.body, self.body, self.minangle, 500, 50)
self.shape.friction = 1
space.add(self.body, self.shape, self.joint, self.mussle)
self.update(0)
def load_segment(tmxobject, map_height, static_body, defaults):
"""
Creates a pymunk.Segment parsed from a TiledObject instance.
:param TiledObject tmxobject: A TiledObject instance that represents a \
line segment with two points, A to B.
:param int map_height: The height of the TiledMap that the TiledObject \
was loaded from in pixels.
:rtype: pymunk.Segment
:return: A pymunk.Segment shape instance.
"""
segment_defaults = defaults["pymunktmx_segment"]
shape_attrs = get_shape_attrs(tmxobject, segment_defaults)
body_attrs = get_body_attrs(tmxobject, segment_defaults)
radius = shape_attrs[u"radius"]
shape = None
if body_attrs[u"static"]:
verts = [(p[0], map_height - p[1]) for p in tmxobject.points]
shape = pymunk.Segment(static_body, verts[0], verts[1], radius)
else:
x = float(tmxobject.x)
y = float(float(map_height) - tmxobject.y)
mass = body_attrs[u"mass"]
verts = [(p[0] - x, map_height - p[1] - y) for p in tmxobject.points]
moment = pymunk.moment_for_segment(mass, verts[0], verts[1])
body = pymunk.Body(mass, moment)
set_attrs(body_attrs,
body,
skip_keys=[u"position", u"mass", u"static"])
body.position = (x, y)
shape = pymunk.Segment(body, verts[0], verts[1], radius)
set_attrs(shape_attrs, shape, skip_keys=[u"radius"])
return [shape]
def init_physics(self):
if self.physics_initialized:
logger.warning("Attempted multiple setups of physics for %s"
% self.id)
return
logger.debug("Setting up physics for %s" % self.id)
# set up chassis
body_rect = self.body_surf.get_rect()
half_width = body_rect.width / 2.0
inertia = pymunk.moment_for_segment(
self.CHASSIS_MASS, (-half_width, 0), (half_width, 0))
chassis_body = pymunk.Body(self.CHASSIS_MASS, inertia)
chassis_body.position = self.start_pos
chassis = pymunk.Segment(
chassis_body, (-half_width, 0), (half_width, 0),
body_rect.height // 2)
self.space.add(chassis_body, chassis)
self.chassis = chassis_body
# set up wheels
self.space.add(*self._make_wheel(
chassis_body,
body_rect,
self.WHEEL_MASS,
self.REAR_WHEEL_OFFSET_PERCENT,
self.WHEEL_VERTICAL_OFFSET))
self.space.add(*self._make_wheel(
chassis_body,
body_rect,
self.WHEEL_MASS,
self.FRONT_WHEEL_OFFSET_PERCENT,
self.WHEEL_VERTICAL_OFFSET))
self.physics_initialized = True
def __init__(self, space, p1, p2, thickness, mass, static, cosmetic=False):
x = (p1[0] + p2[0]) / 2
y = (p1[1] + p2[1]) / 2
if not cosmetic:
moment = pymunk.moment_for_segment(mass, (p1[0]-x, p1[1]-y), (p2[0]-x, p2[1]-y), thickness)
if static:
self.body = pymunk.Body(mass, moment, pymunk.Body.STATIC)
else:
self.body = pymunk.Body(mass, moment)
self.body.position = x, y
self.shape = pymunk.Segment(self.body, (p1[0]-x, p1[1]-y), (p2[0]-x, p2[1]-y), thickness)
space.add(self.body, self.shape)
self.radius = thickness
self.static = static
self._p1 = p1
self._p2 = p2
self._x = x;
self._y = y
super().__init__(cosmetic)
def create_body_segment(self, mass, a, b): inertia = pm.moment_for_segment(mass, a,b) body = pm.Body(mass, inertia) return body
def main():
shadowCapture = VectorShadowCapture()
pygame.init()
screen = pygame.display.set_mode([1280, 960])
pygame.display.set_caption("Shadow Caster Level 3")
clock = pygame.time.Clock()
draw_options = pymunk.pygame_util.DrawOptions(screen)
space = pymunk.Space(threaded=True)
space.gravity = (0.0, -1500.0)
static = [
pymunk.Segment(space.static_body, (200, 0), (1280, 0), 3),
pymunk.Segment(space.static_body, (1280, 0), (1280, 960), 3),
pymunk.Segment(space.static_body, (1280, 960), (0, 960), 3),
pymunk.Segment(space.static_body, (0, 960), (0, 0), 3)
]
for segment in static:
segment.friction = 1.
space.add(segment)
mass = 100
inertia = pymunk.moment_for_segment(mass, (-200, 0), (200, 0), 1)
bar = pymunk.Body(mass, inertia)
bar.position = 640, 240
barShape = pymunk.Segment(bar, (-400, 0), (400, 0), 10)
scaleFilter = pymunk.ShapeFilter(mask=pymunk.ShapeFilter.ALL_MASKS ^ 0x2)
barShape.filter = scaleFilter
space.add(bar, barShape)
pj = pymunk.PinJoint(space.static_body, bar, (640, 240), (0, 0))
space.add(pj)
# create gate
gate = pymunk.Body(1, pymunk.moment_for_segment(1, (0, 0), (0, 220), 1))
gate.position = 1040, 240
gateShape = pymunk.Segment(bar, (400, 0), (400, -240), 10)
gateShape.filter = scaleFilter
boxLeft = [
pymunk.Segment(bar, (-400, 0), (-400, 100), 3),
pymunk.Segment(bar, (-100, 0), (-100, 100), 3)
]
boxRight = [
pymunk.Segment(bar, (400, 0), (400, 100), 3),
pymunk.Segment(bar, (100, 0), (100, 100), 3)
]
for segment in boxLeft + boxRight:
segment.filter = scaleFilter
segment.friction = 1.
space.add(segment)
counterweightMoment = pymunk.moment_for_circle(100, 0, 145, (0, 0))
counterweight = pymunk.Body(50, counterweightMoment)
counterweightShape = pymunk.Poly(counterweight,
[[0, 0], [200, 0], [200, 100], [0, 100]])
counterweightShape.filter = scaleFilter
counterweightShape.color = (255, 0, 0)
counterweight.position = 744, 240
space.add(counterweightShape, counterweight)
space.add(gate, gateShape)
divider = pymunk.Segment(space.static_body, (640, 0), (640, 210), 5)
space.add(divider)
# Create objective ball_shape
mass = 1
radius = 60
inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0))
body = pymunk.Body(mass, inertia)
body.position = 700, 70
objective = pymunk.Circle(body, radius, (0, 0))
objective.elasticity = .5
objective.friction = 1
space.add(body, objective)
objectiveRegion = [1180, 100, 1280, 0]
ticks_to_next_ball = 10
finished = False
balls = []
while not finished:
finished = inRegion(objectiveRegion, objective.body)
for event in pygame.event.get():
if event.type == QUIT:
sys.exit(0)
elif event.type == KEYDOWN and event.key == K_ESCAPE:
sys.exit(0)
elif event.type == KEYDOWN and event.key == K_SPACE:
shadowCapture.resetBackground()
ticks_to_next_ball -= 1
if ticks_to_next_ball <= 0:
ticks_to_next_ball = 25
ball_shape = add_ball(space)
balls.append(ball_shape)
#remove irrelevant balls
balls_to_remove = []
for ball in balls:
if ball.body.position.y < 0:
balls_to_remove.append(ball)
for ball in balls_to_remove:
space.remove(ball, ball.body)
balls.remove(ball)
surface = shadowCapture.update(
space
) # Update the space with what's captured in the camera. Return a pygame image of the silhouette.
screen.fill((255, 255, 255))
pygame.draw.circle(surface, (255, 0, 0), (1210, 890), 70, 3)
screen.blit(surface, surface.get_rect())
space.debug_draw(draw_options)
space.step(1 / 50.0)
pygame.display.flip()
clock.tick(50)
screen.fill((225, 255, 255))
font = pygame.font.SysFont("Arial", 32)
screen.blit(
font.render("Level 3 Complete! Esc to close window", 1, (0, 0, 0)),
(480, 480))
pygame.display.flip()
while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit(0)
elif event.type == KEYDOWN and event.key == K_ESCAPE:
sys.exit(0)
poly = pymunk.Poly.create_box(None, size=(50, 50))
moment = pymunk.moment_for_poly(1, vertices=poly.get_vertices())
body = pymunk.Body(1, moment, pymunk.Body.DYNAMIC
) #rigid body (without shape right now); params: mass, MOI
poly.body = body
body.position = 640, 700
mass = 1
radius = 30
circle_moment = pymunk.moment_for_circle(mass, 0, radius)
circle_body = pymunk.Body(mass, circle_moment)
circle_body.position = 100, 700
circle_shape = pymunk.Circle(circle_body, radius)
segment_moment = pymunk.moment_for_segment(mass, (0, 0), (0, 400),
2) #end points and thickness
segment_body = pymunk.Body(mass, segment_moment)
segment_body.position = 400, 300
segment_shape = pymunk.Segment(segment_body, (0, 0), (0, 400), 2)
triangle_shape = pymunk.Poly(None, ((0, 0), (100, 0), (50, 100)))
triangle_moment = pymunk.moment_for_poly(mass, triangle_shape.get_vertices())
traingle_body = pymunk.Body(mass, triangle_moment)
traingle_body.position = 700, 700
triangle_shape.body = traingle_body
penta_shape = pymunk.Poly(None, ((0, 0), (100, 0), (150, 100), (50, 200),
(-50, 100)))
penta_moment = pymunk.moment_for_poly(mass, penta_shape.get_vertices())
penta_body = pymunk.Body(mass, penta_moment)
penta_body.position = 900, 700
space = pymunk.Space()
space.gravity = 0, 500
# DYNAMIC, affected by gravity and other forces (ball, player, enemies etc.)
# KINEMATIC, not affected by gravity or other forces, but can be moved programatically (platforms, doors)
# STATIC, not affected by gravity or other forces, and cannot be moved (ground, building, immovable objects)
mass = 1
radius = 30
circle_moment = pymunk.moment_for_circle(mass, 0, radius)
circle_body = pymunk.Body(mass, circle_moment)
circle_body.position = 100, 100
circle_shape = pymunk.Circle(circle_body, radius)
ceiling_moment = pymunk.moment_for_segment(mass, (0, 0), (800, 0), 5)
ceiling_body = pymunk.Body(mass,
ceiling_moment,
body_type=pymunk.Body.KINEMATIC)
ceiling_shape = pymunk.Segment(ceiling_body, (0, 0), (800, 0), 5)
ceiling_body.position = 100, 700
poly_shape = pymunk.Poly.create_box(None, size=(50, 50))
poly_moment = pymunk.moment_for_poly(mass, poly_shape.get_vertices())
poly_body = pymunk.Body(mass, poly_moment)
poly_shape.body = poly_body
poly_body.position = 250, 100
segment_moment = pymunk.moment_for_segment(mass, (0, 0), (0, 400), 2)
segment_body = pymunk.Body(mass, segment_moment)
segment_shape = pymunk.Segment(segment_body, (0, 0), (0, 400), 2)
def main():
pygame.init()
screen = pygame.display.set_mode((xmax, ymax))
clock = pygame.time.Clock()
running = True
### Physics stuff
space = pymunk.Space()
space.gravity = 0.0, 0.0
# walls - the left-top-right walls
walls = [
pymunk.Segment(space.static_body, (-wallw, -wallw),
(-wallw, ymax + wallw), wallw),
pymunk.Segment(space.static_body, (-wallw, ymax + wallw),
(xmax + wallw, ymax + wallw), wallw),
pymunk.Segment(space.static_body, (xmax + wallw, ymax + wallw),
(xmax + wallw, -wallw), wallw),
pymunk.Segment(space.static_body, (-wallw, -wallw), (xmax, -wallw),
wallw)
]
for s in walls:
s.friction = 0.0
s.elasticity = 1.0
s.group = 1
space.add(walls)
## Balls
balls = []
lines = []
run_physics = True
for i in range(10):
p = random.randint(ballr,
xmax - ballr), random.randint(ballr, ymax - ballr)
inertia = pymunk.moment_for_circle(ballm, 0, ballr, (0, 0))
body = pymunk.Body(ballm, inertia)
body.position = p
shape = pymunk.Circle(body, ballr, (0, 0))
shape.friction = 0.0
shape.elasticity = 1.0
space.add(body, shape)
power = random.randint(10, 1000) * 3
impulse = power * Vec2d(random.uniform(-1, 1), random.uniform(-1, 1))
body.apply_impulse_at_world_point(impulse, body.position)
balls.append(shape)
for i in range(3):
length = int(random.uniform(0, 0.5) * min(xmax, ymax))
p1 = Vec2d(random.randint(length, xmax - length),
random.randint(length, ymax - length))
p2 = p1 + Vec2d(random.uniform(-1, 1), random.uniform(
-1, 1)).normalized() * length
inertia = pymunk.moment_for_segment(linem, p1, p2, linew)
body = pymunk.Body(linem, inertia)
shape = pymunk.Segment(body, p1, p2, linew)
shape.friction = 0.0
shape.elasticity = 1.0
space.add(body, shape)
power = random.randint(10, 1000) * 3
impulse = power * Vec2d(random.uniform(-1, 1), random.uniform(-1, 1))
body.apply_impulse_at_world_point(
impulse, shape.a + (shape.b - shape.a) * random.uniform(0, 1))
lines.append(shape)
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
elif event.type == KEYDOWN and event.key == K_ESCAPE:
running = False
elif event.type == KEYDOWN and event.key == K_p:
pass
#pygame.image.save(screen, "balls_and_lines.png")
elif event.type == KEYDOWN and event.key == K_SPACE:
run_physics = not run_physics
### Update physics
if run_physics:
dt = 1.0 / 60.0
for x in range(1):
space.step(dt)
### Draw stuff
screen.fill(THECOLORS["white"])
for ball in balls:
r = ball.radius
v = ball.body.position
rot = ball.body.rotation_vector
p = int(v.x), int(flipy(v.y))
p2 = Vec2d(rot.x, -rot.y) * r * 0.9
pygame.draw.circle(screen, THECOLORS["blue"], p, int(r), 0)
pygame.draw.line(screen, THECOLORS["red"], p, p + p2)
for line in lines:
body = line.body
pv1 = body.position + line.a.rotated(body.angle)
pv2 = body.position + line.b.rotated(body.angle)
p1 = pv1.x, flipy(pv1.y)
p2 = pv2.x, flipy(pv2.y)
pygame.draw.line(screen, THECOLORS["orange"], p1, p2, linew)
### Flip screen
pygame.display.flip()
clock.tick(50)
pygame.display.set_caption("fps: " + str(clock.get_fps()))
def create_body_segment(self, mass, a, b):
inertia = pm.moment_for_segment(mass, a, b)
body = pm.Body(mass, inertia)
return body
def main(self):
self.count = 0
once = True
clock = pygame.time.Clock()
### Physics stuff
space = pymunk.Space()
space.gravity = 0.0, -1000.0
space.collision_slop = 0.0
##
options = pymunk.pygame_util.DrawOptions(self.screen)
## Balls
# storing the ball bodies
positions = []
### creating ground and boundaries
Right_bound = pymunk.Segment(space.static_body, (600, 0), (600, 600),
25)
Left_bound = pymunk.Segment(space.static_body, (0, 0), (0, 600), 25)
ground_shape = pymunk.Segment(space.static_body, (0, 0), (600, 0), 25)
Top_bound = pymunk.Segment(space.static_body, (0, 600), (600, 600), 25)
Top_bound.friction = 0.5
Left_bound.friction = 0.5
Right_bound.friction = 0.5
ground_shape.friction = 0.5
Top_bound.collision_type = COLLTYPE_ROOF
ground_shape.collision_type = COLLTYPE_GROUND
Left_bound.collision_type = COLLTYPE_LINE
Right_bound.collision_type = COLLTYPE_RIGHT
space.add(ground_shape, Right_bound, Left_bound, Top_bound)
if self.level == 1:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 575
### dynamic objects: ball
### objective: make the ball hit the left wall
#collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_LINE)
coll.begin = self.coll_begin
#objects
moment = pymunk.moment_for_circle(25, 0, 50)
ball = pymunk.Body(25, moment)
shape = pymunk.Circle(ball, 50)
shape.collision_type = COLLTYPE_BALL
shape.friction = 0.5
#shape.color = (255,0,0)
ball.position = (300, 75)
space.add(ball, shape)
# Domain
self.x_values += [shape.body.position[0]]
self.y_values += [shape.body.position[1]]
if self.level == 2:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 575
### dynamic objects: ball on top of cross
### objective: make the ball touch the ground
#collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_GROUND)
coll.begin = self.coll_begin
#objects
moment = pymunk.moment_for_circle(15, 0, 15)
ball = pymunk.Body(15, moment)
shape = pymunk.Circle(ball, 15)
shape.collision_type = COLLTYPE_BALL
shape.friction = 0.5
ball.position = (300, 150)
space.add(ball, shape)
moment1 = pymunk.moment_for_segment(200, (-50, -100), (50, 100),
10)
moment2 = pymunk.moment_for_segment(200, (-50, 100), (50, -100),
10)
cross = pymunk.Body(400, moment1 + moment2)
shape1 = pymunk.Segment(cross, (-50, -100), (50, 100), 10)
shape2 = pymunk.Segment(cross, (-50, 100), (50, -100), 10)
cross.position = (300, 125)
space.add(cross, shape1, shape2)
self.x_values = [shape1.body.position[0], shape2.body.position[0]]
self.y_values = [shape1.body.position[1], shape2.body.position[1]]
if self.level == 3:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 575
### static objects: shelf
### dynamic objects: 3 balls, glass
### objective: make only 2 balls go inside the glass
# collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_LEVEL3)
coll.begin = self.coll_begin
# objects
shelf = pymunk.Segment(space.static_body, (25, 300), (150, 300),
10)
moment1 = pymunk.moment_for_segment(200, (-100, -100), (100, -100),
10)
moment2 = pymunk.moment_for_segment(200, (-100, 100), (-100, -100),
10)
moment3 = pymunk.moment_for_segment(200, (100, 100), (100, -100),
10)
glass = pymunk.Body(600, moment1 + moment2 + moment3)
glass.position = (300, 150)
shape1 = pymunk.Segment(glass, (-100, -100), (100, -100), 10)
shape2 = pymunk.Segment(glass, (-100, 100), (-100, -100), 10)
shape3 = pymunk.Segment(glass, (100, 100), (100, -100), 10)
shape1.friction = 0.5
shape2.friction = 0.5
shape3.friction = 0.5
shape1.collision_type = COLLTYPE_LEVEL3
moment = pymunk.moment_for_circle(50, 0, 10)
ball1 = pymunk.Body(50, moment)
ball2 = pymunk.Body(50, moment)
ball3 = pymunk.Body(50, moment)
ball1.position = (50, 320)
ball2.position = (70, 320)
ball3.position = (90, 320)
circ1 = pymunk.Circle(ball1, 10)
circ2 = pymunk.Circle(ball2, 10)
circ3 = pymunk.Circle(ball3, 10)
circ1.friction = 0.5
circ2.friction = 0.5
circ3.friction = 0.5
circ1.collision_type = COLLTYPE_BALL
circ2.collision_type = COLLTYPE_BALL
circ3.collision_type = COLLTYPE_BALL
space.add(glass, ball1, ball2, ball3, circ1, circ2, circ3, shape1,
shape2, shape3, shelf)
if self.level == 4:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 575
## Objects: ball inside the arc
## Objective: get the ball outside the arc
#collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_GROUND)
coll.post_solve = self.coll_begin
# Creating objects
moment = pymunk.moment_for_circle(15, 0, 15)
ball = pymunk.Body(15, moment)
shape = pymunk.Circle(ball, 15)
shape.collision_type = COLLTYPE_BALL
shape.friction = 0.5
ball.position = (300, 64)
space.add(ball, shape)
moment_arc = pymunk.moment_for_circle(200, 40, 50)
arc = pymunk.Body(200, moment_arc)
arc.position = (300, 89)
space.add(arc)
for x in range(-50, 51):
y1 = sqrt(2500 - (x)**2)
y2 = -sqrt(2500 - (x)**2)
if y1 < 40:
shape1 = pymunk.Segment(arc, (x - 1, y1 - 1), (x, y1), 7)
space.add(shape1)
shape2 = pymunk.Segment(arc, (x - 1, y2 + 1), (x, y2), 7)
space.add(shape2)
if self.level == 5:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 575
## Objects: Segments to make an arc, ball that fits in the arc
## Objective: Make the ball touch the right wall
# Collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_RIGHT)
coll.post_solve = self.coll_begin
# objects
# static Objects
shape = pymunk.Segment(space.static_body, (25, 225), (225, 225), 5)
middle = pymunk.Segment(space.static_body, (125, 115), (125, 135),
5)
ground = pymunk.Segment(space.static_body, (25, 25), (575, 25), 5)
space.add(shape, middle, ground)
for x in range(126, 225):
y1 = sqrt(10000 - (x - 225)**2) + 125
y2 = -sqrt(10000 - (x - 225)**2) + 125
shape1 = pymunk.Segment(space.static_body, (x - 1, y1 - 1),
(x, y1), 5)
shape2 = pymunk.Segment(space.static_body, (x - 1, y2 + 1),
(x, y2), 5)
space.add(shape1, shape2)
# dynamic objects
moment = pymunk.moment_for_circle(400, 80, 90)
ball = pymunk.Body(400, moment)
ball.position = (225, 125)
space.add(ball)
for x in range(-90, 91):
y1 = sqrt(8100 - (x)**2)
y2 = -sqrt(8100 - (x)**2)
shape1 = pymunk.Segment(ball, (x - 1, y1 - 1), (x, y1), 7)
shape2 = pymunk.Segment(ball, (x - 1, y2 + 1), (x, y2), 7)
shape1.friction = 0.5
shape2.friction = 0.5
shape1.collision_type = COLLTYPE_BALL
shape2.collision_type = COLLTYPE_BALL
space.add(shape1, shape2)
if self.level == 6:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 575
## Objects: a ball inside a glass
## Objective: Make the ball hit the left wall
# Collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_LINE)
coll.post_solve = self.coll_begin
# Objects
moment = pymunk.moment_for_poly(300, [(225, 225), (325, 225),
(225, 25), (325, 25)])
glass = pymunk.Body(300, moment)
glass.position = (300, 85)
line1 = pymunk.Segment(glass, (-50, 50), (-50, -50), 10)
line2 = pymunk.Segment(glass, (-50, 50), (50, 50), 10)
line3 = pymunk.Segment(glass, (50, 50), (50, -50), 10)
line1.friction = 0.5
line2.friction = 0.5
line3.friction = 0.5
ball_moment = pymunk.moment_for_circle(50, 0, 12)
ball = pymunk.Body(50, ball_moment)
ball.position = (300, 35)
ball_shape = pymunk.Circle(ball, 12)
ball_shape.friction = 0.5
ball_shape.collision_type = COLLTYPE_BALL
space.add(glass, line1, line2, line3, ball, ball_shape)
if self.level == 7:
self.x_start = 25
self.x_end = 300
self.y_start = 25
self.y_end = 575
## Objects: a ball on top of a bar and a glass/box
##Objective: Make the ball fall inside the glass
##Constraint: Can only draw in one half of the screen
# Collision
coll = space.add_collision_handler(COLLTYPE_BALL, COLLTYPE_LEVEL3)
coll.post_solve = self.coll_begin
# Constraint
# Objects
# Static
bar = pymunk.Segment(space.static_body, (350, 25), (350, 125), 12)
space.add(bar)
# Dynamic
moment = pymunk.moment_for_circle(50, 0, 10)
ball = pymunk.Body(50, moment)
ball.position = (350, 140)
ball_shape = pymunk.Circle(ball, 10)
ball_shape.friction = 0.5
ball_shape.collision_type = COLLTYPE_BALL
moment = pymunk.moment_for_poly(200, [(-20, 20), (-20, -20),
(20, -20), (20, 20)])
glass = pymunk.Body(200, moment)
glass.position = (500, 45)
line1 = pymunk.Segment(glass, (-20, 20), (-20, -20), 5)
line2 = pymunk.Segment(glass, (-20, -20), (20, -20), 5)
line3 = pymunk.Segment(glass, (20, -20), (20, 20), 5)
line2.collision_type = COLLTYPE_LEVEL3
line1.friction = 0.5
line2.friction = 0.5
line3.friction = 0.5
space.add(glass, ball, ball_shape, line1, line2, line3)
if self.level == 8:
self.x_start = 25
self.x_end = 575
self.y_start = 25
self.y_end = 400
# no object
# Objectif: Make an object hit the roof
# Constraint: Can not draw in the upper quarter of the screen
# Collision
coll = space.add_collision_handler(COLLTYPE_DEFAULT, COLLTYPE_ROOF)
coll.post_solve = self.coll_begin
if self.level == 9:
self.x_start = 25
self.x_end = 575
self.y_start = 300
self.y_end = 575
# static objects : 4 dots, hanging arc
# dynamic object: open box
# Objective: fill the box with any drawn object
# Constraint: Can not draw in the upper half of the screen
# Collision
coll = space.add_collision_handler(COLLTYPE_DEFAULT,
COLLTYPE_LEVEL3)
coll.post_solve = self.coll_begin
# Static object
dot1 = pymunk.Body(body_type=pymunk.Body.STATIC)
ball1 = pymunk.Circle(dot1, 12)
dot1.position = (250, 100)
dot2 = pymunk.Body(body_type=pymunk.Body.STATIC)
ball2 = pymunk.Circle(dot2, 12)
dot2.position = (200, 125)
dot3 = pymunk.Body(body_type=pymunk.Body.STATIC)
ball3 = pymunk.Circle(dot3, 12)
dot3.position = (350, 100)
dot4 = pymunk.Body(body_type=pymunk.Body.STATIC)
ball4 = pymunk.Circle(dot4, 12)
dot4.position = (400, 125)
for x in range(276, 326):
y = sqrt(625 - ((x - 300)**2)) + 275
shape1 = pymunk.Segment(space.static_body, (x - 1, y - 1),
(x, y), 5)
shape1.friction = 0.5
space.add(shape1)
# Dynamic object
body = pymunk.Body(
50,
pymunk.moment_for_poly(50, [(275, 75), (325, 75), (275, 25),
(325, 25)]))
body.position = (300, 75)
shape1 = pymunk.Segment(body, (-25, 25), (-25, -25), 5)
shape2 = pymunk.Segment(body, (-25, -25), (25, -25), 5)
shape3 = pymunk.Segment(body, (25, -25), (25, 25), 5)
shape1.friction = 0.5
shape2.friction = 0.5
shape3.friction = 0.5
shape2.collision_type = COLLTYPE_LEVEL3
space.add(shape1, shape2, shape3, body, ball1, ball2, ball3, ball4,
dot1, dot2, dot3, dot4)
run_physics = False
positions = []
objects = []
p = (0, 0)
playAgain = pygame.image.load("PlayAgain_button.png")
playAgain = pygame.transform.scale(playAgain, (28, 28))
home = pygame.image.load("home_button.png")
home = pygame.transform.scale(home, (28, 28))
pause = pygame.image.load("pause_button.png")
pause = pygame.transform.scale(pause, (28, 28))
qst = pygame.image.load("qst_button.png")
qst = pygame.transform.scale(qst, (28, 28))
while self.run:
for event in pygame.event.get():
if event.type == QUIT:
self.run = False
quit()
elif event.type == MOUSEMOTION:
if event.buttons[0]:
run_physics = False
p = int(event.pos[0]), int(flipy(event.pos[1]))
#print(self.x_values)
if self.domain(p[0], p[1]) and self.customDomain(
p[0], p[1]):
positions.append(p)
elif event.type == MOUSEBUTTONUP:
run_physics = True
once = True
moment = pymunk.moment_for_circle(10, 0, 12)
body = pymunk.Body(
len(positions) * 10, moment * len(positions))
if positions:
body.position = calculateCG(positions)
for p in relToCG(positions):
obj = pymunk.Circle(body, 12, p)
#obj.color = (255,255,255)
obj.friction = 0.5
obj.collision_type = COLLTYPE_DEFAULT
objects.append(obj)
space.add(objects, body)
fillShape(space, body, relToCG(positions))
positions = []
objects = []
### Update physics
if run_physics:
dt = 1.0 / 60.0
for x in range(1):
space.step(dt)
### Update self.screen
self.screen.fill(THECOLORS["black"])
if self.level == 7:
self.screen.fill((170, 4, 19, 255), (300, 0, 300, 600))
if self.level == 8:
self.screen.fill((170, 4, 19, 255), (0, 0, 600, 200))
if self.level == 9:
self.screen.fill((170, 4, 19, 255), (0, 300, 600, 300))
### Show pymunk objects
space.debug_draw(options)
### getting all the positions of the shapes
for (x, y) in flip(positions):
pygame.draw.circle(self.screen, THECOLORS["white"], (x, y), 12)
fillIn(self.screen, flip(positions))
##Play Again button
self.button("",
585,
585,
20, (90, 110, 223, 255), (88, 159, 224, 225),
action=self.main)
self.screen.blit(playAgain, (570, 570))
##Go to start screen button
self.button("",
15,
585,
20, (90, 110, 223, 255), (88, 159, 224, 225),
action=self.start)
self.screen.blit(home, (1, 568))
##Pause button
self.button("",
15,
15,
20, (90, 110, 223, 255), (88, 159, 224, 225),
action=self.waitScreen)
self.screen.blit(pause, (1, 1))
##More info button
## Instructions
self.button("",
585,
15,
20, (90, 110, 223, 255), (88, 159, 224, 225),
action=self.display)
self.screen.blit(qst, (570, 2))
### Flip self.screen
pygame.display.flip()
self.screen.fill(THECOLORS["black"])
clock.tick(50)
pygame.display.set_caption("KineDRAWtics")
######## Circle ##############
circle_moment = pymunk.moment_for_circle(mass, 0, radius)
circle_body = pymunk.Body(mass, circle_moment)
circle_body.position = 100, 100
circle_shape = pymunk.Circle(circle_body, radius)
############# Square(POLY) ##############
poly_shape = pymunk.Poly.create_box(None, size=(50,50))
poly_moment = pymunk.moment_for_poly(mass, poly_shape.get_vertices())
poly_body = pymunk.Body(mass, poly_moment)
poly_shape.body = poly_body
poly_body.position = 250,100
############# Segment (Line) ###########
segment_moment = pymunk.moment_for_segment(mass, (0,0), (0,400), 2)
segment_body = pymunk.Body(mass, segment_moment)
segment_shape = pymunk.Segment(segment_body, (0,0), (0,400), 2)
segment_body.position = 400, 100
space.add(circle_body, circle_shape, poly_body, poly_shape, segment_body, segment_shape)
@window.event
def on_draw():
window.clear()
space.debug_draw(options)
def update(dt):
space.step(dt)
def __init__(self,
name,
space,
ptlist,
width,
density=DEFAULT_DENSITY,
elasticity=DEFAULT_ELASTICITY,
friction=DEFAULT_FRICTION,
inner_color=DEFAULT_GOAL_COLOR,
outer_color=DEFAULT_COLOR):
PGObject.__init__(self, name, "Container", space, outer_color, density,
friction, elasticity)
self.inner_color = inner_color
self.outer_color = outer_color
self.r = width / 2
loc = centroidForPoly(ptlist)
self.pos = np.array([loc.x, loc.y])
ptlist = copy.deepcopy(ptlist)
if density != 0:
ptlist = recenterPoly(ptlist)
#self.seglist = map(lambda p: pm.Vec2d(p), ptlist)
self.seglist = [pm.Vec2d(p) for p in ptlist]
self._area = np.pi * self.r * self.r
imom = 0
for i in range(len(self.seglist) - 1):
v1 = self.seglist[i]
v2 = self.seglist[i + 1]
larea = 2 * self.r * v1.get_distance(v2)
self._area += larea
imom += pm.moment_for_segment(larea * density, v1, v2, 0)
mass = density * self._area
if mass == 0:
uBody = space.static_body
else:
self._cpBody = uBody = pm.Body(mass, imom)
space.add(self._cpBody)
self._cpPolyShapes = []
self.polylist = segs2Poly(ptlist, self.r)
for pl in self.polylist:
pshp = pm.Poly(uBody, pl)
pshp.elasticity = elasticity
pshp.friction = friction
pshp.collision_type = COLTYPE_SOLID
pshp.name = name
self._cpPolyShapes.append(pshp)
space.add(pshp)
# Make sure we have ccw
if not polyValidate(ptlist):
ptlist.reverse()
self._cpSensor = pm.Poly(uBody, ptlist)
self._cpSensor.sensor = True
self._cpSensor.collision_type = COLTYPE_SENSOR
self._cpSensor.name = name
space.add(self._cpSensor)
if mass != 0:
self._cpBody.position = loc
valMovible = pymunk.Body.DYNAMIC
else:
valMovible = pymunk.Body.STATIC
if (valFriccion > 1):
valFriccion = 1.0
elif (valFriccion < 0):
valFriccion = 0.0
if (valRebote > 1):
valRebote = 1.0
elif (valRebote < 0):
valRebote = 0.0
lineaMomento = pymunk.moment_for_segment(valMasa, (valPosX1, valPosY1),
(valPosX2, valPosY2),
valMedida)
lineaCuerpo = pymunk.Body(valMasa, lineaMomento, valMovible)
lineaForma = pymunk.Segment(lineaCuerpo, (valPosX1, valPosY1),
(valPosX2, valPosY2), valMedida)
lineaForma.color = colores[valColor]
lineaCuerpo.position = 0, 0
lineaForma.friction = valFriccion
lineaForma.elasticity = valRebote
espacio.add(lineaCuerpo, lineaForma)
iApuntadorCuads += 2
elif (instruccion == "regresar"):
indOperando1 = tempCuad[1]
