Example #1
0
def create_walls():
    wall1_poly = pymunk.Poly.create_box(None, size=(10, full_height * 1.1))
    wall1_poly.collision_type = Coll_Type.ENVIRONMENT
    wall1_poly_moment = pymunk.moment_for_poly(250, wall1_poly.get_vertices())
    wall1_body = pymunk.Body(250, wall1_poly_moment, pymunk.Body.STATIC)
    wall1_poly.body = wall1_body
    wall1_body.position = 0, 0
    space.add(wall1_poly, wall1_body)

    wall2_poly = pymunk.Poly.create_box(None, size=(full_width * 2.3, 10))
    wall2_poly.collision_type = Coll_Type.ENVIRONMENT
    wall2_poly_moment = pymunk.moment_for_poly(250, wall2_poly.get_vertices())
    wall2_body = pymunk.Body(250, wall2_poly_moment, pymunk.Body.STATIC)
    wall2_poly.body = wall2_body
    wall2_body.position = 0, full_height
    space.add(wall2_poly, wall2_body)

    wall3_poly = pymunk.Poly.create_box(None, size=(10, full_height * 2.3))
    wall3_poly.collision_type = Coll_Type.ENVIRONMENT
    wall3_poly_moment = pymunk.moment_for_poly(250, wall3_poly.get_vertices())
    wall3_body = pymunk.Body(250, wall3_poly_moment, pymunk.Body.STATIC)
    wall3_poly.body = wall3_body
    wall3_body.position = full_width, 0
    space.add(wall3_poly, wall3_body)

    wall4_poly = pymunk.Poly.create_box(None, size=(full_width * 1.1, 10))
    wall4_poly.collision_type = Coll_Type.ENVIRONMENT
    wall4_poly_moment = pymunk.moment_for_poly(250, wall4_poly.get_vertices())
    wall4_body = pymunk.Body(250, wall4_poly_moment, pymunk.Body.STATIC)
    wall4_poly.body = wall4_body
    wall4_body.position = 0, 0
    space.add(wall4_poly, wall4_body)
Example #2
0
 def __init_physiscs__(self):
     image_width = self.image.get_max_width() * 0.8
     offset = self.image.get_max_width() - image_width
     vs = [(offset, 0), (image_width, 0), (image_width, 64), (offset, 64)]
     mass = 30
     moment = pymunk.moment_for_poly(mass, vs)
     self.body = pymunk.Body(mass, pymunk.inf)
     self.shape = pymunk.Poly(self.body, vs)
     self.shape.friction = 0
     self.shape.collision_type = 20
     self.shape.elasticity = 0
     self.body.position = (segment_width * self.initial_positition[0],
                           self.initial_positition[0] * segment_height)
     self.body.center_of_gravity = 20, 0
     self.body.velocity_func = self.limit_velocity
     self.body.min_walk_x, self.body.max_walk_x = 0, 0
     self.body.current_max_velocity = Enemy.max_relative_velocity
     self.body.touching_ground = False
     self.moving_force = (40000, 0)
     self.space.add(self.body, self.shape)
     # Collison handlers
     self.platform_collision_handler = self.space.add_collision_handler(
         20, 3)
     self.player_collision_handler = self.space.add_collision_handler(20, 1)
     self.player_collision_handler.pre_solve = Enemy.attack
     self.player_collision_handler.separate = Enemy.cease_attack
     self.platform_collision_handler.pre_solve = Enemy.standing_on_platform
     self.platform_collision_handler.separate = Enemy.separated_from_platform
     self.body.attack = False
