Unity3D 第一人称控制器 C#脚本

CharacterMotor.cs

using UnityEngine;
using System.Collections;   

/**
 *  @Author : www.xuanyusong.com
 */

[RequireComponent(typeof(CharacterController))]
[AddComponentMenu("Character/Character Motor")]   

public class CharacterMotor : MonoBehaviour {   

    // Does this script currently respond to input?
    public bool canControl  = true;   

    public bool useFixedUpdate = true;   

    // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.
    // Very handy for organization!   

    // The current global direction we want the character to move in.
    [System.NonSerialized]
    public Vector3 inputMoveDirection = Vector3.zero;   

    // Is the jump button held down? We use this interface instead of checking
    // for the jump button directly so this script can also be used by AIs.
    [System.NonSerialized]
    public bool inputJump  = false;   

    [System.Serializable]
    public class CharacterMotorMovement
    {   

        // The maximum horizontal speed when moving
        public float maxForwardSpeed = 10.0f;
        public float maxSidewaysSpeed = 10.0f;
        public float maxBackwardsSpeed = 10.0f;   

        // Curve for multiplying speed based on slope (negative = downwards)
        public AnimationCurve slopeSpeedMultiplier = new AnimationCurve(new Keyframe(-, ), new Keyframe(, ), new Keyframe(, ));   

        // How fast does the character change speeds?  Higher is faster.
        public float maxGroundAcceleration = 30.0f;
        public float maxAirAcceleration = 20.0f;   

        // The gravity for the character
        public float gravity = 10.0f;
        public float maxFallSpeed = 20.0f;   

        // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.
        // Very handy for organization!   

        // The last collision flags returned from controller.Move
        [System.NonSerialized]
        public CollisionFlags collisionFlags;    

        // We will keep track of the character's current velocity,
        [System.NonSerialized]
        public Vector3 velocity;   

        // This keeps track of our current velocity while we're not grounded
        [System.NonSerialized]
        public Vector3 frameVelocity = Vector3.zero;   

        [System.NonSerialized]
        public Vector3 hitPoint = Vector3.zero;   

        [System.NonSerialized]
        public Vector3 lastHitPoint = new Vector3(Mathf.Infinity, , );
    }   

    public CharacterMotorMovement movement = new CharacterMotorMovement();   

    public enum MovementTransferOnJump {
        None, // The jump is not affected by velocity of floor at all.
        InitTransfer, // Jump gets its initial velocity from the floor, then gradualy comes to a stop.
        PermaTransfer, // Jump gets its initial velocity from the floor, and keeps that velocity until landing.
        PermaLocked // Jump is relative to the movement of the last touched floor and will move together with that floor.
    }   

    // We will contain all the jumping related variables in one helper class for clarity.
    [System.Serializable]
    public class CharacterMotorJumping {
        // Can the character jump?
        public bool enabled = true;   

        // How high do we jump when pressing jump and letting go immediately
        public float baseHeight = 1.0f;   

        // We add extraHeight units (meters) on top when holding the button down longer while jumping
        public float extraHeight = 4.1f;   

        // How much does the character jump out perpendicular to the surface on walkable surfaces?
        // 0 means a fully vertical jump and 1 means fully perpendicular.
        public float perpAmount  = 0.0f;   

        // How much does the character jump out perpendicular to the surface on too steep surfaces?
        // 0 means a fully vertical jump and 1 means fully perpendicular.
        public float steepPerpAmount = 0.5f;   

        // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.
        // Very handy for organization!   

        // Are we jumping? (Initiated with jump button and not grounded yet)
        // To see if we are just in the air (initiated by jumping OR falling) see the grounded variable.
        [System.NonSerialized]
        public bool jumping = false;   

        [System.NonSerialized]
        public bool holdingJumpButton = false;   

        // the time we jumped at (Used to determine for how long to apply extra jump power after jumping.)
        [System.NonSerialized]
        public float lastStartTime = 0.0f;   

        [System.NonSerialized]
        public float lastButtonDownTime = -100f;   

        [System.NonSerialized]
        public Vector3 jumpDir = Vector3.up;
    }   

    public CharacterMotorJumping  jumping = new CharacterMotorJumping();   

    [System.Serializable]
    public class CharacterMotorMovingPlatform {
        public bool enabled = true;   

        public MovementTransferOnJump movementTransfer = MovementTransferOnJump.PermaTransfer;   

        [System.NonSerialized]
        public Transform hitPlatform;   

        [System.NonSerialized]
        public Transform activePlatform;   

        [System.NonSerialized]
        public Vector3 activeLocalPoint;   

        [System.NonSerialized]
        public Vector3 activeGlobalPoint;   

        [System.NonSerialized]
        public Quaternion activeLocalRotation;   

        [System.NonSerialized]
        public Quaternion activeGlobalRotation;   

        [System.NonSerialized]
        public Matrix4x4 lastMatrix;   

        [System.NonSerialized]
        public Vector3 platformVelocity;   

        [System.NonSerialized]
        public bool newPlatform;
    }   

    public CharacterMotorMovingPlatform movingPlatform  = new CharacterMotorMovingPlatform();   

    [System.Serializable]
    public class CharacterMotorSliding {
        // Does the character slide on too steep surfaces?
        public bool enabled = true;   

        // How fast does the character slide on steep surfaces?
        public float slidingSpeed  = 15f;   

        // How much can the player control the sliding direction?
        // If the value is 0.5 the player can slide sideways with half the speed of the downwards sliding speed.
        public float sidewaysControl = 1.0f;   

        // How much can the player influence the sliding speed?
        // If the value is 0.5 the player can speed the sliding up to 150% or slow it down to 50%.
        public float speedControl  = 0.4f;
    }   

    public CharacterMotorSliding sliding  = new CharacterMotorSliding();   

    [System.NonSerialized]
    public bool grounded = true;   

