IsJumping() публичный Метод

public IsJumping ( ) : bool
Результат bool
Пример #1
0
    public virtual void Update()
    {
        ThirdPersonController playerController = (ThirdPersonController)this.GetComponent(typeof(ThirdPersonController));
        float currentSpeed = playerController.GetSpeed();

        if (currentSpeed > playerController.walkSpeed)
        {
            this.anim.CrossFade("run");
            this.anim.Blend("jumpland", 0);
        }
        else
        {
            if (currentSpeed > 0.1f)
            {
                this.anim.CrossFade("walk");
                this.anim.Blend("jumpland", 0);
            }
            else
            {
                this.anim.Blend("walk", 0f, 0.3f);
                this.anim.Blend("run", 0f, 0.3f);
                this.anim.Blend("run", 0f, 0.3f);
            }
        }
        this.anim["run"].normalizedSpeed  = this.runSpeedScale;
        this.anim["walk"].normalizedSpeed = this.walkSpeedScale;
        if (playerController.IsJumping())
        {
            if (playerController.IsControlledDescent())
            {
                this.anim.CrossFade("jetpackjump", 0.2f);
            }
            else
            {
                if (playerController.HasJumpReachedApex())
                {
                    this.anim.CrossFade("jumpfall", 0.2f);
                }
                else
                {
                    this.anim.CrossFade("jump", 0.2f);
                }
            }
        }
        else
        {
            if (!playerController.IsGroundedWithTimeout())
            {
                this.anim.CrossFade("ledgefall", 0.2f);
            }
            else
            {
                this.anim.Blend("ledgefall", 0f, 0.2f);
            }
        }
    }
    public virtual IEnumerator Start()
    {
        ThirdPersonController playerController = (ThirdPersonController)this.GetComponent(typeof(ThirdPersonController));

        this.GetComponent <AudioSource>().loop = false;
        this.GetComponent <AudioSource>().Stop();
        var   particles  = this.GetComponentsInChildren(typeof(ParticleSystem));
        Light childLight = (Light)this.GetComponentInChildren(typeof(Light));

        foreach (ParticleSystem p in particles)
        {
            var e = p.emission;
            e.enabled = false;
        }
        childLight.enabled = false;
        while (true)
        {
            bool isFlying = playerController.IsJumping();
            if (isFlying)
            {
                if (!this.GetComponent <AudioSource>().isPlaying)
                {
                    this.GetComponent <AudioSource>().Play();
                }
            }
            else
            {
                this.GetComponent <AudioSource>().Stop();
            }
            foreach (ParticleSystem p in particles)
            {
                var e = p.emission;
                e.enabled = isFlying;
            }
            if (isFlying)
            {
                this.litAmount = Mathf.Clamp01(this.litAmount + (Time.deltaTime * 2));
            }
            else
            {
                this.litAmount = Mathf.Clamp01(this.litAmount - (Time.deltaTime * 2));
            }
            childLight.enabled   = isFlying;
            childLight.intensity = this.litAmount;
            yield return(null);
        }
    }
Пример #3
0
    private void LateUpdate()
    {
        var targetCenter = Target.position + _centerOffset;
        var targetHead   = Target.position + _headOffset;

        // When jumping don't move the camera upwards but only down!
        if (_controller.IsJumping())
        {
            // We'd be moving the camera upwards, do that only if it's really high!
            float newTargetHeight = targetCenter.y + Height;
            if (newTargetHeight < _targetHeight || newTargetHeight - _targetHeight > 5)
            {
                _targetHeight = targetCenter.y + Height;
            }
        }
        // When walking always update the height
        else
        {
            _targetHeight = targetCenter.y + Height;
        }

        // We start snapping when user pressed Fire2!
        _isSnapping = Input.GetButton("Fire2");

        if (_isSnapping)
        {
            //ApplySnapping(targetCenter);
            ApplyPositionDamping(new Vector3(targetCenter.x, _targetHeight, targetCenter.z));

            //TODO: Optimize!!
            Transform t = GameObject.Find("Player").GetComponent <ThirdPersonTargetting>().GetCurrentTarget();

            //Set our target as the snapped object
            targetCenter = t.position;
        }
        else
        {
            ApplyPositionDamping(new Vector3(targetCenter.x, _targetHeight, targetCenter.z));
        }

        SetupRotation(targetCenter, targetHead);
    }
