Exemple #1
0
    def update(self, task=None):
        """
        Updates position of sounds in the 3D audio system. Will be called automatically
        in a task.
        """
        # Update the positions of all sounds based on the objects
        # to which they are attached

        # The audio manager is not active so do nothing
        if hasattr(self.audio_manager, "getActive"):
            if self.audio_manager.getActive()==0:
                return Task.cont

        for known_object in self.sound_dict.keys():
            tracked_sound = 0
            while tracked_sound < len(self.sound_dict[known_object]):
                sound = self.sound_dict[known_object][tracked_sound]
                pos = known_object.getPos(self.root)
                vel = self.getSoundVelocity(sound)
                sound.set3dAttributes(pos[0], pos[1], pos[2], vel[0], vel[1], vel[2])
                tracked_sound += 1

        # Update the position of the listener based on the object
        # to which it is attached
        if self.listener_target:
            pos = self.listener_target.getPos(self.root)
            forward = self.root.getRelativeVector(self.listener_target, Vec3.forward())
            up = self.root.getRelativeVector(self.listener_target, Vec3.up())
            vel = self.getListenerVelocity()
            self.audio_manager.audio3dSetListenerAttributes(pos[0], pos[1], pos[2], vel[0], vel[1], vel[2], forward[0], forward[1], forward[2], up[0], up[1], up[2])
        else:
            self.audio_manager.audio3dSetListenerAttributes(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1)
        return Task.cont
    def matchPose(self, pose_rig):
        for node, parent in pose_rig.exposed_joints:
            if node.getName() not in joints_config:
                continue

            joint_config = joints_config[node.getName()]
            if 'joints' not in joint_config:
                continue

            joints = joint_config['joints']
            if len(joints) == 0:
                continue

            box_np = self.root.find(node.getName())

            if len(joints) > 1:
                pos = node.getPos(pose_rig.actor)
                hpr = node.getHpr(pose_rig.actor)
                box_np.setPosHpr(self.root, pos, hpr)
            else:
                joint = joints.keys()[0]
                child_node, child_parent = next((child_node, child_parent) for child_node, child_parent in pose_rig.exposed_joints if child_node.getName() == joint)
                box_np.setPos(child_parent, child_node.getPos(child_parent) / 2.0)

                quat = Quat()
                lookAt(quat, child_node.getPos(child_parent), Vec3.up())
                box_np.setQuat(child_parent, quat)

            box_np.node().clearForces()
Exemple #3
0
 def __init__(self, cr):
     DistributedEntity.__init__(self, cr)
     self.height = 1.0
     self.raiseSpeed = 1
     self.stompSpeed = 1
     self.scale = Vec3(1)
     self.moveDir = Vec3.up()
    def step(self, task):
        distance = ClockObject.getGlobalClock().getDt() * self.speed

        rotMat = Mat3.rotateMatNormaxis(self.avatar.getH(), Vec3.up())
        step = Vec3(rotMat.xform(Vec3.forward() * distance))
        self.avatar.setFluidPos(Point3(self.avatar.getPos() + step))

        return Task.cont
 def __init__(self, cr):
     DistributedEntity.__init__(self, cr)
     FSM.__init__(self, 'func_rotating')
     self.state = 0
     self.axis = Vec3.up()
     self.timeToFull = 5.0
     self.speed = 50.0
     self.spinTrack = None
def create_colliders(root, pose_rig, joints_config):
    for node, parent in pose_rig.exposed_joints:
        if node.getName() not in joints_config:
            continue

        joint_config = joints_config[node.getName()]
        if "joints" not in joint_config:
            continue

        joints = joint_config["joints"]
        if len(joints) == 0:
            continue

        mass = joint_config["mass"] if "mass" in joint_config else 1

        box_rb = BulletRigidBodyNode(node.getName())
        box_rb.setMass(1.0)
        # box_rb.setLinearDamping(0.2)
        # box_rb.setAngularDamping(0.9)
        # box_rb.setFriction(1.0)
        # box_rb.setAnisotropicFriction(1.0)
        # box_rb.setRestitution(0.0)

        for joint in joints:
            child_node, child_parent = next(
                (child_node, child_parent)
                for child_node, child_parent in pose_rig.exposed_joints
                if child_node.getName() == joint
            )

            pos = child_node.getPos(child_parent)
            width = pos.length() / 2.0
            scale = Vec3(3, width, 3)

            shape = BulletBoxShape(scale)

            quat = Quat()
            lookAt(quat, child_node.getPos(child_parent), Vec3.up())
            if len(joints) > 1:
                transform = TransformState.makePosHpr(child_node.getPos(child_parent) / 2.0, quat.getHpr())
            else:
                transform = TransformState.makeHpr(quat.getHpr())

            box_rb.addShape(shape, transform)

        box_np = root.attachNewNode(box_rb)

        if len(joints) > 1:
            pos = node.getPos(pose_rig.actor)
            hpr = node.getHpr(pose_rig.actor)
            box_np.setPosHpr(root, pos, hpr)
        else:
            box_np.setPos(child_parent, child_node.getPos(child_parent) / 2.0)
            box_np.lookAt(child_parent, child_node.getPos(child_parent))

        yield box_np