    [System.NonSerialized]
    public Vector3 groundNormal = Vector3.zero;   

    private Vector3  lastGroundNormal = Vector3.zero;   

    private Transform tr;   

    private CharacterController  controller ;   

    void Awake () {
        controller = GetComponent <CharacterController>();
        tr = transform;
    }   

    private void UpdateFunction () {
        // We copy the actual velocity into a temporary variable that we can manipulate.
        Vector3 velocity  = movement.velocity;   

        // Update velocity based on input
        velocity = ApplyInputVelocityChange(velocity);   

        // Apply gravity and jumping force
        velocity = ApplyGravityAndJumping (velocity);   

        // Moving platform support
        Vector3 moveDistance  = Vector3.zero;
        if (MoveWithPlatform()) {
            Vector3 newGlobalPoint  = movingPlatform.activePlatform.TransformPoint(movingPlatform.activeLocalPoint);
            moveDistance = (newGlobalPoint - movingPlatform.activeGlobalPoint);
            if (moveDistance != Vector3.zero)
                controller.Move(moveDistance);   

            // Support moving platform rotation as well:
            Quaternion newGlobalRotation  = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;
            Quaternion rotationDiff  = newGlobalRotation * Quaternion.Inverse(movingPlatform.activeGlobalRotation);   

            var yRotation = rotationDiff.eulerAngles.y;
            if (yRotation != ) {
                // Prevent rotation of the local up vector
                tr.Rotate(, yRotation, );
            }
        }   

        // Save lastPosition for velocity calculation.
        Vector3 lastPosition  = tr.position;   

        // We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
        Vector3 currentMovementOffset = velocity * Time.deltaTime;   

        // Find out how much we need to push towards the ground to avoid loosing grouning
        // when walking down a step or over a sharp change in slope.
        float pushDownOffset  = Mathf.Max(controller.stepOffset, new Vector3(currentMovementOffset.x, , currentMovementOffset.z).magnitude);
        if (grounded)
            currentMovementOffset -= pushDownOffset * Vector3.up;   

        // Reset variables that will be set by collision function
        movingPlatform.hitPlatform = null;
        groundNormal = Vector3.zero;   

        // Move our character!
        movement.collisionFlags = controller.Move (currentMovementOffset);   

        movement.lastHitPoint = movement.hitPoint;
        lastGroundNormal = groundNormal;   

        if (movingPlatform.enabled && movingPlatform.activePlatform != movingPlatform.hitPlatform) {
            if (movingPlatform.hitPlatform != null) {
                movingPlatform.activePlatform = movingPlatform.hitPlatform;
                movingPlatform.lastMatrix = movingPlatform.hitPlatform.localToWorldMatrix;
                movingPlatform.newPlatform = true;
            }
        }   

        // Calculate the velocity based on the current and previous position.
        // This means our velocity will only be the amount the character actually moved as a result of collisions.
        Vector3 oldHVelocity  = new Vector3(velocity.x, , velocity.z);
        movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
        Vector3 newHVelocity  = new Vector3(movement.velocity.x, , movement.velocity.z);   

        // The CharacterController can be moved in unwanted directions when colliding with things.
        // We want to prevent this from influencing the recorded velocity.
        if (oldHVelocity == Vector3.zero) {
            movement.velocity = new Vector3(, movement.velocity.y, );
        }
        else {
            float projectedNewVelocity  = Vector3.Dot(newHVelocity, oldHVelocity) / oldHVelocity.sqrMagnitude;
            movement.velocity = oldHVelocity * Mathf.Clamp01(projectedNewVelocity) + movement.velocity.y * Vector3.up;
        }   

        if (movement.velocity.y < velocity.y - 0.001) {
            if (movement.velocity.y < ) {
                // Something is forcing the CharacterController down faster than it should.
                // Ignore this
                movement.velocity.y = velocity.y;
            }
            else {
                // The upwards movement of the CharacterController has been blocked.
                // This is treated like a ceiling collision - stop further jumping here.
                jumping.holdingJumpButton = false;
            }
        }   

        // We were grounded but just loosed grounding
        if (grounded && !IsGroundedTest()) {
            grounded = false;   

            // Apply inertia from platform
            if (movingPlatform.enabled &&
                (movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
             movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)
                ) {
                movement.frameVelocity = movingPlatform.platformVelocity;
                movement.velocity += movingPlatform.platformVelocity;
            }   

            SendMessage("OnFall", SendMessageOptions.DontRequireReceiver);
            // We pushed the character down to ensure it would stay on the ground if there was any.
            // But there wasn't so now we cancel the downwards offset to make the fall smoother.
            tr.position += pushDownOffset * Vector3.up;
        }
        // We were not grounded but just landed on something
        else if (!grounded && IsGroundedTest()) {
            grounded = true;
            jumping.jumping = false;
            SubtractNewPlatformVelocity();   

            SendMessage("OnLand", SendMessageOptions.DontRequireReceiver);
        }   

        // Moving platforms support
        if (MoveWithPlatform()) {
            // Use the center of the lower half sphere of the capsule as reference point.
            // This works best when the character is standing on moving tilting platforms.
            movingPlatform.activeGlobalPoint = tr.position + Vector3.up * (controller.center.y - controller.height*0.5f + controller.radius);
            movingPlatform.activeLocalPoint = movingPlatform.activePlatform.InverseTransformPoint(movingPlatform.activeGlobalPoint);   

            // Support moving platform rotation as well:
            movingPlatform.activeGlobalRotation = tr.rotation;
            movingPlatform.activeLocalRotation = Quaternion.Inverse(movingPlatform.activePlatform.rotation) * movingPlatform.activeGlobalRotation;
        }
    }   