Пример #4
0
    void Update() {

        if (characterController.IsJumping() && !isFlying || characterController.IsFalling() )
        {

            //next jump button shouldn't be too close to first jump time
            if ((characterController.LastJumpTime() + jumpOffset) > Time.time )
                return;


            if (Input.GetButtonDown("Jump"))
              ActivateFlying();               
            
        }


        if (isFlying)
            FlyingUpdate();

    }
Пример #5
0
    void Apply(Transform dummyTarget, Vector3 dummyCenter)
    {
        Vector3 targetCenter = target.position + centerOffset;
        Vector3 targetHead   = target.position + headOffset;

        // When jumping don't move camera upwards but only down!
        if (controller.IsJumping())
        {
            // We'd be moving the camera upwards, do that only if it's really high
            float newTargetHeight = targetCenter.y + height;
            if (newTargetHeight < targetHeight || newTargetHeight - targetHeight > 5)
            {
                targetHeight = targetCenter.y + height;
            }
            // When walking always update the target height
        }
        else
        {
            targetHeight = targetCenter.y + height;
        }

        // We start snapping when user pressed Fire2!
        if (Input.GetButton("Fire2") && !isSnapping)
        {
            velocity   = Vector3.zero;
            isSnapping = true;
        }

        if (isSnapping)
        {
            ApplySnapping(targetCenter);
        }
        else
        {
            ApplyPositionDamping(new Vector3(targetCenter.x, targetHeight, targetCenter.z));
        }

        SetUpRotation(targetCenter, targetHead);
    }
Пример #6
0
    void  Apply(Transform dummyTarget, Vector3 dummyCenter)
    {
        // Early out if we don't have a target
        if (!controller)
        {
            return;
        }

        Vector3 targetCenter = _target.position + centerOffset;
        Vector3 targetHead   = _target.position + headOffset;

        //	DebugDrawStuff();

        // Calculate the current & target rotation angles
        float originalTargetAngle = _target.eulerAngles.y;
        float currentAngle        = cameraTransform.eulerAngles.y;

        // Adjust real target angle when camera is locked
        float targetAngle = originalTargetAngle;

        // When pressing Fire2 (alt) the camera will snap to the target direction real quick.
        // It will stop snapping when it reaches the target
        if (Input.GetButton("Fire2"))
        {
            snap = true;
        }

        if (snap)
        {
            // We are close to the target, so we can stop snapping now!
            if (AngleDistance(currentAngle, originalTargetAngle) < 3.0f)
            {
                snap = false;
            }

            currentAngle = Mathf.SmoothDampAngle(currentAngle, targetAngle, ref angleVelocity, snapSmoothLag, snapMaxSpeed);
        }
        // Normal camera motion
        else
        {
            if (controller.GetLockCameraTimer() < lockCameraTimeout)
            {
                targetAngle = currentAngle;
            }

            // Lock the camera when moving backwards!
            // * It is really confusing to do 180 degree spins when turning around.
            if (AngleDistance(currentAngle, targetAngle) > 160 && controller.IsMovingBackwards())
            {
                targetAngle += 180;
            }

            currentAngle = Mathf.SmoothDampAngle(currentAngle, targetAngle, ref angleVelocity, angularSmoothLag, angularMaxSpeed);
        }


        // When jumping don't move camera upwards but only down!
        if (controller.IsJumping())
        {
            // We'd be moving the camera upwards, do that only if it's really high
            float newTargetHeight = targetCenter.y + height;
            if (newTargetHeight < targetHeight || newTargetHeight - targetHeight > 5)
            {
                targetHeight = targetCenter.y + height;
            }
        }
        // When walking always update the target height
        else
        {
            targetHeight = targetCenter.y + height;
        }

        // Damp the height
        float currentHeight = cameraTransform.position.y;

        currentHeight = Mathf.SmoothDamp(currentHeight, targetHeight, ref heightVelocity, heightSmoothLag);

        // Convert the angle into a rotation, by which we then reposition the camera
        Quaternion currentRotation = Quaternion.Euler(0, currentAngle, 0);

        // Set the position of the camera on the x-z plane to:
        // distance meters behind the target
        cameraTransform.position  = targetCenter;
        cameraTransform.position += currentRotation * Vector3.back * distance;

        Vector3 tempCameraTransformPos = cameraTransform.position;

        tempCameraTransformPos.y = currentHeight;
        cameraTransform.position = tempCameraTransformPos;

        // Always look at the target
        SetUpRotation(targetCenter, targetHead);
    }
