예제 #1
0
    def create_body(self, pos):
        x, y = pos
        self.lend = self.create_left_end(pos)
        self.segments = []
        self.ends = []

        if self.lend:
            prevBody = self.lend.body
            self.ends.append(self.lend)
        else:
            prevBody = None

        for i in range(self.length):
            sd = b2PolygonDef()
            sd.SetAsBox(self.PIECE_LENGTH, self.radius)
            sd.density = self.density
            sd.friction = 1
            sd.restitution = 0
            sd.filter.groupIndex = -1

            bd = b2BodyDef()
            bd.linearDamping = 0
            bd.angularDamping = 0.2
            bd.position = (x + self.PIECE_LENGTH * 2 * i - self.PIECE_LENGTH, y)
            body = world.CreateBody(bd)
            body.CreateShape(sd)
            body.SetMassFromShapes()
            self.segments.append(body)

            if prevBody:
                jd = b2RevoluteJointDef()
                anchor = (x + self.PIECE_LENGTH * (2 * i - 1), y)
                jd.Initialize(prevBody, body, anchor)
                world.CreateJoint(jd).getAsType()

            prevBody = body

        self.rend = self.create_right_end((x + self.PIECE_LENGTH * (self.length - 1) * 2, y))
        if self.rend:
            jd = b2RevoluteJointDef()
            anchor = (x + self.PIECE_LENGTH * (self.length - 1) * 2, y)
            jd.Initialize(prevBody, self.rend.body, anchor)
            world.CreateJoint(jd).getAsType()
            self.ends.append(self.rend)
예제 #2
0
    def __init__(self):
        super(Pinball, self).__init__()

        # The ground
        ground = self.world.CreateBody(
            shapes=b2LoopShape(vertices=[(0, -2), (8, 6),
                                         (8, 20), (-8, 20),
                                         (-8, 6)]),
        )

        # Flippers
        p1, p2 = (-2, 0), (2, 0)

        fixture = b2FixtureDef(shape=b2PolygonShape(box=(1.75, 0.1)), density=1)
        flipper = {'fixtures': fixture}

        self.leftFlipper = self.world.CreateDynamicBody(
            position=p1,
            **flipper
        )
        self.rightFlipper = self.world.CreateDynamicBody(
            position=p2,
            **flipper
        )

        rjd = b2RevoluteJointDef(
            bodyA=ground,
            bodyB=self.leftFlipper,
            localAnchorA=p1,
            localAnchorB=(0, 0),
            enableMotor=True,
            enableLimit=True,
            maxMotorTorque=1000,
            motorSpeed=0,
            lowerAngle=-30.0 * b2_pi / 180.0,
            upperAngle=5.0 * b2_pi / 180.0,
        )

        self.leftJoint = self.world.CreateJoint(rjd)

        rjd.motorSpeed = 0
        rjd.localAnchorA = p2
        rjd.bodyB = self.rightFlipper
        rjd.lowerAngle = -5.0 * b2_pi / 180.0
        rjd.upperAngle = 30.0 * b2_pi / 180.0
        self.rightJoint = self.world.CreateJoint(rjd)

        # Ball
        self.ball = self.world.CreateDynamicBody(
            fixtures=b2FixtureDef(
                shape=b2CircleShape(radius=0.2),
                density=1.0),
            bullet=True,
            position=(1, 15))

        self.pressed = False
예제 #3
0
    def pick_up(self, body, pos):
        if self.joint:
            return
#        jd = b2DistanceJointDef()
#        jd.Initialize(self.body, body, b2Vec2(0.65, 0), b2Vec2(0, 4))
#        jd.length = 0.5

        jd = b2RevoluteJointDef()
        jd.Initialize(self.body, body, self.body.position)
        self.joint = world.CreateJoint(jd).getAsType()
def spawn_heli(hx, hy):
    global heli, cable, hook
    heli = Heli((hx, hy + 3.5))

    cable = Cable((hx + 3, hy + 1.5))

    jd = b2RevoluteJointDef()
    jd.Initialize(heli.body, cable.segments[0], (hx + 1, hy + 1.5))
    heli.cable_joint = world.CreateJoint(jd).getAsType()

    objects.append(heli)
    objects.append(cable)

    hook = cable.rend
예제 #5
0
 def create_body(self, pos):
     pos = b2Vec2(*pos)
     super(Truck, self).create_body(pos)
     self.wheels = []
     self.joints = []
     for i, p in enumerate(self.WHEEL_POSITIONS):
         p = pos + p
         w = Wheel(p)
         jdef = b2RevoluteJointDef()
         jdef.enableMotor = i < 2
         jdef.motorSpeed = 0
         jdef.maxMotorTorque = 6000
         jdef.Initialize(self.body, w.body, p)
         j = world.CreateJoint(jdef).asRevoluteJoint()
         self.joints.append(j)
         self.wheels.append(w)
