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 __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 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]