Exemple #7
0
 def get_normal(self):
     seen = set()
     points = [p for p in self.points if p not in seen and not seen.add(p)]
     if len(points) >= 3:
         v1 = points[0] - points[1]
         v2 = points[1] - points[2]
         normal = v1.cross(v2)
         normal.normalize()
     else:
         normal = Vec3.up()
     return normal
Exemple #8
0
 def get_normal(self):
     seen = set()
     points = [p for p in self.points if p not in seen and not seen.add(p)]
     if len(points) >= 3:
         v1 = points[0] - points[1]
         v2 = points[1] - points[2]
         normal = v1.cross(v2)
         normal.normalize()
     else:
         normal = Vec3.up()
     return normal
Exemple #9
0
 def guide_missile(self, task):
     try:
         quat = Quat()
         lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up())
         self.missile.anp.setQuat(quat)
         fwd = quat.getForward()
         fwd.normalize()
         mvel = self.missile.anpo.getVelocity().length()
         self.missile.anpo.setVelocity(fwd*mvel)
     except:
         return task.done
     return task.cont
 def __processSwimming(self):
     procSwimCollector.start()
     
     if self.__footContact:
         absSlopeDot = round(self.__footContact[2].dot(Vec3.up()), 2)
         if self.__targetPos.z - 0.1 < self.__footContact[0].z and (self.__linearVelocity.z < 0.0 or absSlopeDot < 1):
             self.__targetPos.z = self.__footContact[0].z
             self.__linearVelocity.z = 0.0
     
     if self.__headContact and self.__capsuleTop >= self.__headContact[0].z and self.__linearVelocity.z > 0.0:
         self.__linearVelocity.z = 0.0
         
     procSwimCollector.stop()
    def __applyLinearVelocity(self):
        globalVel = self.__linearVelocity * self.__timeStep

        if self.predictFutureSpace and not self.__checkFutureSpace(globalVel):
            return

        if self.__footContact is not None and self.minSlopeDot and self.movementState != "swimming":
            normalVel = Vec3(globalVel)
            normalVel.normalize()

            floorNormal = self.__footContact[2]
            #worldToAvatar = self.movementParent.getTransform(render).getInverse().getMat()
            #contactNormalAv = worldToAvatar * floorNormal
            #velAv = worldToAvatar * globalVel
            #forward = contactNormalAv.cross(Vec3.right())
            #forward.normalize()
            #globalVel = forward * self.__linearVelocity.length() * self.__timeStep

            absSlopeDot = round(floorNormal.dot(Vec3.up()), 2)

            def applyGravity():
                self.__targetPos -= Vec3(
                    floorNormal.x, floorNormal.y,
                    0.0) * self.gravity * self.__timeStep * 0.1

            if absSlopeDot <= self.minSlopeDot:
                applyGravity()

                if globalVel != Vec3():
                    globalVelDir = Vec3(globalVel)
                    globalVelDir.normalize()

                    fn = Vec3(floorNormal.x, floorNormal.y, 0.0)
                    fn.normalize()

                    velDot = 1.0 - globalVelDir.angleDeg(fn) / 180.0
                    if velDot < 0.5:
                        self.__targetPos -= Vec3(fn.x * globalVel.x, fn.y *
                                                 globalVel.y, 0.0) * velDot

                    globalVel *= velDot

            elif self.__slopeAffectsSpeed and globalVel != Vec3():
                applyGravity()

        elif self.movementState == "swimming" and not self.isOnGround():
            self.__targetPos -= Vec3(0, 0,
                                     -self.gravity * self.__timeStep * 0.1)

        self.__targetPos += globalVel