    void FixedUpdate () {
        if (movingPlatform.enabled) {
            if (movingPlatform.activePlatform != null) {
                if (!movingPlatform.newPlatform) {
                    Vector3 lastVelocity  = movingPlatform.platformVelocity;   

                    movingPlatform.platformVelocity = (
                                                       movingPlatform.activePlatform.localToWorldMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)
                                                       - movingPlatform.lastMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)
                                                       ) / Time.deltaTime;
                }
                movingPlatform.lastMatrix = movingPlatform.activePlatform.localToWorldMatrix;
                movingPlatform.newPlatform = false;
            }
            else {
                movingPlatform.platformVelocity = Vector3.zero;
            }
        }   

        if (useFixedUpdate)
            UpdateFunction();
    }   

    void Update () {
        if (!useFixedUpdate)
            UpdateFunction();
    }   

    private Vector3 ApplyInputVelocityChange (Vector3 velocity) {
        if (!canControl)
            inputMoveDirection = Vector3.zero;   

        // Find desired velocity
        Vector3 desiredVelocity;
        if (grounded && TooSteep()) {
            // The direction we're sliding in
            desiredVelocity = new Vector3(groundNormal.x, , groundNormal.z).normalized;
            // Find the input movement direction projected onto the sliding direction
            var projectedMoveDir = Vector3.Project(inputMoveDirection, desiredVelocity);
            // Add the sliding direction, the spped control, and the sideways control vectors
            desiredVelocity = desiredVelocity + projectedMoveDir * sliding.speedControl + (inputMoveDirection - projectedMoveDir) * sliding.sidewaysControl;
            // Multiply with the sliding speed
            desiredVelocity *= sliding.slidingSpeed;
        }
        else
            desiredVelocity = GetDesiredHorizontalVelocity();   

        if (movingPlatform.enabled && movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer) {
            desiredVelocity += movement.frameVelocity;
            desiredVelocity.y = ;
        }   

        if (grounded)
            desiredVelocity = AdjustGroundVelocityToNormal(desiredVelocity, groundNormal);
        else
            velocity.y = ;   

        // Enforce max velocity change
        float maxVelocityChange  = GetMaxAcceleration(grounded) * Time.deltaTime;
        Vector3 velocityChangeVector  = (desiredVelocity - velocity);
        if (velocityChangeVector.sqrMagnitude > maxVelocityChange * maxVelocityChange) {
            velocityChangeVector = velocityChangeVector.normalized * maxVelocityChange;
        }
        // If we're in the air and don't have control, don't apply any velocity change at all.
        // If we're on the ground and don't have control we do apply it - it will correspond to friction.
        if (grounded || canControl)
            velocity += velocityChangeVector;   

        if (grounded) {
            // When going uphill, the CharacterController will automatically move up by the needed amount.
            // Not moving it upwards manually prevent risk of lifting off from the ground.
            // When going downhill, DO move down manually, as gravity is not enough on steep hills.
            velocity.y = Mathf.Min(velocity.y, );
        }   

        return velocity;
    }   

    private Vector3 ApplyGravityAndJumping (Vector3 velocity) {   

        if (!inputJump || !canControl) {
            jumping.holdingJumpButton = false;
            jumping.lastButtonDownTime = -;
        }   

        if (inputJump && jumping.lastButtonDownTime <  && canControl)
            jumping.lastButtonDownTime = Time.time;   

        if (grounded)
            velocity.y = Mathf.Min(, velocity.y) - movement.gravity * Time.deltaTime;
        else {
            velocity.y = movement.velocity.y - movement.gravity * Time.deltaTime;   

            // When jumping up we don't apply gravity for some time when the user is holding the jump button.
            // This gives more control over jump height by pressing the button longer.
            if (jumping.jumping && jumping.holdingJumpButton) {
                // Calculate the duration that the extra jump force should have effect.
                // If we're still less than that duration after the jumping time, apply the force.
                if (Time.time < jumping.lastStartTime + jumping.extraHeight / CalculateJumpVerticalSpeed(jumping.baseHeight)) {
                    // Negate the gravity we just applied, except we push in jumpDir rather than jump upwards.
                    velocity += jumping.jumpDir * movement.gravity * Time.deltaTime;
                }
            }   

            // Make sure we don't fall any faster than maxFallSpeed. This gives our character a terminal velocity.
            velocity.y = Mathf.Max (velocity.y, -movement.maxFallSpeed);
        }   

        if (grounded) {
            // Jump only if the jump button was pressed down in the last 0.2 seconds.
            // We use this check instead of checking if it's pressed down right now
            // because players will often try to jump in the exact moment when hitting the ground after a jump
            // and if they hit the button a fraction of a second too soon and no new jump happens as a consequence,
            // it's confusing and it feels like the game is buggy.
            if (jumping.enabled && canControl && (Time.time - jumping.lastButtonDownTime < 0.2)) {
                grounded = false;
                jumping.jumping = true;
                jumping.lastStartTime = Time.time;
                jumping.lastButtonDownTime = -;
                jumping.holdingJumpButton = true;   

                // Calculate the jumping direction
                if (TooSteep())
                    jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.steepPerpAmount);
                else
                    jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.perpAmount);   

                // Apply the jumping force to the velocity. Cancel any vertical velocity first.
                velocity.y = ;
                velocity += jumping.jumpDir * CalculateJumpVerticalSpeed (jumping.baseHeight);   

                // Apply inertia from platform
                if (movingPlatform.enabled &&
                    (movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
                 movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)
                    ) {
                    movement.frameVelocity = movingPlatform.platformVelocity;
                    velocity += movingPlatform.platformVelocity;
                }   

                SendMessage("OnJump", SendMessageOptions.DontRequireReceiver);
            }
            else {
                jumping.holdingJumpButton = false;
            }
        }   

        return velocity;
    }   

    void OnControllerColliderHit (ControllerColliderHit hit) {
        if (hit.normal.y >  && hit.normal.y > groundNormal.y && hit.moveDirection.y < ) {
            if ((hit.point - movement.lastHitPoint).sqrMagnitude > 0.001 || lastGroundNormal == Vector3.zero)
                groundNormal = hit.normal;
            else
                groundNormal = lastGroundNormal;   

            movingPlatform.hitPlatform = hit.collider.transform;
            movement.hitPoint = hit.point;
            movement.frameVelocity = Vector3.zero;
        }
    }   

    private IEnumerator SubtractNewPlatformVelocity () {
        // When landing, subtract the velocity of the new ground from the character's velocity
        // since movement in ground is relative to the movement of the ground.
        if (movingPlatform.enabled &&
            (movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
         movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)
            ) {
            // If we landed on a new platform, we have to wait for two FixedUpdates
            // before we know the velocity of the platform under the character
            if (movingPlatform.newPlatform) {
                Transform platform  = movingPlatform.activePlatform;
                yield return new WaitForFixedUpdate();
                yield return new WaitForFixedUpdate();
                if (grounded && platform == movingPlatform.activePlatform)
                    yield return ;
            }
            movement.velocity -= movingPlatform.platformVelocity;
        }
    }   

    private bool MoveWithPlatform () {
        return (
                movingPlatform.enabled
                && (grounded || movingPlatform.movementTransfer == MovementTransferOnJump.PermaLocked)
                && movingPlatform.activePlatform != null
                );
    }   

    private Vector3 GetDesiredHorizontalVelocity () {
        // Find desired velocity
        Vector3 desiredLocalDirection  = tr.InverseTransformDirection(inputMoveDirection);
        float maxSpeed  = MaxSpeedInDirection(desiredLocalDirection);
        if (grounded) {
            // Modify max speed on slopes based on slope speed multiplier curve
            var movementSlopeAngle = Mathf.Asin(movement.velocity.normalized.y)  * Mathf.Rad2Deg;
            maxSpeed *= movement.slopeSpeedMultiplier.Evaluate(movementSlopeAngle);
        }
        return tr.TransformDirection(desiredLocalDirection * maxSpeed);
    }   

    private Vector3 AdjustGroundVelocityToNormal (Vector3 hVelocity, Vector3 groundNormal) {
        Vector3 sideways  = Vector3.Cross(Vector3.up, hVelocity);
        return Vector3.Cross(sideways, groundNormal).normalized * hVelocity.magnitude;
    }   

    private bool IsGroundedTest () {
        return (groundNormal.y > 0.01);
    }   

    float GetMaxAcceleration (bool grounded) {
        // Maximum acceleration on ground and in air
        if (grounded)
            return movement.maxGroundAcceleration;
        else
            return movement.maxAirAcceleration;
    }   

    float CalculateJumpVerticalSpeed (float targetJumpHeight) {
        // From the jump height and gravity we deduce the upwards speed
        // for the character to reach at the apex.
        return Mathf.Sqrt ( * targetJumpHeight * movement.gravity);
    }   

    bool IsJumping () {
        return jumping.jumping;
    }   

    bool IsSliding () {
        return (grounded && sliding.enabled && TooSteep());
    }   

    bool IsTouchingCeiling () {
        return (movement.collisionFlags & CollisionFlags.CollidedAbove) != ;
    }   

    bool IsGrounded () {
        return grounded;
    }   

    bool TooSteep () {
        return (groundNormal.y <= Mathf.Cos(controller.slopeLimit * Mathf.Deg2Rad));
    }   

    Vector3 GetDirection () {
        return inputMoveDirection;
    }   

    void  SetControllable (bool controllable) {
        canControl = controllable;
    }   

    // Project a direction onto elliptical quater segments based on forward, sideways, and backwards speed.
    // The function returns the length of the resulting vector.
    float MaxSpeedInDirection (Vector3 desiredMovementDirection) {
        if (desiredMovementDirection == Vector3.zero)
            return ;
        else {
            float zAxisEllipseMultiplier = (desiredMovementDirection.z >  ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;
            Vector3 temp = new Vector3(desiredMovementDirection.x, , desiredMovementDirection.z / zAxisEllipseMultiplier).normalized;
            float length = new Vector3(temp.x, , temp.z * zAxisEllipseMultiplier).magnitude * movement.maxSidewaysSpeed;
            return length;
        }
    }   

    void SetVelocity (Vector3 velocity) {
        grounded = false;
        movement.velocity = velocity;
        movement.frameVelocity = Vector3.zero;
        SendMessage("OnExternalVelocity");
    }   

    // Require a character controller to be attached to the same game object   

    //@script RequireComponent (CharacterController)
    //@script AddComponentMenu ("Character/Character Motor")   

}

