3D 主角跟随鼠标转向 主角设置x轴摄像机上也挂一个设置y轴，按下q随机设置天空盒子和光照，主角移动

using UnityEngine;

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 = 0, MouseX = 1, MouseY = 2 }
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 ()
{
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, 0);
}
else if (axes == RotationAxes.MouseX)
{
transform.Rotate(0, Input.GetAxis("Mouse X") * sensitivityX, 0);
}
else
{
rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);

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

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

}

——————————————————————————————————————————————————————

// Fantasy Skybox FREE version: 1.2
// Author: Gold Experience TeamDev (http://www.ge-team.com/)
// Support: [e-mail]
// Please direct any bugs/comments/suggestions to [e-mail]


#region Namespaces


using UnityEngine;
using System.Collections;


#endregion


/***************
* FSPlayer class.
* 
* This class handles
* - Switches the Skybox
* - Updates Directional light
* - Updates Render Settings
* - Responds the Trigger events
* - Shows details on GUIs.
* 
* More info:
* 
* Skybox
* http://docs.unity3d.com/Documentation/Components/class-Skybox.html
*
* How do I Make a Skybox?
* https://docs.unity3d.com/Documentation/Manual/HOWTO-UseSkybox.html
* 
* Render Settings
* http://docs.unity3d.com/Documentation/Components/class-RenderSettings.html
* 
* Directional light
* https://docs.unity3d.com/Documentation/Components/class-Light.html
* 
* Lights
* https://docs.unity3d.com/Documentation/Manual/Lights.html
* 
* Box Collider
* https://docs.unity3d.com/Documentation/Components/class-BoxCollider.html
* 
***************/


/***************
* Fog and Ambient colors reference.
* There are render settings and light preset pictures in Assets/Fantasy Skybox FREE/Presets folder
* 
* FS Night 01A
* Fog Color: 30,50,100,255 Color(0.1176470588235294f,0.196078431372549f,0.392156862745098f,1f)
* Ambient Light: 35,35,35,255 Color(0.1372549019607843f,0.1372549019607843f,0.1372549019607843f,1f)
*
* FS Night 01B
* Fog Color: 20,40,100,255 Color(0.0784313725490196f,0.1568627450980392f,0.392156862745098f,1f)
* Ambient Light: 35,35,35,255 Color(0.1372549019607843f,0.1372549019607843f,0.1372549019607843f,1f)
* 
* FS Sunny 01A
* Fog Color: 110,180,255,255 Color(0.431372549f,0.705882353f,1f,1f)
* Ambient Light: 160,160,170,255 Color(0.62745098f,0.62745098f,0.666666667f,1f)
*
* FS Sunny 01B
* Fog Color: 90,210,255,255 Color(0.352941176f,0.823529412f,1f,1f)
* Ambient Light: 160,180,180,255 Color(0.62745098f,0.705882353f,0.705882353f,1f)
* 
* 
* ***************/