Exemple #12
0
 def __init__(self, air, dispatch):
     DistributedEntityAI.__init__(self, air, dispatch)
     self.height = 1.0
     self.stompSpeed = 1
     self.raiseSpeed = 1
     self.timeOnGround = 0.0
     self.timeInAir = 0.0
     self.damage = 20
     self.scale = Vec3(1)
     self.floorColl = None
     self.damaged = []
     self.moveDir = Vec3.up()
     self.stomped = False
     self.startDelay = 0.0
    def update(self, task=None):
        """
        Updates position of sounds in the 3D audio system. Will be called automatically
        in a task.
        """
        # Update the positions of all sounds based on the objects
        # to which they are attached

        # The audio manager is not active so do nothing
        if hasattr(self.audio_manager, "getActive"):
            if self.audio_manager.getActive() == 0:
                return Task.cont

        for known_object, sounds in list(self.sound_dict.items()):
            node_path = known_object.getNodePath()
            if not node_path:
                # The node has been deleted.
                del self.sound_dict[known_object]
                continue

            pos = node_path.getPos(self.root)

            for sound in sounds:
                vel = self.getSoundVelocity(sound)
                sound.set3dAttributes(pos[0], pos[1], pos[2], vel[0], vel[1],
                                      vel[2])

        # Update the position of the listener based on the object
        # to which it is attached
        if self.listener_target:
            pos = self.listener_target.getPos(self.root)
            forward = self.root.getRelativeVector(self.listener_target,
                                                  Vec3.forward())
            up = self.root.getRelativeVector(self.listener_target, Vec3.up())
            vel = self.getListenerVelocity()
            self.audio_manager.audio3dSetListenerAttributes(
                pos[0], pos[1], pos[2], vel[0], vel[1], vel[2], forward[0],
                forward[1], forward[2], up[0], up[1], up[2])
        else:
            self.audio_manager.audio3dSetListenerAttributes(
                0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1)
        return Task.cont
Exemple #14
0
    def __apply_linear_velocity(self):
        global_vel = self.node.getQuat(render).xform(
            self.__linear_velocity) * self.__time_step

        if self.predict_future_space and not self.__check_future_space(
                global_vel):
            return

        if self.__foot_contact is not None and self.min_slope_dot and self.movement_state != "flying":
            normal_vel = Vec3(global_vel)
            normal_vel.normalize()

            floor_normal = self.__foot_contact[2]
            abs_slope_dot = round(floor_normal.dot(Vec3.up()), 2)

            def apply_gravity():
                self.__current_pos -= Vec3(
                    floor_normal.x, floor_normal.y,
                    0.0) * self.gravity * self.__time_step * 0.1

            if abs_slope_dot <= self.min_slope_dot:
                apply_gravity()

                if global_vel != Vec3():
                    global_vel_dir = Vec3(global_vel)
                    global_vel_dir.normalize()

                    fn = Vec3(floor_normal.x, floor_normal.y, 0.0)
                    fn.normalize()

                    vel_dot = 1.0 - global_vel_dir.angleDeg(fn) / 180.0
                    if vel_dot < 0.5:
                        self.__current_pos -= Vec3(fn.x * global_vel.x, fn.y *
                                                   global_vel.y, 0.0) * vel_dot

                    global_vel *= vel_dot

            elif self.__slope_affects_speed and global_vel != Vec3():
                apply_gravity()

        self.__current_pos += global_vel
Exemple #15
0
    def __applyLinearVelocity(self):
        globalVel = self.movementParent.getQuat(render).xform(
            self.__linearVelocity) * self.__timeStep

        if self.predictFutureSpace and not self.__checkFutureSpace(globalVel):
            return

        if self.__footContact is not None and self.minSlopeDot and self.movementState != "flying":
            normalVel = Vec3(globalVel)
            normalVel.normalize()

            floorNormal = self.__footContact[2]
            absSlopeDot = round(floorNormal.dot(Vec3.up()), 2)

            def applyGravity():
                self.__currentPos -= Vec3(
                    floorNormal.x, floorNormal.y,
                    0.0) * self.gravity * self.__timeStep * 0.1

            if absSlopeDot <= self.minSlopeDot:
                applyGravity()

                if globalVel != Vec3():
                    globalVelDir = Vec3(globalVel)
                    globalVelDir.normalize()

                    fn = Vec3(floorNormal.x, floorNormal.y, 0.0)
                    fn.normalize()

                    velDot = 1.0 - globalVelDir.angleDeg(fn) / 180.0
                    if velDot < 0.5:
                        self.__currentPos -= Vec3(fn.x * globalVel.x, fn.y *
                                                  globalVel.y, 0.0) * velDot

                    globalVel *= velDot

            elif self.__slopeAffectsSpeed and globalVel != Vec3():
                applyGravity()

        self.__currentPos += globalVel