예제 #6
0
def setup_scene():
    global batch, heli, hook
    batch = pyglet.graphics.Batch()

    # Gradient sky
    l, b = world_to_screen((0, FLOOR))
    r, t = world_to_screen((W, H))
    horizon = 177 / 255.0, 202 / 255.0, 1.0
    zenith = 68 / 255.0, 0.5, 1.0
    batch.add(4, gl.GL_QUADS, None,
        ('v2f', [l, b, l, t, r, t, r, b]),
        ('c3f', sum([horizon, zenith, zenith, horizon], ())),
    )

    # Create the ground
    group = pyglet.sprite.SpriteGroup(
        earth_tex, gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA
    )
    l, b = world_to_screen((0, 0))
    r, t = world_to_screen((W, FLOOR))
    batch.add(4, gl.GL_QUADS, group,
        ('v2f', [l, b, l, t, r, t, r, b]),
        ('t2f', [0, 0.5, 0, 1, 10, 1, 10, 0.5]),
    )

    heli = Heli((20, FLOOR + 3.5))

    cable = Cable((23, FLOOR + 1.5))

    jd = b2RevoluteJointDef()
    jd.Initialize(heli.body, cable.segments[0], (21, FLOOR + 1.5))
    heli.cable_joint = world.CreateJoint(jd).getAsType()

    objects.append(Crate((60, FLOOR + 2)))
    objects.append(heli)
    objects.append(cable)

    hook = cable.rend
예제 #7
0
파일: car.py 프로젝트: FluxDenisty/CabLife
    def __init__(self, world, pos=None):
        if (pos is None):
            pos = b2Vec2(0, 0)
        self.m_tires = []

        # create car body
        bodyDef = b2BodyDef()
        bodyDef.type = b2_dynamicBody
        bodyDef.restitution = 0.1
        bodyDef.position = pos
        self.m_body = world.CreateBody(bodyDef)
        self.m_body.angularDamping = 5
        self.m_body.linearDamping = 1

        vertices = []
        for i in xrange(4):
            vertices.append(b2Vec2())
        vertices[0].Set(-5.6, 0)
        vertices[1].Set(-5.6, 20)
        vertices[2].Set(5.6, 20)
        vertices[3].Set(5.6, 0)
        '''
        vertices[0].Set(3, 0)
        vertices[1].Set(6, 5)
        vertices[2].Set(5.6, 11)
        vertices[3].Set(2, 20)
        vertices[4].Set(-2, 20)
        vertices[5].Set(-5.6, 11)
        vertices[6].Set(-6, 5)
        vertices[7].Set(-3, 0)
        '''
        polygonShape = b2PolygonShape(vertices=vertices)
        self.m_body.CreateFixture(
            shape=polygonShape,
            density=100.0,
        )

        # prepare common joint parameters
        jointDef = b2RevoluteJointDef()
        jointDef.bodyA = self.m_body
        jointDef.enableLimit = True
        jointDef.lowerAngle = 0
        jointDef.upperAngle = 0
        jointDef.localAnchorB.SetZero()  # center of tire

        maxForwardSpeed = 150
        maxBackwardSpeed = -40
        backTireMaxDriveForce = 50
        frontTireMaxDriveForce = 100
        backTireMaxLateralImpulse = 1.5
        frontTireMaxLateralImpulse = 0.5

        # back left tire
        tire = TDTire(world, self)
        tire.setCharacteristics(
            maxForwardSpeed,
            maxBackwardSpeed,
            backTireMaxDriveForce,
            backTireMaxLateralImpulse)
        jointDef.bodyB = tire.m_body
        jointDef.localAnchorA.Set(-6, 1.5)
        world.CreateJoint(jointDef)
        self.m_tires.append(tire)

        # back right tire
        tire = TDTire(world, self)
        tire.setCharacteristics(
            maxForwardSpeed,
            maxBackwardSpeed,
            backTireMaxDriveForce,
            backTireMaxLateralImpulse)
        jointDef.bodyB = tire.m_body
        jointDef.localAnchorA.Set(6, 1.5)
        world.CreateJoint(jointDef)
        self.m_tires.append(tire)

        # front left tire
        tire = TDTire(world, self)
        tire.setCharacteristics(
            maxForwardSpeed,
            maxBackwardSpeed,
            frontTireMaxDriveForce,
            frontTireMaxLateralImpulse)
        jointDef.bodyB = tire.m_body
        jointDef.localAnchorA.Set(-6, 17)
        self.flJoint = world.CreateJoint(jointDef)
        self.m_tires.append(tire)

        # front right tire
        tire = TDTire(world, self)
        tire.setCharacteristics(
            maxForwardSpeed,
            maxBackwardSpeed,
            frontTireMaxDriveForce,
            frontTireMaxLateralImpulse)
        jointDef.bodyB = tire.m_body
        jointDef.localAnchorA.Set(6, 17)
        self.frJoint = world.CreateJoint(jointDef)
        self.m_tires.append(tire)
예제 #8
0
파일: main.py 프로젝트: ddunwoody/cayley
          (-50,  10))

chass_b = Polygon(vertices=vert_b, colour=(1.00, 0.25, 0.25),
                 density=20, friction=0.6)
chass_t = Polygon(vertices=vert_t, colour=(0.25, 0.25, 1.00),
                 density=5, friction=0.6)

chassis = world.create_body((0, 15), chass_b, chass_t)

circ_r = Circle(5, colour=(0.50, 0.50, 0.75), density=40, friction=0.8)
circ_f = Circle(5, colour=(0.75, 0.50, 0.50), density=40, friction=0.8)

wheel_r = world.create_body((-55, 5), circ_r)
wheel_f = world.create_body((-15, 5), circ_f)

jd = b2RevoluteJointDef()
jd.Initialize(chassis, wheel_r, wheel_r.GetWorldCenter())
jd.enableMotor = True
jd.maxMotorTorque = 50000
drive = world.create_joint(jd)

jd.Initialize(chassis, wheel_f, wheel_f.GetWorldCenter())
world.create_joint(jd)

window = Window(world, caption='Cayley', resizable=True, visible=False)
window.set_screen_margin(0.1)
window.focus_camera(0, 200)
window.set_visible()
window.center_on_screen()

clock.schedule_interval(world.update, 1/60.)