FPSInputController.cs 内涵双摇杆控制脚本,请注意

using UnityEngine;
using System.Collections;   

/**
 *  @Author : www.xuanyusong.com
 */

[RequireComponent(typeof(CharacterMotor))]
[AddComponentMenu("Character/FPS Input Controller")]   

public class FPSInputController : MonoBehaviour {   

    private CharacterMotor motor ;   

    // Use this for initialization
    void Awake () {
        motor = GetComponent<CharacterMotor>();
    }   

    // Update is called once per frame
    void Update ()
    {
        keyMove ();
        //joyMove ();
    }   

    void joyMove()
    {
        Vector2 getPosition = gameObject.GetComponent<JoyStick>().getPositions();
        // Get the input vector from kayboard or analog stick
        Vector3 directionVector = new Vector3(getPosition.y, , getPosition.x);   

        if (directionVector != Vector3.zero) {
            // Get the length of the directon vector and then normalize it
            // Dividing by the length is cheaper than normalizing when we already have the length anyway
            var directionLength = directionVector.magnitude;
            directionVector = directionVector / directionLength;   

            // Make sure the length is no bigger than 1
            directionLength = Mathf.Min(, directionLength);   

            // Make the input vector more sensitive towards the extremes and less sensitive in the middle
            // This makes it easier to control slow speeds when using analog sticks
            directionLength = directionLength * directionLength;   

            // Multiply the normalized direction vector by the modified length
            directionVector = directionVector * directionLength;
        }   

        // Apply the direction to the CharacterMotor
        motor.inputMoveDirection = transform.rotation * directionVector;
        //motor.inputJump = Input.GetButton("Jump");
    }