Example #3
0
    def __init__(self, pos=(0, 0), color=Color.RED, idn=0, client_id=0):
        self.alive = True
        self.hp = 100
        self.ammo1 = 40
        self.ammo2 = 5
        self.isReloading = False
        self.color = color
        self.rotating = False
        self.moving = False
        self.idn = idn
        self.CLIENT_ID = client_id
        self.ammo_type = SharedProjectile.Ammo_Type.REGULAR
        self.command = SharedTank.Command.NOTHING
        self.poly = pymunk.Poly.create_box(None,
                                           size=(SharedTank.HEIGHT,
                                                 SharedTank.WIDTH),
                                           radius=0.1)
        self.poly.collision_type = Coll_Type.TANK
        self.poly.idn = self.idn
        self.moment = pymunk.moment_for_poly(50000, self.poly.get_vertices())
        self.body = pymunk.Body(50000, self.moment, pymunk.Body.DYNAMIC)
        self.poly.body = self.body
        self.body.position = pos

        barrelImg = pyglet.image.load("res/PNG/tanks/barrel%s_outline.png" %
                                      color.value)
        barrelImg.anchor_x = barrelImg.width // 2
        barrelImg.anchor_y = (barrelImg.height // 2) - 15
        self.barrelSprite = FakeSprite((pos[0], pos[1]))
        space.add(self.poly, self.body)
Example #4
0
	def __init__(self,cellspace,num,pos,angle,radius=4,mass=0.1,**kwargs):
		##{{{
		## Cell Attributes
		super(cellc, self).__init__(cellspace,num,pos,angle,**kwargs)
		self.radius=radius #Radius of hemisphere at cell end
		self.length=self.radius*2 #The length of the cell measured from the center of the two hemisphere
		self.height=self.radius*2 #The height of the box connecting the two hemisphere. = diameter
		self.mass=mass #Self Explanatory
		self.color="red"
		self.growthrate=0.5 #Growth rate can be a function of a state variable eventually	
		self.cycle='grow'
		for i in kwargs.iterkeys(): 
			vars(self)[i]=kwargs[i]

		## Initializing cell in space
		inertia=pm.moment_for_poly(self.mass,\
		[(-self.length/2.0,-self.height/2.0), (-self.length/2.0,self.height/2.0), (self.length/2.0,self.height/2.0), (self.length/2.0,-self.height/2.0)],\
		(0,0))
		self.body=pm.Body(self.mass,inertia)
		self.body.position = pos
		self.body.angle = angle
		#-----------
		self.box = pm.Poly(self.body, [(0,0), (0,self.height), (self.length,self.height), (self.length,0)],\
		(-self.length/2.,-self.height/2.)) # Connecting box
		self.left = pm.Circle(self.body,self.radius,(-self.length/2.,0)) # left hemisphere
		self.right = pm.Circle(self.body,self.radius,(self.length/2.,0)) # right hemisphere
		#-----------
		self.left.color=self.right.color=self.box.color = pg.color.THECOLORS[self.color]
		self.space.add(self.body, self.left, self.right, self.box)
Example #5
0
	def __init__(self,cellspace,num,pos,angle,radius=5,length=None,vertices=6,mass=0.1,biochem=None,**kwargs):
		##{{{
		## Cell Attributes
		super(cellp, self).__init__(cellspace,num,pos,angle,biochem=biochem,**kwargs)
		self.radius=radius #Radius of hemisphere at cell end. Radius is in uM
		self.length=radius*2 if length is None else length #The length of the cell measured from the center of the two hemisphere
		self.height=self.radius*2
		self.vertices=vertices #Number of vertices in the hemisphere
		self.mass=mass #Self Explanatory
		self.color=pg.color.THECOLORS["red"]

		self.growthrate=0.05 #Growth rate can be a function of a state variable eventually. um/s growth in length
		self.divmean=4.*self.radius #Threshold for division
		self.divstd=0.1*self.divmean
		self.divthreshold=self.divmean+self.divstd*np.random.randn(1) #Threshold decided at the start to reduce computational cost

		self.cycle='grow'
		self.kwargs=kwargs	# This is done so that when the cell divides, any special attribute
							# will be transfered to the daughter cell.
		for i in kwargs.iterkeys(): 
			vars(self)[i]=kwargs[i]

		## Initializing cell in space
		self._genpoly()
		inertia=pm.moment_for_poly(self.mass,self.ver, (0,0))
		self.body=pm.Body(self.mass,inertia)
		self.body.position = pos
		self.body.angle = angle
		#-----------
		self.box = pm.Poly(self.body,self.ver,(-self.length/2.,-self.height/2.)) # Connecting box
		#-----------
		self.box.elasticity=0.5
		self.box.friction=0
		self.box.color = self.color
		self.space.add(self.body, self.box)
Example #6
0
def create_square_thing(world, layer, position, image):
    points = [(0,0),(32,0),(32,32),(0,32)]
    shape = ConvexPolygonShape(*points)
    shape.translate( shape.centroid() * -1)
    moment = pymunk.moment_for_poly( 1.0, shape.vertices )
    rv = Debris( world, layer, position, shape, image, moment = moment, collision_type = physics.CollisionTypes["main"] )
    return rv
Example #7
0
    def __init__(self, position):
        super(Player, self).__init__()
        self.v1 = 50
        self.v2 = 15
        #Pymunk physics variables.
        self.verts = [(-self.v2, -self.v1), (-self.v2, self.v1), (self.v2, self.v1), (self.v2, -self.v1)]
        self.mass = 100
        self.friction = 9
        self.elasticity = 0
        self.moment = pymunk.moment_for_poly(self.mass, self.verts)
        self.body = pymunk.Body(self.mass, self.moment)
        self.body.position = position
        self.shape = pymunk.Poly(self.body, self.verts)
        #self.shape.group = 1
        #self.shape.layers = 1
        #self.shape.collision_type = 1
        self.shape.friction = 0.1
        self.shape.elasticity = 0.9
        self.shape.collision_type = 2
        self.pin_body = pymunk.Body()
        self.pin_body.position = self.body.position
        self.spring = pymunk.DampedRotarySpring(self.body, self.pin_body, 0, 20000000, 900000)

        self.groove_body = pymunk.Body()
        self.groove_body.position = (self.body.position.x, 0)
        self.groove = pymunk.GrooveJoint(self.groove_body, self.body, (0, 0), (0, 768), (0,0))
Example #8
0
def create_bananas(space):
    mass = 10
    size = 50
    points = [(-size, -size), (-size, size), (size,size), (size, -size)]
    moment = pymunk.moment_for_poly(mass, points, (0,0))
    body = pymunk.Body(mass, moment)
    x = random.randint(0, 500)
    body.position = Vec2d(x,x)
    banana = pymunk.Poly(body, points, (0,0))
    #banana.friction = 2
    banana.elasticity = 0.95
    space.add(body, banana)

    """
    Circular Banana

    radius = 10
    inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0))
    body = pymunk.Body(mass, inertia)
    x = random.randint(0, 500)
    body.position = x, x
    banana = pymunk.Circle(body, radius, (0, 0))
    banana.elasticity = 0.95
    space.add(body, banana)
    """
    return banana
Example #9
0
    def generateBodyAndShape(self, physObj, body=None, rel_pos=(0, 0)):
        if body is None:
            moment = pymunk.moment_for_poly(physObj.mass, self.verts)
            body = pymunk.Body(
                physObj.mass, moment, body_type=pymunk.Body.STATIC if physObj.static else pymunk.Body.DYNAMIC
            )
        shape = pymunk.Poly(
            body,
            self.verts,
            transform=pymunk.Transform(
                a=np.cos(physObj.rotation),
                b=np.sin(physObj.rotation),
                c=-np.sin(physObj.rotation),
                d=np.cos(physObj.rotation),
                tx=rel_pos[0],
                ty=rel_pos[1],
            ),
        )
        shape.friction = physObj.friction_coefficient
        shape.elasticity = physObj.restitution_coefficient
        shape.collision_type = 1
        shape.sensor = physObj.sensor
        from ev3sim.objects.base import STATIC_CATEGORY, DYNAMIC_CATEGORY

        shape.filter = pymunk.ShapeFilter(categories=STATIC_CATEGORY if physObj.static else DYNAMIC_CATEGORY)
        return body, shape
Example #10
0
    def create_world(self):
        fp = [(self.tray_width / 2, -self.tray_height / 2),
              (-self.tray_width / 2, self.tray_height / 2),
              (self.tray_width / 2, self.tray_height / 2),
              (-self.tray_width / 2, -self.tray_height / 2),
              (-self.tray_width / 2, -self.tray_height / 2)]

        mass = 100
        moment = pymunk.moment_for_poly(mass, fp[0:2])

        self.trayBody = pymunk.Body(mass, moment)
        self.trayBody.position = self.tray_x_pos, self.tray_y_pos
        self.trayBody.angle = self.tray_angle
        trayShape = pymunk.Poly(self.trayBody, fp)
        if self.tray_has_ends:
            side1 = [(self.tray_width / 2, self.tray_height / 2),
                     (self.tray_width / 2, self.tray_height * 4),
                     (self.tray_width / 2 - 1, self.tray_height * 4),
                     (self.tray_width / 2 - 1, self.tray_height / 2)]
            side2 = [(-self.tray_width / 2, self.tray_height / 2),
                     (-self.tray_width / 2, self.tray_height * 4),
                     (-self.tray_width / 2 + 1, self.tray_height * 4),
                     (-self.tray_width / 2 + 1, -self.tray_height / 2)]
            self.side1_shape = pymunk.Poly(self.trayBody, side1)
            self.side2_shape = pymunk.Poly(self.trayBody, side2)
            self.space.add(self.side1_shape, self.side2_shape)
        self.space.add(self.trayBody, trayShape)

        trayJointBody = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
        trayJointBody.position = self.trayBody.position
        j = pymunk.PinJoint(self.trayBody, trayJointBody, (0, 0), (0, 0))
        self.space.add(j)

        self.__add_ball()
Example #11
0
    def add_dynamic_structure(self,
                              pos,
                              walls,
                              segments,
                              name,
                              mass,
                              center_of_gravity,
                              action_on_touch=None,
                              is_slippery_slope=False,
                              correct_angle=False):

        points = []
        for a, b in walls:
            points.append(a)
            points.append(b)

        moment = pymunk.moment_for_poly(mass, points, radius=1)

        body = pymunk.Body(mass, moment, pymunk.Body.DYNAMIC)

        body.center_of_gravity = center_of_gravity

        body.position = pos
        self.reindex_shapes_for_body(body)

        self._add_structure(pos, walls, segments, name, action_on_touch,
                            is_slippery_slope, body, (0.7, 1))
Example #12
0
    def __init__(self):
        self.type = 'attractor'

        self.radius = 320000
        self.density = 0.5

        self.mass = self.density * (math.pi * (self.radius * self.radius))

        # size = self.radius
        self.points = make_circle(self.radius, 314)
        inertia = pymunk.moment_for_poly(self.mass, self.points, (0, 0))
        self.body = pymunk.Body(self.mass, inertia)
        # self.body.position = position
        self.body.position = 1, 1
        # self.body.apply_impulse_at_local_point(velocity, [0,0])
        self.shape = pymunk.Poly(self.body, self.points)

        #inertia = pymunk.moment_for_circle(self.mass, 0, self.radius, (0,0))
        #self.body = pymunk.Body(self.mass, inertia)

        #self.shape = pymunk.Circle(self.body, self.radius, (0,0))
        self.shape.friction = 0.5

        self.color = (190, 165, 145)

        self.atmosphere = Atmosphere(self)
Example #13
0
 def __init__(self,
              pos=(0, 0),
              color=Color.RED,
              idn=0,
              src_idn=0,
              client_id=0,
              type=Ammo_Type.REGULAR):
     self.idn = idn
     self.src_idn = src_idn
     self.CLIENT_ID = client_id
     self.color = color
     self.type = type
     self.damage = 10
     self.velocity = 1000
     if self.type == SharedProjectile.Ammo_Type.AP:
         self.damage = 34
         self.velocity = 1500
     self.poly = pymunk.Poly.create_box(None,
                                        size=(SharedProjectile.HEIGHT,
                                              SharedProjectile.WIDTH))
     self.poly.collision_type = Coll_Type.PROJECTILE
     self.poly.idn = self.idn
     self.moment = pymunk.moment_for_poly(25, self.poly.get_vertices())
     self.body = pymunk.Body(25, self.moment, pymunk.Body.DYNAMIC)
     self.poly.body = self.body
     self.body.position = pos
     space.add(self.poly, self.body)
Example #14
0
  def add_square(self, pos, a=18, density=0.1, friction=0.2, elasticity=0.3):
    """ Adding a Square | Note that a is actually half a side, due to vector easyness :) 
        Parameter: pos == (int(x), int(y))
        Optional: a == (sidelen/2) | #physical_parameters
        Returns: pymunk.Shape() (=> .Poly())
    """
    mass = density * (a * a * 4)
    
    # Square Vectors (Clockwise)
    verts = [Vec2d(-a,-a), Vec2d(-a, a), Vec2d(a, a), Vec2d(a,-a)]
    
    # Square Physic Settings
    inertia = pm.moment_for_poly(mass, verts, Vec2d(0,0))
  
    # Create Body
    body = pm.Body(mass, inertia)
    body.position = self.Vec2df(pos)
  
    # Create Shape
    shape = pm.Poly(body, verts, Vec2d(0,0))
    shape.riction = friction
    shape.elasticity = elasticity

    shape.color = self.get_color()
    shape.color2 = self.get_color()
          
    # Append to Space
    self.space.add(body, shape)
    self.element_count += 1
    return shape
Example #15
0
    def __init__(self, position, velocity):
        self.type = 'actor'

        self.mass = 0
        self.points = []

        self.modules = []
        self.modules.append(Module([6, 0]))
        self.modules.append(Module([-6, 0]))

        for module in self.modules:
            self.mass += module.mass
            self.points += module.points

        # print self.mass
        # print self.points

        inertia = pymunk.moment_for_poly(self.mass, self.points, (0, 0))
        self.body = pymunk.Body(self.mass, inertia)
        self.body.position = position
        self.body.apply_impulse_at_local_point(velocity, [0, 0])
        self.shape = pymunk.Poly(self.body, self.points)
        self.shape.friction = 0.5

        self.orbit = None  #initpos_to_orbit(self.)

        self.freefalling = True
        self.interacting = False

        self.color = (200, 50, 50)

        self.image = None  #preprocessed image used to 'blit' onto the screen.

        self.availableResources = {}
Example #16
0
    def _build_physics_elements(self):
        self.dynamic_object = []
        for element in self.collect_object_list:
            width, height = element.size
            mass = width * height
            if element.is_circle:
                moment = pymunk.moment_for_circle(mass, 0, 100)
                body = pymunk.Body(mass, moment)
                shape = pymunk.Circle(body, width/2)
                body.elasticity = 0.9
            else:
                vs = [(-width/2, height/2), (width/2, height/2), (width/2, -height/2), (-width/2, -height/2)]
                moment = pymunk.moment_for_poly(mass, vs)
                body = pymunk.Body(mass, moment)
                shape = pymunk.Poly(body, vs)
            shape.friction = 0.6
            body.position = element.position[0]+width/2, self.flipy(element.position[1]+height/2)
            body.angle = math.pi
            self.space.add(body, shape)
            self.dynamic_object.append((element, shape))

        static_body = pymunk.Body()
        for element in self.collide_object_list:
            x, y = element.position[0], self.flipy(element.position[1])
            width, height = element.size[0], element.size[1]
            static_lines = [pymunk.Segment(static_body, (x, y), (x+width, y), 0.0),
                            pymunk.Segment(static_body, (x+width, y), (x+width, y-height), 0.0),
                            pymunk.Segment(static_body, (x+width, y-height), (x, y-height), 0.0),
                            pymunk.Segment(static_body, (x, y-height), (x, y), 0.0),
                            ]
            for l in static_lines:
                l.friction = 0.5
            self.space.add(static_lines)
Example #17
0
	def create_body_poly(self, mass, posinit, points):
		center = pm.util.calc_center(points)
		points = pm.util.poly_vectors_around_center(points)
		moment = pm.moment_for_poly(mass,points, Vec2d(0,0))
		body = pm.Body(mass, moment)
		body.position = Vec2d(posinit)
		return body, points
Example #18
0
    def __init__(self,x=600,y=-20,angle=0,angular_velocity=0,buoyancy=pymunk.Vec2d(0,-8000)):
        pygame.sprite.Sprite.__init__(self)
        self.image_default = pygame.image.load("images/airship-balloon.png").convert()
        self.image_default.set_colorkey((1,0,0))
        self.image = self.image_default
        
        self.rect = self.image.get_rect()
        self.rect.center = (x, y)
        
        offset = (0,0) # center of gravity
        points = [(-210, -7), (-196, -24), (-82, -56), (-26, -60), (27, -60), (83, -56), (197, -24), (212, -7), (212, 6), (197, 25), (83, 57), (27, 61), (-26, 61), (-82, 57), (-196, 25), (-210, 8)]
        mass = 10
        moment = pymunk.moment_for_poly(mass,points)
        self.body = pymunk.Body(mass,moment)
        self.body.position = x,y
        self.body.angular_velocity = angular_velocity
        self.body.velocity_limit = 300
        

        self.shape = pymunk.Poly(self.body, points)
        self.shapes = [self.shape]
        
        self.shape.elasticity = 1
        self.shape.friction = .5
        self.shape.collision_type = 1    # 0 - can't jump off of it; 1 - can jump when standing on it

        self.buoyancy = buoyancy
        self.body.apply_force(buoyancy)
Example #19
0
    def __init__(self,
                 name,
                 space,
                 vertices,
                 density=DEFAULT_DENSITY,
                 elasticity=DEFAULT_ELASTICITY,
                 friction=DEFAULT_FRICTION,
                 color=DEFAULT_COLOR):
        PGObject.__init__(self, name, "Poly", space, color, density, friction,
                          elasticity)

        #vertices = map(lambda v: map(float, v), vertices)
        vertices = [[float(vp) for vp in v] for v in vertices]
        loc = centroidForPoly(vertices)
        area = areaForPoly(vertices)
        mass = density * area

        if mass == 0:
            self._cpShape = pm.Poly(space.static_body, vertices)
            self._cpShape.elasticity = elasticity
            self._cpShape.friction = friction
            self._cpShape.collision_type = COLTYPE_SOLID
            self._cpShape.name = name
            space.add(self._cpShape)
        else:
            recenterPoly(vertices)
            imom = pm.moment_for_poly(mass, vertices)
            self._cpBody = pm.Body(mass, imom)
            self._cpShape = pm.Poly(self._cpBody, vertices)
            self._cpShape.elasticity = elasticity
            self._cpShape.friction = friction
            self._cpShape.collision_type = COLTYPE_SOLID
            self._cpShape.name = name
            self._cpBody.position = loc
            space.add(self._cpBody, self._cpShape)
Example #20
0
def spawn_ball(dt, position, direction):
    x, y = position
    angle = random.random() * math.pi
    vs = [(-23, 26), (23, 26), (0, -26)]
    mass = 10
    moment = pymunk.moment_for_poly(mass, vs)
    body = pymunk.Body(mass, moment)
    body.apply_impulse(Vec2d(direction))
    # Keep ball velocity at a static value
    def constant_velocity(body, gravity, damping, dt):
        body.velocity = body.velocity.normalized() * 400
    body.velocity_func = constant_velocity

    shape = pymunk.Circle(body, ball_img.width / 2)
    # shape.friction = 0.5
    shape.elasticity = 1.0
    body.position = x, y
    body.angle = angle

    space.add(body, shape)

    sprite = pyglet.sprite.Sprite(ball_img, batch=batch)
    sprite.shape = shape
    sprite.body = body
    logos.append(sprite)
Example #21
0
    def __init__(self, world, model, *, position=(0, 0), angle=0, scale=1):
        self.__world = weakref.ref(world)
        self.__model = model

        self.__scale = math.Matrix.scale(scale)

        shape = model.shape
        if pymunk.util.is_clockwise(shape):
            shape = reversed(shape)
        shape = list(map(lambda p: p * self.__scale, shape))

        mass = model.density * pymunk.util.calc_area(shape)
        self._body = pymunk.Body(mass, pymunk.moment_for_poly(mass, shape))
        self._body.__object = weakref.ref(self)
        self._body.position = tuple(position)
        self._body.angle = angle
        self._shapes = []
        for convex_polygon in pymunk.util.convexise(
                pymunk.util.triangulate(shape)):
            convex_polygon = pymunk.Poly(self._body, convex_polygon)
            convex_polygon.elasticity = model.elasticity
            convex_polygon.friction = model.friction
            self._shapes.append(convex_polygon)

        world._objects.add(self)
        world._space.add(self._body, *self._shapes)

        self.active = False
Example #22
0
    def _create_pm_object(self, shape):
        mass = shape.body.mass
        inertia = shape.body.inertia
        pm_body = pm.Body(mass, inertia)
        pm_body.position = shape.position

        if isinstance(shape, Circle):
            radius = shape.radius
            # WARNING: for now, circle shapes are completely aligned to their
            # body's center of gravity
            offset = (0, 0)
            pm_obj = pm.Circle(pm_body, radius,  offset)
        elif isinstance(shape, Segment):
            # WARNING: the segment is assumed to be centered around its position
            # points a and b are equally distant from the segments center
            #print 'creating segment: pos:',  pm_body.position, 'from: ', shape.a,  'to: ', shape.b, 'radius: ', shape.radius

            pm_obj = pm.Segment(pm_body, shape.a, shape.b, shape.radius)
        elif isinstance(shape, Polygon):
            vertices = shape.vertices
            # WARNING: for now, polygon shapes are completely aligned to their
            # body's center of gravity
            offset = (0, 0)
            moment = pm.moment_for_poly(mass, vertices, offset)
            pm_body = pm.Body(mass, moment)
            pm_obj = pm.Poly(pm_body, vertices, offset)
        return pm_obj
Example #23
0
 def __init__(self, name, context, initPos, mass, width, length, radius = 0): # if num provided for radius, circle assumed
     self.name = name
     self.context = context
     self.mass = mass
     self.width = width * SCALE
     self.length = length * SCALE
     self.pos = initPos * SCALE
     self.radius = radius * SCALE
     self.scale = SCALE
     vertices = [(-self.width/2, -self.length/2),(-self.width/2,self.length/2),(self.width/2,self.length/2),(self.width/2,-self.length/2)]
     if self.radius > 0:
         self.inertia = pymunk.moment_for_circle(self.mass,self.radius,self.radius)
         self.body = pymunk.Body(self.mass,self.inertia)
         self.shape = pymunk.Circle(self.body,self.radius)
     else:
         self.inertia = pymunk.moment_for_poly(self.mass,vertices)
         self.body = pymunk.Body(self.mass, self.inertia)
         self.shape = pymunk.Poly(self.body, vertices)
     self.body.position = self.pos
     self.shape.elasticity = 0.95
     self.shape.friction = 0.9
     self.shape.color = pygame.color.THECOLORS["yellow"]
     self.shape.collision_type = collision_types[self.name]
     self.context.objects[self.shape._get_shapeid()] = self
     self.pickedUp = False
     self.context.numRets+=1
Example #24
0
 def _create_body(self) -> pymunk.Body:
     vertices = self._shape.get_vertices()
     moment = pymunk.moment_for_poly(self._mass, vertices, offset=(10, 10))
     body = pymunk.Body(self._mass, moment)
     self._shape.body = body
     body.friction = 1.0
     return body
Example #25
0
    def __init__(self, x, y, width, height, color, mass=5, lidar=None):
        points = [(x[0] * width, x[1] * height) for x in SHIP_TEMPLATE]
        moment = pm.moment_for_poly(mass, points)

        # Body creation
        body = pm.Body(mass, moment)
        body.position = Vec2d(x, y)

        # Shape creation
        shape = pm.Poly(body, points)

        shape.friction = 0.7
        shape.color = color
        shape.collision_type = 1

        self.filter = pm.ShapeFilter(
            categories=0b1)  # This is used for better segment querying
        self.width = width
        self.height = height
        self.shape = shape
        self.body = body
        self.force_vector = Vec2d(0, 100)
        self.rudder_angle = 0
        self.point_of_thrust = self.shape.bb.center()
        self.max_angle = 10
        self.lidar = lidar
Example #26
0
def load_poly_concave(tmxobject, map_height, static_body, defaults):
    """
    Creates several pymunk.Poly objects parsed from a TiledObject instance.
    They share a common pymunk.Body object.

    :param TiledObject tmxobject: A TiledObject instance that represents a \
    concave polygon with multiple vertices.
    :param int map_height: The height of the TiledMap that the TiledObject \
    was loaded from in pixels.

    """

    poly_defaults = defaults["pymunktmx_poly"]
    shape_attrs = get_shape_attrs(tmxobject, poly_defaults)
    body_attrs = get_body_attrs(tmxobject, poly_defaults)
    offset = body_attrs[u"offset"]
    radius = shape_attrs[u"radius"]

    # break concave shape into triangles
    points = list(tmxobject.points)

    # pymunk.util.triangulate expects the list to be in anti-clockwise order
    if pymunk.util.is_clockwise(points):
        points.reverse()

    # the pymunk.util.convexise doesn't create shapes that match originals
    # so we will just use the triangles
    triangles = pymunk.util.triangulate(points)

    shapes = []
    if body_attrs[u"static"]:
        for vertices in triangles:
            vertices = [(p[0], map_height - p[1]) for p in vertices]
            shape = pymunk.Poly(static_body, vertices, offset, radius)
            shapes.append(shape)

    else:
        x = float(tmxobject.x)
        y = float(float(map_height) - tmxobject.y)
        mass = body_attrs[u"mass"]
        verts = [(p[0] - x, -(p[1] - y)) for p in tmxobject.points]
        moment = pymunk.moment_for_poly(mass, verts, offset)
        body = pymunk.Body(mass, moment)
        body.position = (x, y)

        set_attrs(body_attrs,
                  body,
                  skip_keys=[u"position", u"mass", u"static"])

        for vertices in triangles:
            vertices = [(p[0] - x, -(p[1] - y)) for p in vertices]
            shape = pymunk.Poly(body, vertices, offset, radius)
            shapes.append(shape)

        shapes.append(body)

    for shape in shapes:
        set_attrs(shape_attrs, shape, skip_keys=[u"radius"])

    return shapes
Example #27
0
    def __init__(self,
                 space,
                 init_pos=(0, 0),
                 image_shape=None,
                 is_player=True,
                 is_geosynch=False,
                 moon_center=(0, 0),
                 boost_sound=None):
        super().__init__()
        self.game_over = False
        self.rocket_boost_sound = boost_sound
        self.is_geosynch = is_geosynch
        self.is_player = is_player
        self.image = pygame.image.load(resource_path("images/catstronaut.png"))
        self.moon_center = moon_center
        if image_shape:
            self.image = pygame.transform.scale(self.image, image_shape)
            self.image = pygame.transform.flip(self.image, True, True)
        self.rect = self.image.get_bounding_rect()
        width = self.rect.width
        height = self.rect.height
        self.space = space
        self.pos = pygame.Vector2(init_pos)

        vs = [(-width / 2, -height / 2), (width / 2, -height / 2),
              (width / 2, height / 2), (-width / 2, height / 2)]
        mass = 5
        moment = pymunk.moment_for_poly(mass, vs)
        self.body = pymunk.Body(mass, moment)
        self.body.force = (0, -250)
        self.body.position = self.pos.x, -self.pos.y + 500
        self.shape = pymunk.Poly(self.body, vs)
        self.shape.friction = 0.5
        self.space.add(self.body, self.shape)
        self.can_jump = True
Example #28
0
 def _make_star(
     self,
     star_npoints: int,
     star_out_rad: float,
     star_in_rad: float,
 ) -> Tuple[List[pm.shapes.Poly], List[List[pm.Vec2d]]]:
     # Body.
     star_verts = gtools.compute_star_verts(star_npoints, star_out_rad,
                                            star_in_rad)
     # Create an exact convex decomposition.
     convex_parts = autogeom.convex_decomposition(
         star_verts + star_verts[:1], 0)
     star_hull = autogeom.to_convex_hull(star_verts, 1e-5)
     star_inertia = pm.moment_for_poly(self.mass, star_hull, (0, 0), 0)
     self.shape_body = body = pm.Body(self.mass, star_inertia)
     body.position = self.init_pos
     body.angle = self.init_angle
     self.add_to_space(body)
     # Shape.
     shapes = []
     star_group = self.generate_group_id()
     for convex_part in convex_parts:
         shape = pm.Poly(body, convex_part)
         # Avoid self-intersection with a shape filter.
         shape.filter = pm.ShapeFilter(group=star_group)
         shapes.append(shape)
         del shape
     return shapes, convex_parts
Example #29
0
def create_robot(position):
    global space
    x, y = position
    robot_upscale = 21  # robot diameter = 210 mm (21 cm)
    with open("robot.json", "r") as f:
        robot_data = json.load(f)

    verts = robot_data["rigidBodies"][0]["shapes"][0]["vertices"]
    vertices = []
    for vert in verts:
        vertices.append((vert["x"] * robot_upscale, vert["y"] * robot_upscale))

    mass = 700  # robot weights around 1kg
    inertia = pymunk.moment_for_poly(mass, vertices)
    body = pymunk.Body(mass, inertia)
    body.position = x, y

    shapes = robot_data["rigidBodies"][0]["polygons"]
    for shape in shapes:
        verties = []
        for vert in shape:
            vert_x = vert["x"] * robot_upscale
            vert_y = vert["y"] * robot_upscale
            verties.append((vert_x, vert_y))
        poly_shape = pymunk.Poly(body, verties)
        poly_shape.color = pygame.color.THECOLORS["red"]
        poly_shape.elasticity = 0
        poly_shape.friction = 10
        poly_shape.collision_type = COLLISION_TYPES["robot"]
        space.add(poly_shape)
    space.add(body)

    return body
Example #30
0
    def __init__(self, position, collision_type, *, size):

        if collision_type != 5:
            # Column
            vertices = [pm.Vec2d(size[SPRITE_WIDTH]/2, -size[SPRITE_HEIGHT]/4),
                        pm.Vec2d(size[SPRITE_WIDTH]/2, size[SPRITE_HEIGHT]),
                        pm.Vec2d(-size[SPRITE_WIDTH]/2, size[SPRITE_HEIGHT]),
                        pm.Vec2d(-size[SPRITE_WIDTH]/2, -size[SPRITE_HEIGHT]/4)]

        else:
            # Beam
            vertices = [pm.Vec2d(size[SPRITE_WIDTH]/8, -size[SPRITE_HEIGHT]/4),
                        pm.Vec2d(size[SPRITE_WIDTH]/8, size[SPRITE_HEIGHT]/8),
                        pm.Vec2d(-size[SPRITE_WIDTH]/4, size[SPRITE_HEIGHT]/8),
                        pm.Vec2d(-size[SPRITE_WIDTH]/4, -size[SPRITE_HEIGHT]/4)]

        mass = 1
        moment = pm.moment_for_poly(mass=mass, vertices=vertices)
        Body.__init__(self, position, mass, moment)
        self.shape = pm.Poly(self.body, vertices=vertices, radius=0.5)

        self.shape.density = .0001
        self.shape.elasticity = 0.4

        self.shape.friction = 0.1
        self.shape.trigger_rotation = False

        self.shape.collision_type = collision_type
        self.angle = 0
Example #31
0
    def __init__(self, space, x, y, mass, sprite, sprite_size=1):
        pygame.sprite.Sprite.__init__(self)
    
        self.image, self.rect = load_image(sprite)
        
        # This is not exactly an ideal way to figure this out
        self.width = self.rect[2]
        self.height = self.rect[3]
        
        # This will resize the sprite if we've resized it
        self.image = pygame.transform.scale(self.image, (int(self.width * sprite_size), int(self.height * sprite_size) ))
    
        self.space = space
        self.mass = mass
        
        ## Need to offset the points of the shape so that the center of the image is at (0, 0)		
        offset = Vec2d(self.width/2, self.height/2)
        
        bounds = self.rect
        points = [Vec2d(bounds.topleft) - offset, Vec2d(bounds.topright) - offset, Vec2d(bounds.bottomright) - offset, Vec2d(bounds.bottomleft) - offset] 
        #### End of shape offset code - we can now pass the points to the body/shape creation ####

        inertia = pymunk.moment_for_poly(mass, points, (0,0))
        self.body = pymunk.Body(mass, inertia)
        self.body.position = x, y
    
        self.shape = pymunk.Poly(self.body, points, (0, 0) )
        self.shape.friction = DEFAULT_FRICTION_AMT
        
        game.space.add(self.body, self.shape)
Example #32
0
 def create_body_poly(self, mass, posinit, points):
     center = pm.util.calc_center(points)
     points = pm.util.poly_vectors_around_center(points)
     moment = pm.moment_for_poly(mass, points, Vec2d(0, 0))
     body = pm.Body(mass, moment)
     body.position = Vec2d(posinit)
     return body, points
Example #33
0
    def get_body_and_shape(self):
        # compile part data
        vertices = []
        mass = 0
        centroids_map = {}
        for p in self.parts:
            vertices += p.vertices
            mass += p.mass
            centroids_map[centroid(p.vertices)] = p.mass

        # calculate center of mass
        weighted_centroids_map = {
            c: m / mass
            for c, m in centroids_map.items()
        }
        centroids = list(weighted_centroids_map.keys())
        weights = [weighted_centroids_map[c] for c in centroids]
        com = centroid(centroids, weights)

        # calculate offset
        vertices = list(set(vertices))
        center = centroid(vertices)
        offset = Vec2d(center) - Vec2d(com)

        # create body
        body = pymunk.Body(mass)
        shape = pymunk.Poly(body, vertices)
        body.moment = pymunk.moment_for_poly(mass, vertices)
        body.center_of_gravity = com
        body.position = 450, 300

        return body, shape, body.local_to_world(com)
Example #34
0
    def __init__(self, position):
        WrapSprite.__init__(self, position, (0, 0))
        """
		Physical properties of ship.
		"""
        triangle_vertices = [(-5, 5), (-5, -5),
                             (5, 0)]  # vertices of triangular shape of ship
        mass = 1.0  # arbitrary
        self.gravity = Vec2d(0, 0)  # no gravity
        self.body = pymunk.Body(mass=mass,
                                moment=pymunk.moment_for_poly(
                                    mass, triangle_vertices),
                                body_type=pymunk.Body.DYNAMIC)
        self.body.angle = math.pi / 2.  # initialize facing up
        self.shape = pymunk.Poly(self.body,
                                 [(-5, 5), (-5, -5),
                                  (5, 0)])  # initialize trianglur shape
        self.body.position = position
        self.shape.friction = 0.0  # arbitrary
        self.shape.collision_type = collision_types["Player"]
        self.shape.game_over = False  # flag triggered by collision handler detecting ship was killed by asteroid

        # legal buttons for player actions
        self.legal_actions = [K_UP, K_DOWN, K_LEFT, K_RIGHT, K_SPACE]

        # tune rocket's forward  and turning speed
        self.forward_thrust = 20  # as an impulse
        self.turning_speed = 0.1  # as radians per step
    def create_world(self):
        self.space = pymunk.Space()
        self.space.gravity = Vec2d(0., -900.)

        static_body = pymunk.Body()
        static_lines = [  #pymunk.Segment(static_body, Vec2d(50,100), Vec2d(550,100), 1),
            #pymunk.Segment(static_body, Vec2d(450,100), Vec2d(450,300), 1)
        ]

        static_blocks = [
            pymunk.Poly(static_body, [(50, 100), (550, 100), (550, 99),
                                      (50, 99)])
        ]
        for l in static_blocks:
            l.friction = 0.3
        self.space.add(static_blocks)

        for x in range(5):
            for y in range(12):
                size = 5
                points = [(-size, -size), (-size, size), (size, size),
                          (size, -size)]
                mass = 10.0
                moment = pymunk.moment_for_poly(mass, points, (0, 0))
                body = pymunk.Body(mass, moment)
                body.position = Vec2d(200 + x * 50, 105 + y * 11)
                shape = pymunk.Poly(body, points, (0, 0))
                shape.friction = 0.3
                self.space.add(body, shape)
Example #36
0
    def __init__(self, world_pos, vertices, mass, friction=0.8, moment = None, taggable=True, grabable=False, texture_name=None, dynamic=True, collision_group=0, layers=2**32-1):
        self._world_entity_manager = None

        self._is_dynamic = True

        self._verts = vertices
        pymunk_verts = map(Vec2d, vertices)
        
        if not moment:
            moment = pymunk.moment_for_poly(mass, pymunk_verts, (0,0))

        self._body = pymunk.Body(mass, moment)
        self._body.position = world_pos
  
        self._shape = pymunk.Poly(self._body, pymunk_verts, (0,0) )
        self._shape.friction = friction

        self._is_taggable = taggable
        self._is_grabable = grabable
        self._texture_name = texture_name
        self._is_dynamic = dynamic
        self._time_passed = 0.0
        self._shape.layers = layers
        self._taggable_attached = None

        self._shape.group = collision_group

        if not self._is_dynamic:
            self._bounding_rect_cache = self.get_bounding_rect(force=True)

        self._tags = {}
        self._attached = False
Example #37
0
	def __init__(self, pos):
		Collidable.__init__(self, self.groups)
		self.left_images = []
		for i in self.right_images:
			self.left_images.append(pygame.transform.flip(i, 1, 0))
		self.image = self.right_images[0]
		self.rect = self.image.get_rect()
		self.jump_speed = 0
		self.jump_accel = 0.3
		self.jumping = False
		self.frame = 0
		self.facing = 1
		self.still_timer = 0
		self.hit_timer = 0
		self.health = 5
		self.heat = 100
		
		w = self.rect.width/2 - 20
		h = self.rect.height/2 - 10
		
		poly = [(-w,-h),(w,-h),(w,h),(-w,h)]
		mass = 1000
		moment = pymunk.moment_for_poly(mass, poly)
		self.body = pymunk.Body(mass, pymunk.inf)
		
		self.shape = pymunk.Poly(self.body, poly)
		self.shape.color = THECOLORS["blue"]
		self.shape.friction = 3
		
		self.rect.topleft = pos
		self.body.position = (self.rect.center[0],480-self.rect.center[1])
		self.jumping = False
Example #38
0
    def add_triangle(self, vertices, random_color):
        vbackup = vertices
        vertices = [int(v) for v in vertices]
        vertices  = zip(vertices[::2], vertices[1::2])
        center = cymunk.util.calc_center(vertices)
        body = cymunk.Body(100,
            cymunk.moment_for_poly(100, vertices))
        body.position.x = center[0]
        body.position.y = center[1]
        triangle = cymunk.Poly(body, vertices)
        triangle.elasticity = 0.6
        triangle.friction = FRICTION
        self.space.add(body, triangle)

        with self.parent.canvas.before:
            color = Color(*random_color, mode="rgba")
            rot = Rotate(angle=0, axis=(0, 0, 1), origin=center)
            triangle_shape = Triangle(points=vbackup)
            unrot = Rotate(0, (0, 0, 1), origin=center)
        body.data = {
            "color": color,
            "instruction": [triangle_shape, rot, unrot],
            "type": TRIANGLE_TYPE,
            "shapes": [triangle],
        }    
Example #39
0
def load_poly_concave(tmxobject, map_height, static_body, defaults):
    """
    Creates several pymunk.Poly objects parsed from a TiledObject instance.
    They share a common pymunk.Body object.

    :param TiledObject tmxobject: A TiledObject instance that represents a \
    concave polygon with multiple vertices.
    :param int map_height: The height of the TiledMap that the TiledObject \
    was loaded from in pixels.

    """

    poly_defaults = defaults["pymunktmx_poly"]
    shape_attrs = get_shape_attrs(tmxobject, poly_defaults)
    body_attrs = get_body_attrs(tmxobject, poly_defaults)
    offset = body_attrs[u"offset"]
    radius = shape_attrs[u"radius"]

    # break concave shape into triangles
    points = list(tmxobject.points)

    # pymunk.util.triangulate expects the list to be in anti-clockwise order
    if pymunk.util.is_clockwise(points):
        points.reverse()

    # the pymunk.util.convexise doesn't create shapes that match originals
    # so we will just use the triangles
    triangles = pymunk.util.triangulate(points)

    shapes = []
    if body_attrs[u"static"]:
        for vertices in triangles:
            vertices = [(p[0], map_height - p[1]) for p in vertices]
            shape = pymunk.Poly(static_body, vertices, offset, radius)
            shapes.append(shape)

    else:
        x = float(tmxobject.x)
        y = float(float(map_height) - tmxobject.y)
        mass = body_attrs[u"mass"]
        verts = [(p[0] - x, -(p[1] - y)) for p in tmxobject.points]
        moment = pymunk.moment_for_poly(mass, verts, offset)
        body = pymunk.Body(mass, moment)
        body.position = (x, y)

        set_attrs(body_attrs, body,
                  skip_keys=[u"position", u"mass", u"static"])

        for vertices in triangles:
            vertices = [(p[0] - x, -(p[1] - y)) for p in vertices]
            shape = pymunk.Poly(body, vertices, offset, radius)
            shapes.append(shape)

        shapes.append(body)

    for shape in shapes:
        set_attrs(shape_attrs, shape, skip_keys=[u"radius"])

    return shapes
Example #40
0
 def __init__(self, space, vertices, mass=None, position=None, velocity=None):
     super(PolyBody, self).__init__(space, mass, position, velocity)
     self.vertices = vertices
     inertia = pymunk.moment_for_poly(self.mass, self.vertices)
     self.game_body = pymunk.Body(self.mass, inertia)
     self.game_body.position = self.position
     self.game_shape = pymunk.Poly(self.game_body, self.vertices)
     self.space.game_space.add(self.game_body, self.game_shape)
Example #41
0
 def create_body(self):
     if self.item.static:
         mass = moment = inf
     else:
         mass = self.item.geometry.area
         moment = moment_for_poly(mass, self.item.geometry.verts)
     body = Body(mass, moment)
     return body
Example #42
0
 def __init__(self, space, screen):
     vs = [(-20, 20), (20, 20), (20, -20), (-20, -20)]
     mass = 10
     moment = pm.moment_for_poly(mass, vs)
     body = pm.Body(mass, moment)
     shape = DefenseShape(space, body, vs)
     PymunkSprite.__init__(self, space, screen, "../assets/img/joint.png",
                           shape)
Example #43
0
def makeBox(mass, space, textures, hit_box, scale, x, y):
    body = pymunk.Body(mass, pymunk.moment_for_poly(mass, vertices=hit_box) * 10)
    body.position = pymunk.Vec2d((x, y))
    shape = pymunk.Poly.create_box(body, (textures[0].width, textures[0].height))
    shape.friction = 0.5
    space.add(body, shape)
    sprite = Ground(shape, textures, scale, x, y)
    return sprite
Example #44
0
def create_poly(collision_type=None, elasticity=None, friction=None, mass=None,
                moment=None, offset=None, position=None, radius=None, 
                vertices=None, **extras):
  if _lacks_moment(mass, moment):
    moment = pymunk.moment_for_poly(mass, vertices, offset)
  body = _create_body(mass, moment, position)
  shape = pymunk.Poly(body, vertices, offset, radius)
  return _configure_shape(shape, elasticity, friction, collision_type)
Example #45
0
 def addPoly(self, actorID, **kwargs):
     '''Create a polygon shape and body'''
     if kwargs['moment'] == -1:
         kwargs['moment'] = pymunk.moment_for_poly(kwargs['mass'], kwargs['vertices'])
         
     body = self.createBody(kwargs['isStatic'], kwargs['mass'], kwargs['moment'], kwargs['pos'])
     shape = pymunk.Poly(body, kwargs['vertices'])
     self.addShape(actorID, body, shape, kwargs['elasticity'], kwargs['collisionType'])
Example #46
0
 def create_body(self):
     verts = map(Vec2d, self.get_verts())
     self.body = Body(self.mass, moment_for_poly(self.mass, verts))
     self.body.position = (self.x, self.y)
     self.shape = Poly(self.body, verts, (0, 0))
     self.shape.layers = self.layers
     # this is so you can get to it from collision handlers.
     #     eg. arbiter.shapes[0].parent 
     self.shape.parent = self
Example #47
0
 def create_body(self):
     verts = map(Vec2d, self.get_verts())
     self.body = Body(self.mass, moment_for_poly(self.mass, verts))
     self.body.position = (self.x, self.y)
     self.shape = Poly(self.body, verts, (0, 0))
     self.shape.layers = self.layers
     # this is so you can get to it from collision handlers.
     #     eg. arbiter.shapes[0].parent
     self.shape.parent = self
Example #48
0
 def create_poly(self, points, mass=5.0, pos=(0, 0)):
     moment = pymunk.moment_for_poly(mass, points, Vec2d(0, 0))
     body = pymunk.Body(mass, moment)
     body.position = Vec2d(pos)
     shape = pymunk.Poly(body, points, Vec2d(0, 0))
     shape.friction = 1
     # shape.collision_type = COLLTYPE_DEFAULT
     self.space.add(body, shape)
     return shape
Example #49
0
 def __init__(self, space, screen):
     vs = [(-25, 25), (25, 25), (25, -25), (-25, -25)]
     mass = 10
     moment = pm.moment_for_poly(mass, vs)
     body = pm.Body(mass, moment)
     shape = pm.Poly(body, vs)
     PymunkSprite.__init__(self, space, screen,
                           "../assets/img/MaceBall.png", shape)
     self.shape.collision_type = COLLISION_OFFENSE
Example #50
0
 def __init__(self, position, space):
     self.mass = 1
     self.shape = pymunk.Poly.create_box(None, size=(10, 50))
     self.moment = pymunk.moment_for_poly(self.mass,
                                          self.shape.get_vertices())
     self.body = pymunk.Body(self.mass, self.moment)
     self.shape.body = self.body
     self.shape.body.position = position
     space.add(self.shape, self.body)
Example #51
0
	def	_update_cell(self):
		##{{{
		"""
		Updates Inertia, Updates length, height etc for pygame
		Does not update position.
		"""
		self._genpoly()
		self.body.moment=pm.moment_for_poly(self.mass,self.ver, (0,0)) #Sets new inertia
		self.box.unsafe_set_vertices(self.ver,(-self.length/2.,-self.height/2.))
Example #52
0
def create_poly(points, space, mass = 5.0, pos = (0,0)):
    moment = pymunk.moment_for_poly(mass,points, Vec2d(0,0))    
    body = pymunk.Body(mass, moment)
    body.position = Vec2d(pos)
    shape = pymunk.Poly(body, points, Vec2d(0,0))
    shape.collision_type = collisiontype_default
    shape.friction = 1.0
    shape.elasticity = 0.5
    space.add(body, shape)
    return shape
Example #53
0
    def add_poly(self, points, position=(100,100), mass=1.0):
        """ Add a closed polygon collision shape. """

        moment = pymunk.moment_for_poly(mass, points, (0,0))
        self._body = pymunk.Body(mass, moment)
        self._body.position = position
        self._body.angle = 47.0

        self._shape = pymunk.Poly(self._body, points, (0,0))
        return self
Example #54
0
def create_arrow():
    vs = [(-30,0), (0,3), (10,0), (0,-3)]
    mass = 1
    moment = pymunk.moment_for_poly(mass, vs)
    arrow_body = pymunk.Body(mass, moment)

    arrow_shape = pymunk.Poly(arrow_body, vs)
    arrow_shape.friction = .5
    arrow_shape.collision_type = 1
    return arrow_body, arrow_shape
Example #55
0
    def add_wheel(self, space, pos):
        fp = [(-5, -3), (5, -3), (5, 3), (-5, 3)]
        mass = 1000
        moment = pymunk.moment_for_poly(mass, fp)
        wheel_body = pymunk.Body(mass, moment)
        wheel_shape = pymunk.Poly(wheel_body, fp)
        wheel_shape.group = self.group
	wheel_body.position = pos
    	joint = pymunk.PivotJoint(self.robot.body, wheel_body, wheel_body.position)
        space.add(wheel_body, wheel_shape, joint)
        return wheel_shape
Example #56
0
 def _body(self):
     if self.static == False:
         mass = 20
         # saint random!
         radius = 20
         #inertia = pymunk.moment_for_box(mass, 0, radius)
         inertia = pymunk.moment_for_poly(mass, self.points)
         body = pymunk.Body(mass, inertia)
     else:
         body = pymunk.Body(pymunk.inf, pymunk.inf)
     return body
Example #57
0
 def __init__(self, level, pos, player):
   self.level = level
   self.level = level
   self.player = player
   self.body = Body(self.mass, moment_for_poly(self.mass, self.verticies))
   self.body.position = Vec2d(pos)
   self.body.velocity = Vec2d(self.initialSpeed, 0).rotated(pi*random())
   self.createShape(self.verticies)
   self.shape.friction = 1
   self.startTime = game.engine.levelTime
   self.opacity = 1.
Example #58
0
 def create_poly(self, points, mass = 5.0, pos = (0,0)):
     moment = pymunk.moment_for_poly(mass,points, Vec2d(0,0))    
     #moment = 1000
     body = pymunk.Body(mass, moment)
     body.position = Vec2d(pos)       
     print body.position
     shape = pymunk.Poly(body, points, Vec2d(0,0))
     shape.friction = 0.5
     shape.collision_type = 1
     self.space.add(body, shape)
     return shape