Exemple #16
0
    def update(self, task=None):
        """
        Updates position of sounds in the 3D audio system. Will be called automatically
        in a task.
        """
        # Update the positions of all sounds based on the objects
        # to which they are attached

        # The audio manager is not active so do nothing
        if hasattr(self.audio_manager, "getActive"):
            if self.audio_manager.getActive() == 0:
                return Task.cont

        for known_object in self.sound_dict.keys():
            tracked_sound = 0
            while tracked_sound < len(self.sound_dict[known_object]):
                sound = self.sound_dict[known_object][tracked_sound]
                pos = known_object.getPos(self.root)
                vel = self.getSoundVelocity(sound)
                sound.set3dAttributes(pos[0], pos[1], pos[2], vel[0], vel[1],
                                      vel[2])
                tracked_sound += 1

        # Update the position of the listener based on the object
        # to which it is attached
        if self.listener_target:
            pos = self.listener_target.getPos(self.root)
            forward = self.root.getRelativeVector(self.listener_target,
                                                  Vec3.forward())
            up = self.root.getRelativeVector(self.listener_target, Vec3.up())
            vel = self.getListenerVelocity()
            self.audio_manager.audio3dSetListenerAttributes(
                pos[0], pos[1], pos[2], vel[0], vel[1], vel[2], forward[0],
                forward[1], forward[2], up[0], up[1], up[2])
        else:
            self.audio_manager.audio3dSetListenerAttributes(
                0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1)
        return Task.cont
Exemple #17
0
    def update(self, task=None):
        """
        Updates position of sounds in the 3D audio system. Will be called automatically
        in a task.
        """
        # Update the positions of all sounds based on the objects
        # to which they are attached

        # The audio manager is not active so do nothing
        if hasattr(self.audio_manager, "getActive"):
            if self.audio_manager.getActive()==0:
                return Task.cont

        for known_object, sounds in list(self.sound_dict.items()):
            node_path = known_object.getNodePath()
            if not node_path:
                # The node has been deleted.
                del self.sound_dict[known_object]
                continue

            pos = node_path.getPos(self.root)

            for sound in sounds:
                vel = self.getSoundVelocity(sound)
                sound.set3dAttributes(pos[0], pos[1], pos[2], vel[0], vel[1], vel[2])

        # Update the position of the listener based on the object
        # to which it is attached
        if self.listener_target:
            pos = self.listener_target.getPos(self.root)
            forward = self.root.getRelativeVector(self.listener_target, Vec3.forward())
            up = self.root.getRelativeVector(self.listener_target, Vec3.up())
            vel = self.getListenerVelocity()
            self.audio_manager.audio3dSetListenerAttributes(pos[0], pos[1], pos[2], vel[0], vel[1], vel[2], forward[0], forward[1], forward[2], up[0], up[1], up[2])
        else:
            self.audio_manager.audio3dSetListenerAttributes(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1)
        return Task.cont
Exemple #18
0
 def primitives(self, vdata):
     vertex = GeomVertexWriter(vdata, 'vertex')
     color = GeomVertexWriter(vdata, 'color')
     w = ROAD_WIDTH / 2.0
     v = 0
     for a, b in self.edges:
         a, b = self.points[a], self.points[b]
         ab = b - a
         n = ab.length()
         inc = abs(a.z - b.z) / n
         probes = max(2, n / 25)
         ab_ = Vec3(ab)
         ab_.normalize()
         pab = Vec3.up().cross(ab_) * w
         road = GeomTristrips(Geom.UHStatic)
         for i in range(0, int(probes) + 1):
             p = a + ab / probes * i
             p1 = p + pab
             p2 = p - pab
             z = max(elevation(p1.x, p1.y), elevation(p2.x, p2.y))
             p1.z = z + 0.2
             p2.z = z + 0.2
             vertex.addData3f(p1)
             vertex.addData3f(p2)
             if inc > 0.1:
                 color.addData4f(0.4, 0.0, 0.0, 0.0)
                 color.addData4f(0.4, 0.0, 0.0, 0.0)
             elif n > 1000:
                 color.addData4f(0.0, 0.0, 0.4, 0.0)
                 color.addData4f(0.0, 0.0, 0.4, 0.0)
             else:
                 color.addData4f(0.2, 0.2, 0.2, 0.0)
                 color.addData4f(0.2, 0.2, 0.2, 0.0)
             road.addVertices(v, v + 1)
             v += 2
         road.closePrimitive()
         yield road