    void keyMove()
    {
        // Get the input vector from kayboard or analog stick
        Vector3 directionVector = new Vector3(Input.GetAxis("Horizontal"), , Input.GetAxis("Vertical"));   

        if (directionVector != Vector3.zero) {
            // Get the length of the directon vector and then normalize it
            // Dividing by the length is cheaper than normalizing when we already have the length anyway
            var directionLength = directionVector.magnitude;
            directionVector = directionVector / directionLength;   

            // Make sure the length is no bigger than 1
            directionLength = Mathf.Min(, directionLength);   

            // Make the input vector more sensitive towards the extremes and less sensitive in the middle
            // This makes it easier to control slow speeds when using analog sticks
            directionLength = directionLength * directionLength;   

            // Multiply the normalized direction vector by the modified length
            directionVector = directionVector * directionLength;
        }   

        // Apply the direction to the CharacterMotor
        motor.inputMoveDirection = transform.rotation * directionVector;
        motor.inputJump = Input.GetButton("Jump");
    }

}

MouseLook.cs

内涵双摇杆控制脚本,请注意

using System.Collections;

/// MouseLook rotates the transform based on the mouse delta.
/// Minimum and Maximum values can be used to constrain the possible rotation

/// To make an FPS style character:
/// - Create a capsule.
/// - Add the MouseLook script to the capsule.
///   -> Set the mouse look to use LookX. (You want to only turn character but not tilt it)
/// - Add FPSInputController script to the capsule
///   -> A CharacterMotor and a CharacterController component will be automatically added.

/// - Create a camera. Make the camera a child of the capsule. Reset it's transform.
/// - Add a MouseLook script to the camera.
///   -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)
[AddComponentMenu("Camera-Control/Mouse Look")]
public class MouseLook : MonoBehaviour {

    public enum RotationAxes { MouseXAndY = , MouseX = , MouseY =  }
    public RotationAxes axes = RotationAxes.MouseXAndY;
    public float sensitivityX = 15F;
    public float sensitivityY = 15F;

    public float minimumX = -360F;
    public float maximumX = 360F;

    public float minimumY = -60F;
    public float maximumY = 60F;

    float rotationY = 0F;

    void Update ()
    {mouseMove ();
        //joyMove2();

    }

    void joyMove2()
    {
        if (axes == RotationAxes.MouseXAndY)
        {
            Vector2 getPosition = gameObject.GetComponent<JoyStick>().getPositions();

            float rotationX = transform.localEulerAngles.y + getPosition.x * sensitivityX;

            rotationY += getPosition.y * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);

            transform.localEulerAngles = new Vector3(-rotationY, rotationX, );
        }
        else if (axes == RotationAxes.MouseX)
        {
            Vector2 getPosition = transform.FindChild("Main Camera").GetComponent<JoyStick>().getPositions();
            transform.Rotate(, getPosition.x * sensitivityX, );
        }
        else
        {
            Vector2 getPosition = gameObject.GetComponent<JoyStick>().getPositions();
            rotationY += getPosition.y * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);

            transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, );
        }
    }

    void mouseMove()
    {if (axes == RotationAxes.MouseXAndY)
        {
            float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX;

            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);

            transform.localEulerAngles = new Vector3(-rotationY, rotationX, );
        }
        else if (axes == RotationAxes.MouseX)
        {
            transform.Rotate(, Input.GetAxis("Mouse X") * sensitivityX, );
        }
        else
        {
            rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
            rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);

            transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, );
        }
    }

    void Start ()
    {
        // Make the rigid body not change rotation
        if (GetComponent<Rigidbody>())
            GetComponent<Rigidbody>().freezeRotation = true;
    }
}

PlatformInputController.cs

using UnityEngine;
using System.Collections;   

/**
 *  @Author : www.xuanyusong.com
 */

[RequireComponent(typeof(CharacterController))]
[AddComponentMenu("Character/Platform Input Controller")]
public class PlatformInputController : MonoBehaviour {   

    public bool autoRotate = true;
    public float  maxRotationSpeed = ;   

    private CharacterMotor motor ;   

    // Use this for initialization
    void Awake () {
        motor = GetComponent<CharacterMotor>();
    }   

    // Update is called once per frame
    void Update () {
        // Get the input vector from kayboard or analog stick
        Vector3 directionVector = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), );   

        if (directionVector != Vector3.zero) {
            // Get the length of the directon vector and then normalize it
            // Dividing by the length is cheaper than normalizing when we already have the length anyway
            var directionLength = directionVector.magnitude;
            directionVector = directionVector / directionLength;   

            // Make sure the length is no bigger than 1
            directionLength = Mathf.Min(, directionLength);   

            // Make the input vector more sensitive towards the extremes and less sensitive in the middle
            // This makes it easier to control slow speeds when using analog sticks
            directionLength = directionLength * directionLength;   

            // Multiply the normalized direction vector by the modified length
            directionVector = directionVector * directionLength;
        }   

        // Rotate the input vector into camera space so up is camera's up and right is camera's right
        directionVector = Camera.main.transform.rotation * directionVector;   

        // Rotate input vector to be perpendicular to character's up vector
        var camToCharacterSpace = Quaternion.FromToRotation(-Camera.main.transform.forward, transform.up);
        directionVector = (camToCharacterSpace * directionVector);   

        // Apply the direction to the CharacterMotor
        motor.inputMoveDirection = directionVector;
        motor.inputJump = Input.GetButton("Jump");   

        // Set rotation to the move direction
        if (autoRotate && directionVector.sqrMagnitude > 0.01) {
            Vector3 newForward  = ConstantSlerp(
                                                transform.forward,
                                                directionVector,
                                                maxRotationSpeed * Time.deltaTime
                                                );
            newForward = ProjectOntoPlane(newForward, transform.up);
            transform.rotation = Quaternion.LookRotation(newForward, transform.up);
        }
    }   

    Vector3 ProjectOntoPlane (Vector3 v, Vector3 normal) {
        return v - Vector3.Project(v, normal);
    }   

    Vector3 ConstantSlerp (Vector3 from, Vector3 to, float angle) {
        float value = Mathf.Min(, angle / Vector3.Angle(from, to));
        return Vector3.Slerp(from, to, value);
    }   

}