private void GroundedAnimations()
{
    //blend off any residual animations
    animationGameObject.animation.Blend("fall", 0.0f, 0.1f);
    animationGameObject.animation.Blend("jump", 0.0f, 0.1f);
    animationGameObject.animation.Blend("fly", 0.0f, 0.1f);
    animationGameObject.animation.Blend("elevate", 0.0f, 0.1f);
    animationGameObject.animation.Blend("lower", 0.0f, 0.1f);

    //Fade in Run
    if (characterController.GetSpeed() >= (characterController.GetRunSpeed() - 1))
    {
        animationGameObject.animation.CrossFade("run");
		currentStatus = AnimationStatus.Run;

        //fade out walk
        animationGameObject.animation.Blend("walk", 0.0f, 0.3f);
    }

    // Fade in walk
    else if (characterController.GetSpeed() > 0.1f)
    {

        if (characterController.AreMovingKeysDown())
        {
            animationGameObject.animation.CrossFade("walk");
				currentStatus = AnimationStatus.Walk;
        }
        else
        {
            animationGameObject.animation.Blend("walk", 0.0f, 0.1f);
        }

        // We fade out jumpland realy quick otherwise we get sliding feet
        animationGameObject.animation.Blend("run", 0.0f, 0.3f);



    }

    // Fade out walk and run so just idle remains
    else
    {
        animationGameObject.animation.Blend("walk", 0.0f, 0.3f);
			currentStatus = AnimationStatus.Idle;
       // animationGameObject.animation.Blend("run", 0.0f, 0.3f);
    }

    
    animationGameObject.animation["run"].normalizedSpeed = runSpeedScale;
    animationGameObject.animation["walk"].normalizedSpeed = walkSpeedScale;

    //is Character Jumping
    if (characterController.IsJumping())
    {


        if (!characterController.HasJumpReachedApex() && characterController.IsJumping())
        {
			animationGameObject.animation.CrossFade("jump", 0.2f);
            animationGameObject.animation.Blend("fall", 0.0f, 0.3f);
        }

        else
        {
            animationGameObject.animation.Blend("jump", 0.0f, 0.3f);
            animationGameObject.animation.CrossFade("fall", 0.2f);

        }

		currentStatus = AnimationStatus.Jump;
			
        animationGameObject.animation.Blend("walk", 0.0f, 0.1f);
        animationGameObject.animation.Blend("run", 0.0f, 0.1f);

    }

}
    void Update()
    {
        ThirdPersonController marioController = GetComponent <ThirdPersonController> ();
        float currentSpeed = marioController.GetSpeed();

        networkSyncAnimation = GetComponent <NetworkSyncAnimation> ();

        // Fade in run
        if (currentSpeed > marioController.walkSpeed)
        {
            animation.CrossFade("run");
            // We fade out jumpland quick otherwise we get sliding feet
            animation.Blend("jumpland", 0);
            networkSyncAnimation.SendMessage("SyncAnimation", "run");
            // Fade in walk
        }
        else if (currentSpeed > 0.1f)
        {
            animation.CrossFade("walk");
            // We fade out jumpland realy quick otherwise we get sliding feet
            animation.Blend("jumpland", 0);
            networkSyncAnimation.SendMessage("SyncAnimation", "walk");
            // Fade out walk and run
        }
        else
        {
            animation.CrossFade("idle");
            networkSyncAnimation.SendMessage("SyncAnimation", "idle");
        }

        animation["run"].normalizedSpeed  = runSpeedScale;
        animation["walk"].normalizedSpeed = walkSpeedScale;

        if (marioController.IsJumping())
        {
            if (marioController.IsCapeFlying())
            {
                animation.CrossFade("jetpackjump", 0.2f);
                networkSyncAnimation.SendMessage("SyncAnimation", "jetpackjump");
            }
            else if (marioController.HasJumpReachedApex())
            {
                animation.CrossFade("jumpfall", 0.2f);
                networkSyncAnimation.SendMessage("SyncAnimation", "jumpfall");
            }
            else
            {
                animation.CrossFade("jump", 0.2f);
                networkSyncAnimation.SendMessage("SyncAnimation", "jump");
            }
            // We fell down somewhere
        }
        else if (!marioController.IsGroundedWithTimeout())
        {
            animation.CrossFade("ledgefall", 0.2f);
            networkSyncAnimation.SendMessage("SyncAnimation", "ledgefall");
            // We are not falling down anymore
        }
        else
        {
            animation.Blend("ledgefall", 0.0f, 0.2f);
        }
    }
