3. 第一人称第三人称角色控制组件修改C#版本

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(-90, 1), new Keyframe(0, 1), new Keyframe(90, 0));

    // 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, 0, 0);
}

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 != 0) {
            // Prevent rotation of the local up vector
            tr.Rotate(0, yRotation, 0);
        }
    }

    // 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, 0, 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, 0, velocity.z);
    movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
    Vector3 newHVelocity  = new Vector3(movement.velocity.x, 0, 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(0, movement.velocity.y, 0);
    }
    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 < 0) {
            // 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, 0, 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 = 0;
    }

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

    // 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, 0);
    }

    return velocity;
}

private Vector3 ApplyGravityAndJumping (Vector3 velocity) {

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

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

    if (grounded)
        velocity.y = Mathf.Min(0, 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 = -100;
            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 = 0;
            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 > 0 && hit.normal.y > groundNormal.y && hit.moveDirection.y < 0) {
        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 1;
        }
        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 (2 * targetJumpHeight * movement.gravity);
}

bool IsJumping () {
    return jumping.jumping;
}

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

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

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 0;
    else {
        float zAxisEllipseMultiplier = (desiredMovementDirection.z > 0 ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;
        Vector3 temp = new Vector3(desiredMovementDirection.x, 0, desiredMovementDirection.z / zAxisEllipseMultiplier).normalized;
        float length = new Vector3(temp.x, 0, 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")

}

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 () {
    // Get the input vector from kayboard or analog stick
    Vector3 directionVector = new Vector3(Input.GetAxis("Horizontal"), 0, 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(1, 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");
}

}

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 = 360;

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"), 0);

    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(1, 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(1, angle / Vector3.Angle(from, to));
    return Vector3.Slerp(from, to, value);
}

}

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, 360);
    b = Mathf.Repeat(b, 360);

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

    // 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 = 10000;
    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, 0, 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 = 0;
    }
    else
    {
        extraLookAngle = extraLookAngle - centerToTopAngle;
        cameraTransform.rotation *= Quaternion.Euler(-extraLookAngle, 0, 0);
    }
}

    Vector3 GetCenterOffset ()
    {
        return centerOffset;
    }

}

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 = 0,
    Walking = 1,
    Trotting = 2,
    Running = 3,
    Jumping = 4,
}

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 = 0;
    forward = forward.normalized;

    // Right vector relative to the camera
    // Always orthogonal to the forward vector
    Vector3 right = new Vector3(forward.z, 0, -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, 1000);

                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(2 * targetJumpHeight * gravity);
}

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

    _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 (0, verticalSpeed, 0) + 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 = 0;
        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) != 0;
}

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";
}

}