ThirdPersonCamera.cs

using UnityEngine;
using System.Collections;   

/**
 *  @Author : www.xuanyusong.com
 */

public class ThirdPersonCamera : MonoBehaviour {   

    public Transform cameraTransform;
    private Transform _target;   

    public float distance = 7.0f;   

    public float height = 3.0f;   

    public float angularSmoothLag = 0.3f;
    public float angularMaxSpeed = 15.0f;   

    public float heightSmoothLag = 0.3f;   

    public float snapSmoothLag = 0.2f;
    public float snapMaxSpeed = 720.0f;   

    public float clampHeadPositionScreenSpace = 0.75f;   

    public float lockCameraTimeout = 0.2f;   

    private Vector3 headOffset = Vector3.zero;
    private Vector3 centerOffset = Vector3.zero;   

    private float heightVelocity = 0.0f;
    private float  angleVelocity = 0.0f;
    private bool snap = false;
    private ThirdPersonController controller;
    private float targetHeight = 100000.0f;    

    void Awake ()
    {
        if(!cameraTransform && Camera.main)
            cameraTransform = Camera.main.transform;
        if(!cameraTransform) {
            Debug.Log("Please assign a camera to the ThirdPersonCamera script.");
            enabled = false;
        }   

        _target = transform;
        if (_target)
        {
            controller = _target.GetComponent<ThirdPersonController>();
        }   

        if (controller)
        {
            CharacterController characterController  = (CharacterController)_target.collider;
            centerOffset = characterController.bounds.center - _target.position;
            headOffset = centerOffset;
            headOffset.y = characterController.bounds.max.y - _target.position.y;
        }
        else
            Debug.Log("Please assign a target to the camera that has a ThirdPersonController script attached.");   

        Cut(_target, centerOffset);
    }   

    void DebugDrawStuff ()
    {
        Debug.DrawLine(_target.position, _target.position + headOffset);   

    }   

    float  AngleDistance (float a , float b )
    {
        a = Mathf.Repeat(a, );
        b = Mathf.Repeat(b, );   

        return Mathf.Abs(b - a);
    }   

    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.0)
                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) >  && controller.IsMovingBackwards ())
                targetAngle += ;   

            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 > )
                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 (, currentAngle, );   

        // 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;   

        // Set the height of the camera
        cameraTransform.position = new Vector3(cameraTransform.position.x,currentHeight,cameraTransform.position.z);   

        // Always look at the target
        SetUpRotation(targetCenter, targetHead);
    }   

    void LateUpdate () {
        Apply (transform, Vector3.zero);
    }   

    void  Cut (Transform dummyTarget , Vector3 dummyCenter)
    {
        float oldHeightSmooth = heightSmoothLag;
        float oldSnapMaxSpeed = snapMaxSpeed;
        float oldSnapSmooth = snapSmoothLag;   

        snapMaxSpeed = ;
        snapSmoothLag = 0.001f;
        heightSmoothLag = 0.001f;   

        snap = true;
        Apply (transform, Vector3.zero);   

        heightSmoothLag = oldHeightSmooth;
        snapMaxSpeed = oldSnapMaxSpeed;
        snapSmoothLag = oldSnapSmooth;
    }   

    void SetUpRotation (Vector3 centerPos,Vector3  headPos)
    {
        // Now it's getting hairy. The devil is in the details here, the big issue is jumping of course.
        // * When jumping up and down we don't want to center the guy in screen space.
        //  This is important to give a feel for how high you jump and avoiding large camera movements.
        //
        // * At the same time we dont want him to ever go out of screen and we want all rotations to be totally smooth.
        //
        // So here is what we will do:
        //
        // 1. We first find the rotation around the y axis. Thus he is always centered on the y-axis
        // 2. When grounded we make him be centered
        // 3. When jumping we keep the camera rotation but rotate the camera to get him back into view if his head is above some threshold
        // 4. When landing we smoothly interpolate towards centering him on screen
        Vector3 cameraPos = cameraTransform.position;
        Vector3 offsetToCenter = centerPos - cameraPos;   

        // Generate base rotation only around y-axis
        Quaternion yRotation = Quaternion.LookRotation(new Vector3(offsetToCenter.x, , offsetToCenter.z));   

        Vector3 relativeOffset = Vector3.forward * distance + Vector3.down * height;
        cameraTransform.rotation = yRotation * Quaternion.LookRotation(relativeOffset);   

        // Calculate the projected center position and top position in world space
        Ray centerRay = cameraTransform.camera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 1f));
        Ray topRay = cameraTransform.camera.ViewportPointToRay(new Vector3(0.5f, clampHeadPositionScreenSpace, 1f));   

        Vector3 centerRayPos = centerRay.GetPoint(distance);
        Vector3 topRayPos = topRay.GetPoint(distance);   

        float centerToTopAngle = Vector3.Angle(centerRay.direction, topRay.direction);   

        float heightToAngle = centerToTopAngle / (centerRayPos.y - topRayPos.y);   

        float extraLookAngle = heightToAngle * (centerRayPos.y - centerPos.y);
        if (extraLookAngle < centerToTopAngle)
        {
            extraLookAngle = ;
        }
        else
        {
            extraLookAngle = extraLookAngle - centerToTopAngle;
            cameraTransform.rotation *= Quaternion.Euler(-extraLookAngle, , );
        }
    }   

    Vector3 GetCenterOffset ()
    {
        return centerOffset;
    }   

}