public class FSPlayer : MonoBehaviour
{


#region Variables

// Light
public Light[] m_LightList;

// Skybox
public Material[] m_SkyboxList;

// Fog
Color[] FogColorList;

// Ambient
Color[] AmbientLightList;

// Index to current Skybox
int m_CurrentSkyBox = 0;

#endregion {Variables}

// ######################################################################
// MonoBehaviour Functions
// ######################################################################


#region Component Segments


// Use this for initialization
void Start ()
{
// Init Fog colors array
FogColorList = new Color[4];


// Fog Night
FogColorList[0] = new Color(0.1176470588235294f,0.196078431372549f,0.392156862745098f,1f);
FogColorList[1] = new Color(0.0784313725490196f,0.1568627450980392f,0.392156862745098f,1f);


// Fog Sunny
FogColorList[2] = new Color(0.431372549f,0.705882353f,1f,1f);
FogColorList[3] = new Color(0.352941176f,0.823529412f,1f,1f);


// Init Ambient light colors array
AmbientLightList = new Color[4];


// Ambient Night
AmbientLightList[0] = new Color(0.1372549019607843f,0.1372549019607843f,0.1372549019607843f,1f);
AmbientLightList[1] = new Color(0.1372549019607843f,0.1372549019607843f,0.1372549019607843f,1f);


// Ambient Sunny
AmbientLightList[2] = new Color(0.62745098f,0.705882353f,0.705882353f,1f);
AmbientLightList[3] = new Color(0.705882353f,0.705882353f,0.705882353f,1f);

SwitchSkyBox(0);
}

// Update is called once per frame
void Update ()
{
// User press Q key
if(Input.GetKeyUp(KeyCode.Q))
{
SwitchSkyBox(-1);
}
// User press E key
if(Input.GetKeyUp(KeyCode.E))
{
SwitchSkyBox(+1);
}
}

void OnTriggerExit(Collider other)
{
Debug.Log("OnTriggerExit="+other.name);

// Reset player position when user move it away from terrain
this.transform.localPosition = new Vector3(0,1,0);
    }

// OnGUI is called for rendering and handling GUI events.
void OnGUI () {

// Show version number
GUI.Window(1, new Rect((Screen.width-220), 5, 210, 80), InfoWindow, "Info");

// Show Help GUI window
GUI.Window(2, new Rect((Screen.width-220), Screen.height-85, 210, 80), HelpWindow, string.Format("{0:00}/{1:00}",m_CurrentSkyBox+1, m_SkyboxList.Length) + " (" + m_SkyboxList[m_CurrentSkyBox].name +")");

}

#endregion Component Segments

// ######################################################################
// Functions Functions
// ######################################################################


#region Functions


void SwitchSkyBox(int DiffNum)
{
// update m_CurrentSkyBox
m_CurrentSkyBox += DiffNum;

// rounds m_CurrentSkyBox
if(m_CurrentSkyBox<0)
{
m_CurrentSkyBox = m_SkyboxList.Length-1;
}
if(m_CurrentSkyBox>=m_SkyboxList.Length)
{
m_CurrentSkyBox = 0;
}

// switch skybox
RenderSettings.skybox = m_SkyboxList[m_CurrentSkyBox];

// Set active/deactive lights
for(int i=0;i<m_LightList.Length;i++)
{
if(i==m_CurrentSkyBox)
{
m_LightList[i].gameObject.SetActive(true);
}
else
{
m_LightList[i].gameObject.SetActive(false);
}
}

// Enable fog
RenderSettings.fog = true;

// Set the fog color
if(m_CurrentSkyBox>=0 && m_CurrentSkyBox<FogColorList.Length)
{
RenderSettings.fogColor = FogColorList[m_CurrentSkyBox];
}
else
{
RenderSettings.fogColor = Color.white;
}

// Set the ambient lighting
if(m_CurrentSkyBox>=0 && m_CurrentSkyBox<AmbientLightList.Length)
{
RenderSettings.ambientLight = AmbientLightList[m_CurrentSkyBox];
}
else
{
RenderSettings.ambientLight = Color.white;
}
}


// Show Help window
void HelpWindow(int id)
{
//GUI.Label(new Rect(12, 25, 240, 20), "Skybox: " + string.Format("{0:00}/{1:00}",m_CurrentSkyBox+1, m_SkyboxList.Length) + " (" + m_SkyboxList[m_CurrentSkyBox].name +")");
GUI.Label(new Rect(12, 25, 240, 20), "W/S/A/D: Move player");
GUI.Label(new Rect(12, 50, 240, 20), "Q/E: Switch Skybox");
}


// Show Info window
void InfoWindow(int id)
{
GUI.Label(new Rect(15, 25, 240, 20), "Fantasy Skybox FREE 1.2");
GUI.Label(new Rect(15, 50, 240, 20), "www.ge-team.com/pages");
}


#endregion Functions

——————————————————————————————————————

#pragma strict
#pragma implicit
#pragma downcast


// Does this script currently respond to input?
var canControl : boolean = true;


var useFixedUpdate : boolean = 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
var inputMoveDirection : Vector3 = 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
var inputJump : boolean = false;


class CharacterMotorMovement {
// The maximum horizontal speed when moving
var maxForwardSpeed : float = 10.0;
var maxSidewaysSpeed : float = 10.0;
var maxBackwardsSpeed : float = 10.0;

// Curve for multiplying speed based on slope (negative = downwards)
var slopeSpeedMultiplier : AnimationCurve = AnimationCurve(Keyframe(-90, 1), Keyframe(0, 1), Keyframe(90, 0));

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


// The gravity for the character
var gravity : float = 10.0;
var maxFallSpeed : float = 20.0;

// 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
var collisionFlags : CollisionFlags; 


// We will keep track of the character's current velocity,
@System.NonSerialized
var velocity : Vector3;

// This keeps track of our current velocity while we're not grounded
@System.NonSerialized
var frameVelocity : Vector3 = Vector3.zero;

@System.NonSerialized
var hitPoint : Vector3 = Vector3.zero;

@System.NonSerialized
var lastHitPoint : Vector3 = Vector3(Mathf.Infinity, 0, 0);
}


var movement : CharacterMotorMovement = CharacterMotorMovement();


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.
class CharacterMotorJumping {
// Can the character jump?
var enabled : boolean = true;


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

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

// 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.
var perpAmount : float = 0.0;

// 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.
var steepPerpAmount : float = 0.5;

// 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
var jumping : boolean = false;

@System.NonSerialized
var holdingJumpButton : boolean = false;


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

@System.NonSerialized
var lastButtonDownTime : float = -100;

@System.NonSerialized
var jumpDir : Vector3 = Vector3.up;
}


var jumping : CharacterMotorJumping = CharacterMotorJumping();


class CharacterMotorMovingPlatform {
var enabled : boolean = true;

var movementTransfer : MovementTransferOnJump = MovementTransferOnJump.PermaTransfer;

@System.NonSerialized
var hitPlatform : Transform;

@System.NonSerialized
var activePlatform : Transform;

@System.NonSerialized
var activeLocalPoint : Vector3;

@System.NonSerialized
var activeGlobalPoint : Vector3;

@System.NonSerialized
var activeLocalRotation : Quaternion;

@System.NonSerialized
var activeGlobalRotation : Quaternion;

@System.NonSerialized
var lastMatrix : Matrix4x4;

@System.NonSerialized
var platformVelocity : Vector3;

@System.NonSerialized
var newPlatform : boolean;
}


var movingPlatform : CharacterMotorMovingPlatform = CharacterMotorMovingPlatform();


class CharacterMotorSliding {
// Does the character slide on too steep surfaces?
var enabled : boolean = true;

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

// 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.
var sidewaysControl : float = 1.0;

// 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%.
var speedControl : float = 0.4;
}


var sliding : CharacterMotorSliding = CharacterMotorSliding();


@System.NonSerialized
var grounded : boolean = true;


@System.NonSerialized
var groundNormal : Vector3 = Vector3.zero;


private var lastGroundNormal : Vector3 = Vector3.zero;


private var tr : Transform;


private var controller : CharacterController;


function Awake () {
controller = GetComponent (CharacterController);
tr = transform;
}


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

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

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

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

// Support moving platform rotation as well:
        var newGlobalRotation : Quaternion = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;
        var rotationDiff : Quaternion = 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.
var lastPosition : Vector3 = tr.position;

// We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
var currentMovementOffset : Vector3 = 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.
var pushDownOffset : float = Mathf.Max(controller.stepOffset, 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.
var oldHVelocity : Vector3 = new Vector3(velocity.x, 0, velocity.z);
movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
var newHVelocity : Vector3 = 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 {
var projectedNewVelocity : float = 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.5 + 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; 
}
}


function FixedUpdate () {
if (movingPlatform.enabled) {
if (movingPlatform.activePlatform != null) {
if (!movingPlatform.newPlatform) {
var lastVelocity : Vector3 = 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();
}


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


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

// Find desired velocity
var desiredVelocity : Vector3;
if (grounded && TooSteep()) {
// The direction we're sliding in
desiredVelocity = 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
var maxVelocityChange : float = GetMaxAcceleration(grounded) * Time.deltaTime;
var velocityChangeVector : Vector3 = (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 function ApplyGravityAndJumping (velocity : Vector3) {

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


function OnControllerColliderHit (hit : ControllerColliderHit) {
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 function 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) {
var platform : Transform = movingPlatform.activePlatform;
yield WaitForFixedUpdate();
yield WaitForFixedUpdate();
if (grounded && platform == movingPlatform.activePlatform)
yield 1;
}
movement.velocity -= movingPlatform.platformVelocity;
}
}


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


private function GetDesiredHorizontalVelocity () {
// Find desired velocity
var desiredLocalDirection : Vector3 = tr.InverseTransformDirection(inputMoveDirection);
var maxSpeed : float = 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 function AdjustGroundVelocityToNormal (hVelocity : Vector3, groundNormal : Vector3) : Vector3 {
var sideways : Vector3 = Vector3.Cross(Vector3.up, hVelocity);
return Vector3.Cross(sideways, groundNormal).normalized * hVelocity.magnitude;
}


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


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


function CalculateJumpVerticalSpeed (targetJumpHeight : float) {
// 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);
}


function IsJumping () {
return jumping.jumping;
}


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


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


function IsGrounded () {
return grounded;
}


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


function GetDirection () {
return inputMoveDirection;
}


function SetControllable (controllable : boolean) {
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.
function MaxSpeedInDirection (desiredMovementDirection : Vector3) : float {
if (desiredMovementDirection == Vector3.zero)
return 0;
else {
var zAxisEllipseMultiplier : float = (desiredMovementDirection.z > 0 ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;
var temp : Vector3 = new Vector3(desiredMovementDirection.x, 0, desiredMovementDirection.z / zAxisEllipseMultiplier).normalized;
var length : float = new Vector3(temp.x, 0, temp.z * zAxisEllipseMultiplier).magnitude * movement.maxSidewaysSpeed;
return length;
}
}


function SetVelocity (velocity : Vector3) {
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")