Пример #9
0
    void Apply(Transform dummyTarget, Vector3 dummyCenter)
    {
        // Early out if we don't have a target
        if (!controller)
        {
            return;
        }

        bool    needGoOn     = false;
        Vector3 targetCenter = _target.position + centerOffset;
        Vector3 targetHead   = _target.position + headOffset;

        var strength = Input.GetAxis("Mouse ScrollWheel");

        if (strength != 0)
        {
            distance -= strength * mSpeed;
            distance  = Mathf.Clamp(distance, minDistance, maxDistance);

            /*
             * if(distance <= 1)
             * {
             *  SetVisible(false);
             *  minAngleY = -80;
             * }
             * else if(firstPersonLook)
             * {
             *  SetVisible(true);
             * }
             * else if(distance < look_height)
             * {
             *  minAngleY = (distance - 2) * (yTopLimit - yMinLimit)/(look_height - 2) - yTopLimit;
             *  minAngleY = - minAngleY;
             * }
             * else
             * {
             *  minAngleY = yMinLimit;
             * }
             */
            needGoOn = true;
        }

        var originalTargetAngle = 360 - _target.eulerAngles.y;

        current_hor_angle = 360 - cameraTransform.eulerAngles.y;
        if (!snapped)
        {
            var   targetAngle = originalTargetAngle;
            float dis_angle   = 0;
            if (dosnap)
            {
                dis_angle         = AngleDistance(360 - current_hor_angle, originalTargetAngle);
                current_hor_angle = Mathf.SmoothDampAngle(current_hor_angle, targetAngle, ref angleVelocity, snapSmoothLag, snapMaxSpeed);
            }

            // We are close to the target, so we can stop snapping now!
            dis_angle = 0;
            if (dis_angle <= 10)
            {
                snapped = true;
                dosnap  = false;
            }
            else if (dis_angle < 3)
            {
                dosnap = false;
            }
            if (!snapped && !dosnap)
            {
                current_hor_angle = Mathf.SmoothDampAngle(current_hor_angle, targetAngle, ref angleVelocity, angularSmoothLag, angularMaxSpeed);
            }
            needGoOn = true;
        }
        else
        {
            float rotation_h = 0;
            float rotation_v = 0;
            if (Input.GetMouseButton(1))
            {
                rotation_h = -Input.GetAxis("Mouse X") * xSpeed * 0.02f;
                rotation_v = -Input.GetAxis("Mouse Y") * ySpeed * 0.02f;
            }
            needGoOn = needGoOn || (rotation_h != 0 || rotation_v != 0);

            current_hor_angle += rotation_h;
            current_hor_angle  = Mathf.Repeat(current_hor_angle, 360);
            current_ver_angle += rotation_v;
            current_ver_angle  = Mathf.Clamp(current_ver_angle, minAngleY, yMaxLimit);
        }

        needGoOn = needGoOn || controller.IsMoving();
        needGoOn = needGoOn || controller.IsJumping();

        needGoOn             = needGoOn || needRefreshCameraPos;
        needRefreshCameraPos = false;

        //if (!needGoOn)/*没有鼠标键盘事件,返回即可,相机一般不会自动更新。除非未来有其他情形,那时候再添加*/
        //{
        //    MouseMoveContr mousecl = GetComponent<MouseMoveContr>();
        //    bool mouseMoveFlag = mousecl.GetMouseMoveFlag();

        //    if (!mouseMoveFlag)
        //    {
        //        return;
        //    }
        //}


        float rad_angle_h = (current_hor_angle - 90.0f) * Mathf.Deg2Rad;
        var   rad_angle_v = current_ver_angle * Mathf.Deg2Rad;
        var   camera_pos  = Vector3.zero;
        var   radius_hor  = distance * Mathf.Cos(rad_angle_v);
        float slope       = -Mathf.Sin(rad_angle_v);

        camera_pos.x = radius_hor * Mathf.Cos(rad_angle_h) + targetHead.x;/*计算相机位置是用 头部为球中心计算的*/
        camera_pos.z = radius_hor * Mathf.Sin(rad_angle_h) + targetHead.z;
        camera_pos.y = -distance * slope + targetHead.y;
        if (camera_pos.y < targetHead.y - look_height)
        {
            camera_pos.y = targetHead.y - look_height;
        }

        RaycastHit hit;
        bool       modified = false;

        float hor_dis = 0.0f;

        if (camera_pos.y < targetCenter.y)
        {
            var testPt = camera_pos;
            testPt.y = targetCenter.y;
            if (Physics.Raycast(testPt, Vector3.down, out hit, 50)) /*这个检测必须进行,不能完全指望后面的检测,否则会有微小的显示问题。一般发生在摄像机贴近地面跑动时*/
            {
                if (camera_pos.y < hit.point.y + 0.5)               /*偏移0.5.防止过于接近地面,并且在地面上面的情况,会因为摄像机近截面问题。导致显示地下的内容*/
                {
                    //modified = true;

                    hor_dis      = Vector3.Distance(targetCenter, new Vector3(camera_pos.x, targetCenter.y, camera_pos.z));
                    camera_pos   = hit.point;
                    camera_pos.y = (slope > 0.95f) ? hit.point.y : (camera_pos.y + hor_dis / maxDistance);
                    //摄像头在脚下的时候,hor_dis几乎为0
                    modified = false;
                    //Debug.Log("hit down.....camera_pos : " +camera_pos);
                }
            }
        }

        //if (modified)
        //{
        //    hor_dis = Vector3.Distance(targetCenter, new Vector3(camera_pos.x, targetCenter.y, camera_pos.z));
        //    camera_pos = hit.point;
        //    camera_pos.y = (slope > 0.95f) ? hit.point.y : (camera_pos.y + hor_dis / maxDistance);
        //    //摄像头在脚下的时候,hor_dis几乎为0
        //    modified = false;
        //    //Debug.Log("hit down.....camera_pos : " +camera_pos);
        //}

        var real_dis  = Vector3.Distance(targetCenter, camera_pos);
        var direction = camera_pos - targetCenter;

        if (Physics.Raycast(targetCenter, direction, out hit, real_dis) && hit.collider.gameObject != gameObject)
        {
            //		modified = false;
            //		if(hit.collider.bounds.size.magnitude <= 15) {
            //			modified = false;
            //		} else if (hit.collider.gameObject.tag == "bridge") {
            //			camera_pos.y = camera_pos.y + 2.5;
            //		} else if (hit.collider.gameObject.tag == "through"){
            //			modified = false;
            //		} else {
            //			modified = true;
            //		}
            //		Debug.LogError(hit.point.y < targetHead.y);
            camera_pos = hit.point;
            if (hit.point.y < targetHead.y)
            {
                camera_pos.y = targetHead.y;
                //			Debug.LogError(camera_pos);
            }
        }
        //
        //	if(modified)
        //	{
        //		hor_dis  = Vector3.Distance(targetCenter,Vector3(camera_pos.x,targetCenter.y,camera_pos.z));
        //		camera_pos   = hit.point;
        //		camera_pos.y = (slope > 0.95)?hit.point.y:(camera_pos.y + hor_dis/maxDistance);/*摄像头在脚下的时候,hor_dis几乎为0*/
        //	}
        cameraTransform.position = camera_pos;


        var offsetToCenter = targetHead - cameraTransform.position;

        cameraTransform.rotation = Quaternion.LookRotation(new Vector3(offsetToCenter.x, offsetToCenter.y, offsetToCenter.z));
        Debug.DrawLine(targetHead, camera_pos, Color.red);
    }