ThirdPersonController.cs

using UnityEngine;
using System.Collections;   

/**
 *  @Author : www.xuanyusong.com
 */

[RequireComponent(typeof(CharacterController))]   

public class ThirdPersonController : MonoBehaviour {   

    public AnimationClip idleAnimation ;
    public AnimationClip walkAnimation ;
    public AnimationClip runAnimation ;
    public AnimationClip jumpPoseAnimation;   

    public float walkMaxAnimationSpeed  = 0.75f;
    public float trotMaxAnimationSpeed  = 1.0f;
    public float runMaxAnimationSpeed  = 1.0f;
    public float jumpAnimationSpeed  = 1.15f;
    public float landAnimationSpeed  = 1.0f;   

    private Animation _animation;   

    enum CharacterState
    {
        Idle = ,
        Walking = ,
        Trotting = ,
        Running = ,
        Jumping = ,
    }   

    private CharacterState _characterState;   

    // The speed when walking
    float walkSpeed = 2.0f;
    // after trotAfterSeconds of walking we trot with trotSpeed
    float trotSpeed = 4.0f;
    // when pressing "Fire3" button (cmd) we start running
    float runSpeed = 6.0f;   

    float inAirControlAcceleration = 3.0f;   

    // How high do we jump when pressing jump and letting go immediately
    float jumpHeight = 0.5f;   

    // The gravity for the character
    float gravity = 20.0f;
    // The gravity in controlled descent mode
    float speedSmoothing = 10.0f;
    float rotateSpeed = 500.0f;
    float trotAfterSeconds = 3.0f;   

    bool canJump = true;   

    private float jumpRepeatTime = 0.05f;
    private float jumpTimeout = 0.15f;
    private float groundedTimeout = 0.25f;   

    // The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
    private float lockCameraTimer = 0.0f;   

    // The current move direction in x-z
    private Vector3 moveDirection = Vector3.zero;
    // The current vertical speed
    private float verticalSpeed = 0.0f;
    // The current x-z move speed
    private float moveSpeed = 0.0f;   

    // The last collision flags returned from controller.Move
    private CollisionFlags collisionFlags;    

    // Are we jumping? (Initiated with jump button and not grounded yet)
    private bool jumping = false;
    private bool jumpingReachedApex = false;   

    // Are we moving backwards (This locks the camera to not do a 180 degree spin)
    private bool movingBack = false;
    // Is the user pressing any keys?
    private bool isMoving = false;
    // When did the user start walking (Used for going into trot after a while)
    private float walkTimeStart = 0.0f;
    // Last time the jump button was clicked down
    private float lastJumpButtonTime = -10.0f;
    // Last time we performed a jump
    private float lastJumpTime = -1.0f;   

    // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
    private float lastJumpStartHeight = 0.0f;   

    private Vector3 inAirVelocity = Vector3.zero;   

    private float lastGroundedTime = 0.0f;   

    private bool isControllable = true;   

    void Awake ()
    {
        moveDirection = transform.TransformDirection(Vector3.forward);   

        _animation = GetComponent<Animation>();
        if(!_animation)
            Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");   

        /*
public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;
    */
        if(!idleAnimation) {
            _animation = null;
            Debug.Log("No idle animation found. Turning off animations.");
        }
        if(!walkAnimation) {
            _animation = null;
            Debug.Log("No walk animation found. Turning off animations.");
        }
        if(!runAnimation) {
            _animation = null;
            Debug.Log("No run animation found. Turning off animations.");
        }
        if(!jumpPoseAnimation && canJump) {
            _animation = null;
            Debug.Log("No jump animation found and the character has canJump enabled. Turning off animations.");
        }   

    }   

    void UpdateSmoothedMovementDirection ()
    {
        Transform cameraTransform = Camera.main.transform;
        bool grounded = IsGrounded();   

        // Forward vector relative to the camera along the x-z plane
        Vector3 forward = cameraTransform.TransformDirection(Vector3.forward);
        forward.y = ;
        forward = forward.normalized;   

        // Right vector relative to the camera
        // Always orthogonal to the forward vector
        Vector3 right = new Vector3(forward.z, , -forward.x);   

        float v = Input.GetAxisRaw("Vertical");
        float h = Input.GetAxisRaw("Horizontal");   

        // Are we moving backwards or looking backwards
        if (v < -0.2f)
            movingBack = true;
        else
            movingBack = false;   

        bool wasMoving = isMoving;
        isMoving = Mathf.Abs (h) > 0.1f || Mathf.Abs (v) > 0.1f;   

        // Target direction relative to the camera
        Vector3 targetDirection = h * right + v * forward;   

        // Grounded controls
        if (grounded)
        {
            // Lock camera for short period when transitioning moving & standing still
            lockCameraTimer += Time.deltaTime;
            if (isMoving != wasMoving)
                lockCameraTimer = 0.0f;   

            // We store speed and direction seperately,
            // so that when the character stands still we still have a valid forward direction
            // moveDirection is always normalized, and we only update it if there is user input.
            if (targetDirection != Vector3.zero)
            {
                // If we are really slow, just snap to the target direction
                if (moveSpeed < walkSpeed * 0.9f && grounded)
                {
                    moveDirection = targetDirection.normalized;
                }
                // Otherwise smoothly turn towards it
                else
                {
                    moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, );   

                    moveDirection = moveDirection.normalized;
                }
            }   

            // Smooth the speed based on the current target direction
            float curSmooth = speedSmoothing * Time.deltaTime;   

            // Choose target speed
            //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
            float targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0f);   