Exemple #19
0
 def __applyLinearVelocity(self):
     globalVel = self.movementParent.getQuat(render).xform(self.__linearVelocity) * self.__timeStep
     
     if self.predictFutureSpace and not self.__checkFutureSpace(globalVel):
         return
     
     if self.__footContact is not None and self.minSlopeDot and self.movementState != "flying":
         normalVel = Vec3(globalVel)
         normalVel.normalize()
         
         floorNormal = self.__footContact[2]
         absSlopeDot = round(floorNormal.dot(Vec3.up()), 2)
         
         def applyGravity():
             self.__currentPos -= Vec3(floorNormal.x, floorNormal.y, 0.0) * self.gravity * self.__timeStep * 0.1
         
         if absSlopeDot <= self.minSlopeDot:
             applyGravity()
             
             if globalVel != Vec3():
                 globalVelDir = Vec3(globalVel)
                 globalVelDir.normalize()
                 
                 fn = Vec3(floorNormal.x, floorNormal.y, 0.0)
                 fn.normalize()
                 
                 velDot = 1.0 - globalVelDir.angleDeg(fn) / 180.0
                 if velDot < 0.5:
                     self.__currentPos -= Vec3(fn.x * globalVel.x, fn.y * globalVel.y, 0.0) * velDot
                 
                 globalVel *= velDot
         
         elif self.__slopeAffectsSpeed and globalVel != Vec3():
             applyGravity()
     
     self.__currentPos += globalVel
Exemple #20
0
    def __updateTask(self, task):
        # TODO -- This function does a lot of math, I measured it to take .5 ms on my laptop
        #         That's a lot of time for something miniscule like sway and bob.

        dt = globalClock.getDt()
        time = globalClock.getFrameTime()

        if base.localAvatar.isFirstPerson():
            eyePoint = base.localAvatar.getEyePoint()
            if base.localAvatar.walkControls.crouching:
                eyePoint[2] = eyePoint[2] / 2.0
            eyePoint[2] = CIGlobals.lerpWithRatio(eyePoint[2],
                                                  self.lastEyeHeight, 0.4)
            self.lastEyeHeight = eyePoint[2]

        camRootAngles = Vec3(0)

        # Mouse look around
        mw = base.mouseWatcherNode
        if mw.hasMouse():
            md = base.win.getPointer(0)
            center = Point2(base.win.getXSize() / 2, base.win.getYSize() / 2)

            xDist = md.getX() - center.getX()
            yDist = md.getY() - center.getY()

            sens = self.__getMouseSensitivity()

            angular = -(xDist * sens) / dt
            base.localAvatar.walkControls.controller.setAngularMovement(
                angular)
            camRootAngles.setY(self.lastPitch - yDist * sens)

            if camRootAngles.getY() > FPSCamera.MaxP:
                camRootAngles.setY(FPSCamera.MaxP)
                yDist = 0
            elif camRootAngles.getY() < FPSCamera.MinP:
                yDist = 0
                camRootAngles.setY(FPSCamera.MinP)

            base.win.movePointer(0, int(center.getX()), int(center.getY()))

        if base.localAvatar.isFirstPerson():
            # Camera / viewmodel bobbing
            vmBob = Point3(0)
            vmAngles = Vec3(0)
            vmRaise = Point3(0)
            camBob = Point3(0)

            maxSpeed = base.localAvatar.walkControls.BattleRunSpeed * 16.0

            speed = base.localAvatar.walkControls.speeds.length() * 16.0
            speed = max(-maxSpeed, min(maxSpeed, speed))

            bobOffset = CIGlobals.remapVal(speed, 0, maxSpeed, 0.0, 1.0)

            self.bobTime += (time - self.lastBobTime) * bobOffset
            self.lastBobTime = time

            # Calculate the vertical bob
            cycle = self.bobTime - int(
                self.bobTime / self.BobCycleMax) * self.BobCycleMax
            cycle /= self.BobCycleMax
            if cycle < self.BobUp:
                cycle = math.pi * cycle / self.BobUp
            else:
                cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
                                                                    self.BobUp)

            verticalBob = speed * 0.005
            verticalBob = verticalBob * 0.3 + verticalBob * 0.7 * math.sin(
                cycle)
            verticalBob = max(-7.0, min(4.0, verticalBob))
            verticalBob /= 16.0

            # Calculate the lateral bob
            cycle = self.bobTime - int(
                self.bobTime / self.BobCycleMax * 2) * self.BobCycleMax * 2
            cycle /= self.BobCycleMax * 2
            if cycle < self.BobUp:
                cycle = math.pi * cycle / self.BobUp
            else:
                cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
                                                                    self.BobUp)

            lateralBob = speed * 0.005
            lateralBob = lateralBob * 0.3 + lateralBob * 0.7 * math.sin(cycle)
            lateralBob = max(-7.0, min(4.0, lateralBob))
            lateralBob /= 16.0

            # Apply bob, but scaled down a bit
            vmBob.set(lateralBob * 0.8, 0, verticalBob * 0.1)
            # Z bob a bit more
            vmBob[2] += verticalBob * 0.1
            # Bob the angles
            vmAngles[2] += verticalBob * 0.5
            vmAngles[1] -= verticalBob * 0.4
            vmAngles[0] -= lateralBob * 0.3

            # ================================================================
            # Viewmodel lag/sway

            angles = self.camRoot.getHpr(render)
            quat = Quat()
            quat.setHpr(angles)
            invQuat = Quat()
            invQuat.invertFrom(quat)

            maxVMLag = 1.5
            lagforward = quat.getForward()
            if dt != 0.0:
                lagdifference = lagforward - self.lastFacing
                lagspeed = 5.0
                lagdiff = lagdifference.length()
                if (lagdiff > maxVMLag) and (maxVMLag > 0.0):
                    lagscale = lagdiff / maxVMLag
                    lagspeed *= lagscale

                self.lastFacing = CIGlobals.extrude(self.lastFacing,
                                                    lagspeed * dt,
                                                    lagdifference)
                self.lastFacing.normalize()
                lfLocal = invQuat.xform(lagdifference)
                vmBob = CIGlobals.extrude(vmBob, 5.0 / 16.0, lfLocal * -1.0)

            pitch = angles[1]
            if pitch > 180:
                pitch -= 360
            elif pitch < -180:
                pitch += 360

            vmBob = CIGlobals.extrude(vmBob, pitch * (0.035 / 16),
                                      Vec3.forward())
            vmBob = CIGlobals.extrude(vmBob, pitch * (0.03 / 16), Vec3.right())
            vmBob = CIGlobals.extrude(vmBob, pitch * (0.02 / 16), Vec3.up())

            # ================================================================

            vmRaise.set(
                0, 0, 0
            )  #(0, abs(camRootAngles.getY()) * -0.002, camRootAngles.getY() * 0.002)
            camBob.set(0, 0, 0)

            # Apply bob, raise, and sway to the viewmodel.
            self.viewModel.setPos(vmBob + vmRaise + self.lastVMPos)
            self.vmRoot2.setHpr(vmAngles)
            self.camRoot.setPos(eyePoint + camBob)

        newPitch = camRootAngles.getY()

        if abs(newPitch - self.lastPitch) > self.PitchUpdateEpsilon:
            # Broadcast where our head is looking
            head = base.localAvatar.getPart("head")
            if head and not head.isEmpty():
                # Constrain the head pitch a little bit so it doesn't look like their head snapped
                headPitch = max(-47, newPitch)
                headPitch = min(75, headPitch)
                base.localAvatar.b_setLookPitch(headPitch)

        self.lastPitch = newPitch

        if base.localAvatar.isFirstPerson():
            # Apply punch angle
            self.decayPunchAngle()
            camRootAngles += self.punchAngle

        self.camRoot.setHpr(camRootAngles)

        return task.cont