            _characterState = CharacterState.Idle;   

            // Pick speed modifier
            if (Input.GetKey (KeyCode.LeftShift) | Input.GetKey (KeyCode.RightShift))
            {
                targetSpeed *= runSpeed;
                _characterState = CharacterState.Running;
            }
            else if (Time.time - trotAfterSeconds > walkTimeStart)
            {
                targetSpeed *= trotSpeed;
                _characterState = CharacterState.Trotting;
            }
            else
            {
                targetSpeed *= walkSpeed;
                _characterState = CharacterState.Walking;
            }   

            moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);   

            // Reset walk time start when we slow down
            if (moveSpeed < walkSpeed * 0.3f)
                walkTimeStart = Time.time;
        }
        // In air controls
        else
        {
            // Lock camera while in air
            if (jumping)
                lockCameraTimer = 0.0f;   

            if (isMoving)
                inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
        }   

    }   

    void ApplyJumping ()
    {
        // Prevent jumping too fast after each other
        if (lastJumpTime + jumpRepeatTime > Time.time)
            return;   

        if (IsGrounded()) {
            // Jump
            // - Only when pressing the button down
            // - With a timeout so you can press the button slightly before landing
            if (canJump && Time.time < lastJumpButtonTime + jumpTimeout) {
                verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);
                SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
            }
        }
    }   

    void ApplyGravity ()
    {
        if (isControllable) // don't move player at all if not controllable.
        {
            // Apply gravity
            bool jumpButton = Input.GetButton("Jump");   

            // When we reach the apex of the jump we send out a message
            if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0f)
            {
                jumpingReachedApex = true;
                SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
            }   

            if (IsGrounded ())
                verticalSpeed = 0.0f;
            else
                verticalSpeed -= gravity * Time.deltaTime;
        }
    }   

    float CalculateJumpVerticalSpeed (float targetJumpHeight)
    {
        // From the jump height and gravity we deduce the upwards speed
        // for the character to reach at the apex.
        return Mathf.Sqrt( * targetJumpHeight * gravity);
    }   

    void  DidJump ()
    {
        jumping = true;
        jumpingReachedApex = false;
        lastJumpTime = Time.time;
        lastJumpStartHeight = transform.position.y;
        lastJumpButtonTime = -;   

        _characterState = CharacterState.Jumping;
    }   

    void  Update() {   

        if (!isControllable)
        {
            // kill all inputs if not controllable.
            Input.ResetInputAxes();
        }   

        if (Input.GetButtonDown ("Jump"))
        {
            lastJumpButtonTime = Time.time;
        }   

        UpdateSmoothedMovementDirection();   

        // Apply gravity
        // - extra power jump modifies gravity
        // - controlledDescent mode modifies gravity
        ApplyGravity ();   

        // Apply jumping logic
        ApplyJumping ();   

        // Calculate actual motion
        Vector3 movement = moveDirection * moveSpeed + new Vector3 (, verticalSpeed, ) + inAirVelocity;
        movement *= Time.deltaTime;   

        // Move the controller
        CharacterController controller = GetComponent<CharacterController>();
        collisionFlags = controller.Move(movement);   

        // ANIMATION sector
        if(_animation) {
            if(_characterState == CharacterState.Jumping)
            {
                if(!jumpingReachedApex) {
                    _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
                    _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
                    _animation.CrossFade(jumpPoseAnimation.name);
                } else {
                    _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
                    _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
                    _animation.CrossFade(jumpPoseAnimation.name);
                }
            }
            else
            {
                if(controller.velocity.sqrMagnitude < 0.1f) {
                    _animation.CrossFade(idleAnimation.name);
                }
                else
                {
                    if(_characterState == CharacterState.Running) {
                        _animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0f, runMaxAnimationSpeed);
                        _animation.CrossFade(runAnimation.name);
                    }
                    else if(_characterState == CharacterState.Trotting) {
                        _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0f, trotMaxAnimationSpeed);
                        _animation.CrossFade(walkAnimation.name);
                    }
                    else if(_characterState == CharacterState.Walking) {
                        _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0f, walkMaxAnimationSpeed);
                        _animation.CrossFade(walkAnimation.name);
                    }   

                }
            }
        }
        // ANIMATION sector   

        // Set rotation to the move direction
        if (IsGrounded())
        {   

            transform.rotation = Quaternion.LookRotation(moveDirection);   

        }
        else
        {
            Vector3 xzMove = movement;
            xzMove.y = ;
            if (xzMove.sqrMagnitude > 0.001f)
            {
                transform.rotation = Quaternion.LookRotation(xzMove);
            }
        }      

        // We are in jump mode but just became grounded
        if (IsGrounded())
        {
            lastGroundedTime = Time.time;
            inAirVelocity = Vector3.zero;
            if (jumping)
            {
                jumping = false;
                SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
            }
        }
    }   

    void  OnControllerColliderHit (ControllerColliderHit hit )
    {
        //  Debug.DrawRay(hit.point, hit.normal);
        if (hit.moveDirection.y > 0.01f)
            return;
    }   

    float GetSpeed () {
        return moveSpeed;
    }   

    public bool IsJumping () {
        return jumping;
    }   

    bool IsGrounded () {
        return (collisionFlags & CollisionFlags.CollidedBelow) != ;
    }   

    Vector3 GetDirection () {
        return moveDirection;
    }   

    public bool IsMovingBackwards () {
        return movingBack;
    }   

    public float GetLockCameraTimer ()
    {
        return lockCameraTimer;
    }   

    bool IsMoving ()
    {
        return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5f;
    }   

    bool HasJumpReachedApex ()
    {
        return jumpingReachedApex;
    }   

    bool IsGroundedWithTimeout ()
    {
        return lastGroundedTime + groundedTimeout > Time.time;
    }   

    void Reset ()
    {
        gameObject.tag = "Player";
    }   

}