Exemple #21
0
    def handleAvatarControls(self, task):
        """
        Check on the arrow keys and update the avatar.
        """
        # get the button states:
        run = inputState.isSet("run")
        forward = inputState.isSet("forward")
        reverse = inputState.isSet("reverse")
        turnLeft = inputState.isSet("turnLeft")
        turnRight = inputState.isSet("turnRight")
        slideLeft = inputState.isSet("slideLeft")
        slideRight = inputState.isSet("slideRight")
        jump = inputState.isSet("jump")

        avatarControlForwardSpeed = 0
        avatarControlReverseSpeed = 0
        avatarControlSLeftSpeed = 0
        avatarControlSRightSpeed = 0

        if forward:
            if not self.hasSetForwardInitTime:
                self.forwardInitTime = globalClock.getFrameTime()
                self.hasSetForwardInitTime = True
                self.isAtZeroForward = False
                self.hasSetForwardStopTime = False
            timeSinceForwardSet = globalClock.getFrameTime() - self.forwardInitTime
            if timeSinceForwardSet == 0:
                avatarControlForwardSpeed = 0.0
            else:
                avatarControlForwardSpeed = min((timeSinceForwardSet / self.avatarControlForwardSpeed) * 750,
                                            self.avatarControlForwardSpeed)
        else:
            if self.hasSetForwardInitTime:
                self.hasSetForwardInitTime = False
            if not self.hasSetForwardStopTime:
                self.forwardStopTime = globalClock.getFrameTime()
                self.hasSetForwardStopTime = True
            timeSinceForwardStop = globalClock.getFrameTime() - self.forwardStopTime
            if timeSinceForwardStop == 0:
                avatarControlForwardSpeed = 16.0
            elif not self.isAtZeroForward:
                avatarControlForwardSpeed = self.avatarControlForwardSpeed - (timeSinceForwardStop * 50)
                if avatarControlForwardSpeed <= 0.5:
                    avatarControlForwardSpeed = 0.0
                    self.isAtZeroForward = True
                    self.hasSetForwardStopTime = False

        if reverse:
            if not self.hasSetReverseInitTime:
                self.reverseInitTime = globalClock.getFrameTime()
                self.hasSetReverseInitTime = True
                self.isAtZeroReverse = False
                self.hasSetReverseStopTime = False
            timeSinceReverseSet = globalClock.getFrameTime() - self.reverseInitTime
            if timeSinceReverseSet == 0:
                avatarControlReverseSpeed = 0.0
            else:
                avatarControlReverseSpeed = min((timeSinceReverseSet / self.avatarControlReverseSpeed) * 400,
                                            self.avatarControlReverseSpeed)
        else:
            if self.hasSetReverseInitTime:
                self.hasSetReverseInitTime = False
            if not self.hasSetReverseStopTime:
                self.reverseStopTime = globalClock.getFrameTime()
                self.hasSetReverseStopTime = True
            timeSinceReverseStop = globalClock.getFrameTime() - self.reverseStopTime
            if timeSinceReverseStop == 0:
                avatarControlReverseSpeed = 16.0
            elif not self.isAtZeroReverse:
                avatarControlReverseSpeed = self.avatarControlReverseSpeed - (timeSinceReverseStop * 20)
                if avatarControlReverseSpeed <= 0.5:
                    avatarControlReverseSpeed = 0.0
                    self.isAtZeroReverse = True
                    self.hasSetReverseStopTime = False

        if slideLeft:
            if not self.hasSetSLeftInitTime:
                self.sLeftInitTime = globalClock.getFrameTime()
                self.hasSetSLeftInitTime = True
                self.isAtZeroSLeft = False
                self.hasSetSLeftStopTime = False
            timeSinceSLeftSet = globalClock.getFrameTime() - self.sLeftInitTime
            if timeSinceSLeftSet == 0:
                avatarControlSLeftSpeed = 0.0
            else:
                avatarControlSLeftSpeed = min((timeSinceSLeftSet / self.avatarControlForwardSpeed) * 750,
                                            self.avatarControlForwardSpeed)
        else:
            if self.hasSetSLeftInitTime:
                self.hasSetSLeftInitTime = False
            if not self.hasSetSLeftStopTime:
                self.sLeftStopTime = globalClock.getFrameTime()
                self.hasSetSLeftStopTime = True
            timeSinceSLeftStop = globalClock.getFrameTime() - self.sLeftStopTime
            if timeSinceSLeftStop == 0:
                avatarControlSLeftSpeed = 16.0
            elif not self.isAtZeroSLeft:
                avatarControlSLeftSpeed = self.avatarControlForwardSpeed - (timeSinceSLeftStop * 50)
                if avatarControlSLeftSpeed <= 0.5:
                    avatarControlSLeftSpeed = 0.0
                    self.isAtZeroSLeft = True
                    self.hasSetSLeftStopTime = False

        if slideRight:
            if not self.hasSetSRightInitTime:
                self.sRightInitTime = globalClock.getFrameTime()
                self.hasSetSRightInitTime = True
                self.isAtZeroSRight = False
                self.hasSetSRightStopTime = False
            timeSinceSRightSet = globalClock.getFrameTime() - self.sRightInitTime
            if timeSinceSRightSet == 0:
                avatarControlSRightSpeed = 0.0
            else:
                avatarControlSRightSpeed = min((timeSinceSRightSet / self.avatarControlForwardSpeed) * 750,
                                            self.avatarControlForwardSpeed)
        else:
            if self.hasSetSRightInitTime:
                self.hasSetSRightInitTime = False
            if not self.hasSetSRightStopTime:
                self.sRightStopTime = globalClock.getFrameTime()
                self.hasSetSRightStopTime = True
            timeSinceSRightStop = globalClock.getFrameTime() - self.sRightStopTime
            if timeSinceSRightStop == 0:
                avatarControlSRightSpeed = 16.0
            elif not self.isAtZeroSRight:
                avatarControlSRightSpeed = self.avatarControlForwardSpeed - (timeSinceSRightStop * 50)
                if avatarControlSRightSpeed <= 0.5:
                    avatarControlSRightSpeed = 0.0
                    self.isAtZeroSRight = True
                    self.hasSetSRightStopTime = False

        # Check for Auto-Run
        #if 'localAvatar' in __builtins__:
        #    if base.localAvatar and base.localAvatar.getAutoRun():
        #        forward = 1
        #        reverse = 0

        # Determine what the speeds are based on the buttons:
        self.speed=(avatarControlForwardSpeed or
                    -avatarControlReverseSpeed)
        # Slide speed is a scaled down version of forward speed
        # Note: you can multiply a factor in here if you want slide to
        # be slower than normal walk/run. Let's try full speed.
        #self.slideSpeed=(slideLeft and -self.avatarControlForwardSpeed*0.75 or
        #                 slideRight and self.avatarControlForwardSpeed*0.75)
        self.slideSpeed=(-avatarControlSLeftSpeed or
                        avatarControlSRightSpeed)
        self.rotationSpeed=not (slideLeft or slideRight) and (
                (turnLeft and self.avatarControlRotateSpeed) or
                (turnRight and -self.avatarControlRotateSpeed))

        if self.speed and self.slideSpeed:
            self.speed *= GravityWalker.DiagonalFactor
            self.slideSpeed *= GravityWalker.DiagonalFactor

        debugRunning = inputState.isSet("debugRunning")
        if(debugRunning):
            self.speed*=base.debugRunningMultiplier
            self.slideSpeed*=base.debugRunningMultiplier
            self.rotationSpeed*=1.25

        if self.needToDeltaPos:
            self.setPriorParentVector()
            self.needToDeltaPos = 0
        if self.wantDebugIndicator:
            self.displayDebugInfo()
        if self.lifter.isOnGround():
            if self.isAirborne:
                self.isAirborne = 0
                assert self.debugPrint("isAirborne 0 due to isOnGround() true")
                impact = self.lifter.getImpactVelocity()
                if impact < -30.0:
                    messenger.send("jumpHardLand")
                    self.startJumpDelay(0.3)
                else:
                    messenger.send("jumpLand")
                    if impact < -5.0:
                        self.startJumpDelay(0.2)
                    # else, ignore the little potholes.
            assert self.isAirborne == 0
            self.priorParent = Vec3.zero()
            if jump and self.mayJump:
                # The jump button is down and we're close
                # enough to the ground to jump.
                self.lifter.addVelocity(self.avatarControlJumpForce)
                messenger.send("jumpStart")
                self.isAirborne = 1
                assert self.debugPrint("isAirborne 1 due to jump")
        else:
            if self.isAirborne == 0:
                assert self.debugPrint("isAirborne 1 due to isOnGround() false")
            self.isAirborne = 1

        self.__oldPosDelta = self.avatarNodePath.getPosDelta(render)
        # How far did we move based on the amount of time elapsed?
        self.__oldDt = ClockObject.getGlobalClock().getDt()
        dt=self.__oldDt

        # Check to see if we're moving at all:
        self.moving = self.speed or self.slideSpeed or self.rotationSpeed or (self.priorParent!=Vec3.zero())
        if self.moving:
            distance = dt * self.speed
            slideDistance = dt * self.slideSpeed
            rotation = dt * self.rotationSpeed

            # Take a step in the direction of our previous heading.
            if distance or slideDistance or self.priorParent != Vec3.zero():
                # rotMat is the rotation matrix corresponding to
                # our previous heading.
                rotMat=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
                if self.isAirborne:
                    forward = Vec3.forward()
                else:
                    contact = self.lifter.getContactNormal()
                    forward = contact.cross(Vec3.right())
                    # Consider commenting out this normalize.  If you do so
                    # then going up and down slops is a touch slower and
                    # steeper terrain can cut the movement in half.  Without
                    # the normalize the movement is slowed by the cosine of
                    # the slope (i.e. it is multiplied by the sign as a
                    # side effect of the cross product above).
                    forward.normalize()
                self.vel=Vec3(forward * distance)
                if slideDistance:
                    if self.isAirborne:
                        right = Vec3.right()
                    else:
                        right = forward.cross(contact)
                        # See note above for forward.normalize()
                        right.normalize()
                    self.vel=Vec3(self.vel + (right * slideDistance))
                self.vel=Vec3(rotMat.xform(self.vel))
                step=self.vel + (self.priorParent * dt)
                self.avatarNodePath.setFluidPos(Point3(
                        self.avatarNodePath.getPos()+step))
            self.avatarNodePath.setH(self.avatarNodePath.getH()+rotation)
        else:
            self.vel.set(0.0, 0.0, 0.0)
        if self.moving or jump:
            messenger.send("avatarMoving")
        return Task.cont
 def enterNormal(self):
     self.notify.debug('enterNormal')
     self.setAnimState('Catching', 1.0)
     if self.isLocal:
         self.activity.orthoWalk.start()
     self.toon.lerpLookAt(Vec3.forward() + Vec3.up(), time=0.2, blink=0)
Exemple #23
0
    def moveUp(self):
        vp = base.viewportMgr.activeViewport
        if not vp or not vp.is2D():
            return

        self.updatePos(self.pos + self.getMoveDelta(Vec3.up(), vp))
 def enterNormal(self):
     self.notify.debug('enterNormal')
     self.setAnimState('Catching', 1.0)
     if self.isLocal:
         self.activity.orthoWalk.start()
     self.toon.lerpLookAt(Vec3.forward() + Vec3.up(), time=0.2, blink=0)