#pragma strict
#pragma implicit
#pragma downcast
<em>// Does this script currently respond to input?</em>
var canControl : boolean = true;
 
var useFixedUpdate : boolean = true;
 
<em>// For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.</em>
<em>// Very handy for organization!</em>
 
<em>// The current global direction we want the character to move in.</em>
@System.NonSerialized
var inputMoveDirection : Vector3 = Vector3.zero;
 
<em>// Is the jump button held down? We use this interface instead of checking</em>
<em>// for the jump button directly so this script can also be used by AIs.</em>
@System.NonSerialized
var inputJump : boolean = false;
 
class CharacterMotorMovement {
<em>// The maximum horizontal speed when moving</em>
var maxForwardSpeed : float = 10.0;
var maxSidewaysSpeed : float = 10.0;
var maxBackwardsSpeed : float = 10.0;
 
<em>// Curve for multiplying speed based on slope (negative = downwards)</em>
var slopeSpeedMultiplier : AnimationCurve = AnimationCurve(Keyframe(-90, 1), Keyframe(0, 1), Keyframe(90, 0));
 
<em>// How fast does the character change speeds?  Higher is faster.</em>
var maxGroundAcceleration : float = 30.0;
var maxAirAcceleration : float = 20.0;
 
<em>// The gravity for the character</em>
var gravity : float = 10.0;
var maxFallSpeed : float = 20.0;
 
<em>// For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.</em>
<em>// Very handy for organization!</em>
 
<em>// The last collision flags returned from controller.Move</em>
@System.NonSerialized
var collisionFlags : CollisionFlags;
 
<em>// We will keep track of the character's current velocity,</em>
@System.NonSerialized
var velocity : Vector3;
 
<em>// This keeps track of our current velocity while we're not grounded</em>
@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, <em>// The jump is not affected by velocity of floor at all.</em>
InitTransfer, <em>// Jump gets its initial velocity from the floor, then gradualy comes to a stop.</em>
PermaTransfer, <em>// Jump gets its initial velocity from the floor, and keeps that velocity until landing.</em>
PermaLocked <em>// Jump is relative to the movement of the last touched floor and will move together with that floor.</em>
}
 
<em>// We will contain all the jumping related variables in one helper class for clarity.</em>
class CharacterMotorJumping {
<em>// Can the character jump?</em>
var enabled : boolean = true;
 
<em>// How high do we jump when pressing jump and letting go immediately</em>
var baseHeight : float = 1.0;
 
<em>// We add extraHeight units (meters) on top when holding the button down longer while jumping</em>
var extraHeight : float = 4.1;
 
<em>// How much does the character jump out perpendicular to the surface on walkable surfaces?</em>
<em>// 0 means a fully vertical jump and 1 means fully perpendicular.</em>
var perpAmount : float = 0.0;
 
<em>// How much does the character jump out perpendicular to the surface on too steep surfaces?</em>
<em>// 0 means a fully vertical jump and 1 means fully perpendicular.</em>
var steepPerpAmount : float = 0.5;
 
<em>// For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.</em>
<em>// Very handy for organization!</em>
 
<em>// Are we jumping? (Initiated with jump button and not grounded yet)</em>
<em>// To see if we are just in the air (initiated by jumping OR falling) see the grounded variable.</em>
@System.NonSerialized
var jumping : boolean = false;
 
@System.NonSerialized
var holdingJumpButton : boolean = false;
 
<em>// the time we jumped at (Used to determine for how long to apply extra jump power after jumping.)</em>
@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 {
<em>// Does the character slide on too steep surfaces?</em>
var enabled : boolean = true;
 
<em>// How fast does the character slide on steep surfaces?</em>
var slidingSpeed : float = 15;
 
<em>// How much can the player control the sliding direction?</em>
<em>// If the value is 0.5 the player can slide sideways with half the speed of the downwards sliding speed.</em>
var sidewaysControl : float = 1.0;
 
<em>// How much can the player influence the sliding speed?</em>
<em>// If the value is 0.5 the player can speed the sliding up to 150% or slow it down to 50%.</em>
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 () {
<em>// We copy the actual velocity into a temporary variable that we can manipulate.</em>
var velocity : Vector3 = movement.velocity;
 
<em>// Update velocity based on input</em>
velocity = ApplyInputVelocityChange(velocity);
 
<em>// Apply gravity and jumping force</em>
velocity = ApplyGravityAndJumping (velocity);
 
<em>// Moving platform support</em>
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);
 
<em>// Support moving platform rotation as well:</em>
var newGlobalRotation : Quaternion = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;
var rotationDiff : Quaternion = newGlobalRotation * Quaternion.Inverse(movingPlatform.activeGlobalRotation);
 
var yRotation = rotationDiff.eulerAngles.y;
if (yRotation != 0) {
<em>// Prevent rotation of the local up vector</em>
tr.Rotate(0, yRotation, 0);
}
}
 
<em>// Save lastPosition for velocity calculation.</em>
var lastPosition : Vector3 = tr.position;
 
<em>// We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.</em>
var currentMovementOffset : Vector3 = velocity * Time.deltaTime;
 
<em>// Find out how much we need to push towards the ground to avoid loosing grouning</em>
<em>// when walking down a step or over a sharp change in slope.</em>
var pushDownOffset : float = Mathf.Max(controller.stepOffset, Vector3(currentMovementOffset.x, 0, currentMovementOffset.z).magnitude);
if (grounded)
currentMovementOffset -= pushDownOffset * Vector3.up;
 
<em>// Reset variables that will be set by collision function</em>
movingPlatform.hitPlatform = null;
groundNormal = Vector3.zero;
 
<em>// Move our character!</em>
movement.collisionFlags = controller.Move (currentMovementOffset);
 
movement.lastHitPoint = movement.hitPoint;
lastGroundNormal = groundNormal;
 
if (movingPlatform.enabled &amp;&amp; movingPlatform.activePlatform != movingPlatform.hitPlatform) {
if (movingPlatform.hitPlatform != null) {
movingPlatform.activePlatform = movingPlatform.hitPlatform;
movingPlatform.lastMatrix = movingPlatform.hitPlatform.localToWorldMatrix;
movingPlatform.newPlatform = true;
}
}
 
<em>// Calculate the velocity based on the current and previous position.  </em>
<em>// This means our velocity will only be the amount the character actually moved as a result of collisions.</em>
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);
 
<em>// The CharacterController can be moved in unwanted directions when colliding with things.</em>
<em>// We want to prevent this from influencing the recorded velocity.</em>
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 &lt; velocity.y - 0.001) {
if (movement.velocity.y &lt; 0) {
<em>// Something is forcing the CharacterController down faster than it should.</em>
<em>// Ignore this</em>
movement.velocity.y = velocity.y;
}
else {
<em>// The upwards movement of the CharacterController has been blocked.</em>
<em>// This is treated like a ceiling collision - stop further jumping here.</em>
jumping.holdingJumpButton = false;
}
}
 
<em>// We were grounded but just loosed grounding</em>
if (grounded &amp;&amp; !IsGroundedTest()) {
grounded = false;
 
<em>// Apply inertia from platform</em>
if (movingPlatform.enabled &amp;&amp;
(movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)
) {
movement.frameVelocity = movingPlatform.platformVelocity;
movement.velocity += movingPlatform.platformVelocity;
}
 
SendMessage("OnFall", SendMessageOptions.DontRequireReceiver);
<em>// We pushed the character down to ensure it would stay on the ground if there was any.</em>
<em>// But there wasn't so now we cancel the downwards offset to make the fall smoother.</em>
tr.position += pushDownOffset * Vector3.up;
}
<em>// We were not grounded but just landed on something</em>
else if (!grounded &amp;&amp; IsGroundedTest()) {
grounded = true;
jumping.jumping = false;
SubtractNewPlatformVelocity();
 
SendMessage("OnLand", SendMessageOptions.DontRequireReceiver);
}
 
<em>// Moving platforms support</em>
if (MoveWithPlatform()) {
<em>// Use the center of the lower half sphere of the capsule as reference point.</em>
<em>// This works best when the character is standing on moving tilting platforms. </em>
movingPlatform.activeGlobalPoint = tr.position + Vector3.up * (controller.center.y - controller.height*0.5 + controller.radius);
movingPlatform.activeLocalPoint = movingPlatform.activePlatform.InverseTransformPoint(movingPlatform.activeGlobalPoint);
 
<em>// Support moving platform rotation as well:</em>
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;
 
<em>// Find desired velocity</em>
var desiredVelocity : Vector3;
if (grounded &amp;&amp; TooSteep()) {
<em>// The direction we're sliding in</em>
desiredVelocity = Vector3(groundNormal.x, 0, groundNormal.z).normalized;
<em>// Find the input movement direction projected onto the sliding direction</em>
var projectedMoveDir = Vector3.Project(inputMoveDirection, desiredVelocity);
<em>// Add the sliding direction, the spped control, and the sideways control vectors</em>
desiredVelocity = desiredVelocity + projectedMoveDir * sliding.speedControl + (inputMoveDirection - projectedMoveDir) * sliding.sidewaysControl;
<em>// Multiply with the sliding speed</em>
desiredVelocity *= sliding.slidingSpeed;
}
else
desiredVelocity = GetDesiredHorizontalVelocity();
 
if (movingPlatform.enabled &amp;&amp; movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer) {
desiredVelocity += movement.frameVelocity;
desiredVelocity.y = 0;
}
 
if (grounded)
desiredVelocity = AdjustGroundVelocityToNormal(desiredVelocity, groundNormal);
else
velocity.y = 0;
 
<em>// Enforce max velocity change</em>
var maxVelocityChange : float = GetMaxAcceleration(grounded) * Time.deltaTime;
var velocityChangeVector : Vector3 = (desiredVelocity - velocity);
if (velocityChangeVector.sqrMagnitude &gt; maxVelocityChange * maxVelocityChange) {
velocityChangeVector = velocityChangeVector.normalized * maxVelocityChange;
}
<em>// If we're in the air and don't have control, don't apply any velocity change at all.</em>
<em>// If we're on the ground and don't have control we do apply it - it will correspond to friction.</em>
if (grounded || canControl)
velocity += velocityChangeVector;
 
if (grounded) {
<em>// When going uphill, the CharacterController will automatically move up by the needed amount.</em>
<em>// Not moving it upwards manually prevent risk of lifting off from the ground.</em>
<em>// When going downhill, DO move down manually, as gravity is not enough on steep hills.</em>
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 &amp;&amp; jumping.lastButtonDownTime &lt; 0 &amp;&amp; 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;
 
<em>// When jumping up we don't apply gravity for some time when the user is holding the jump button.</em>
<em>// This gives more control over jump height by pressing the button longer.</em>
if (jumping.jumping &amp;&amp; jumping.holdingJumpButton) {
<em>// Calculate the duration that the extra jump force should have effect.</em>
<em>// If we're still less than that duration after the jumping time, apply the force.</em>
if (Time.time &lt; jumping.lastStartTime + jumping.extraHeight / CalculateJumpVerticalSpeed(jumping.baseHeight)) {
<em>// Negate the gravity we just applied, except we push in jumpDir rather than jump upwards.</em>
velocity += jumping.jumpDir * movement.gravity * Time.deltaTime;
}
}
 
<em>// Make sure we don't fall any faster than maxFallSpeed. This gives our character a terminal velocity.</em>
velocity.y = Mathf.Max (velocity.y, -movement.maxFallSpeed);
}
 
if (grounded) {
<em>// Jump only if the jump button was pressed down in the last 0.2 seconds.</em>
<em>// We use this check instead of checking if it's pressed down right now</em>
<em>// because players will often try to jump in the exact moment when hitting the ground after a jump</em>
<em>// and if they hit the button a fraction of a second too soon and no new jump happens as a consequence,</em>
<em>// it's confusing and it feels like the game is buggy.</em>
if (jumping.enabled &amp;&amp; canControl &amp;&amp; (Time.time - jumping.lastButtonDownTime &lt; 0.2)) {
grounded = false;
jumping.jumping = true;
jumping.lastStartTime = Time.time;
jumping.lastButtonDownTime = -100;
jumping.holdingJumpButton = true;
 
<em>// Calculate the jumping direction</em>
if (TooSteep())
jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.steepPerpAmount);
else
jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.perpAmount);
 
<em>// Apply the jumping force to the velocity. Cancel any vertical velocity first.</em>
velocity.y = 0;
velocity += jumping.jumpDir * CalculateJumpVerticalSpeed (jumping.baseHeight);
 
<em>// Apply inertia from platform</em>
if (movingPlatform.enabled &amp;&amp;
(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 &gt; 0 &amp;&amp; hit.normal.y &gt; groundNormal.y &amp;&amp; hit.moveDirection.y &lt; 0) {
if ((hit.point - movement.lastHitPoint).sqrMagnitude &gt; 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 () {
<em>// When landing, subtract the velocity of the new ground from the character's velocity</em>
<em>// since movement in ground is relative to the movement of the ground.</em>
if (movingPlatform.enabled &amp;&amp;
(movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)
) {
<em>// If we landed on a new platform, we have to wait for two FixedUpdates</em>
<em>// before we know the velocity of the platform under the character</em>
if (movingPlatform.newPlatform) {
var platform : Transform = movingPlatform.activePlatform;
yield WaitForFixedUpdate();
yield WaitForFixedUpdate();
if (grounded &amp;&amp; platform == movingPlatform.activePlatform)
yield 1;
}
movement.velocity -= movingPlatform.platformVelocity;
}
}
 
private function MoveWithPlatform () : boolean {
return (
movingPlatform.enabled
&amp;&amp; (grounded || movingPlatform.movementTransfer == MovementTransferOnJump.PermaLocked)
&amp;&amp; movingPlatform.activePlatform != null
);
}
 
private function GetDesiredHorizontalVelocity () {
<em>// Find desired velocity</em>
var desiredLocalDirection : Vector3 = tr.InverseTransformDirection(inputMoveDirection);
var maxSpeed : float = MaxSpeedInDirection(desiredLocalDirection);
if (grounded) {
<em>// Modify max speed on slopes based on slope speed multiplier curve</em>
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 &gt; 0.01);
}
 
function GetMaxAcceleration (grounded : boolean) : float {
<em>// Maximum acceleration on ground and in air</em>
if (grounded)
return movement.maxGroundAcceleration;
else
return movement.maxAirAcceleration;
}
 
function CalculateJumpVerticalSpeed (targetJumpHeight : float) {
<em>// From the jump height and gravity we deduce the upwards speed </em>
<em>// for the character to reach at the apex.</em>
return Mathf.Sqrt (2 * targetJumpHeight * movement.gravity);
}
 
function IsJumping () {
return jumping.jumping;
}
 
function IsSliding () {
return (grounded &amp;&amp; sliding.enabled &amp;&amp; TooSteep());
}
 
function IsTouchingCeiling () {
return (movement.collisionFlags &amp; CollisionFlags.CollidedAbove) != 0;
}
 
function IsGrounded () {
return grounded;
}
 
function TooSteep () {
return (groundNormal.y &lt;= Mathf.Cos(controller.slopeLimit * Mathf.Deg2Rad));
}
 
function GetDirection () {
return inputMoveDirection;
}
 
function SetControllable (controllable : boolean) {
canControl = controllable;
}
 
<em>// Project a direction onto elliptical quater segments based on forward, sideways, and backwards speed.</em>
<em>// The function returns the length of the resulting vector.</em>
function MaxSpeedInDirection (desiredMovementDirection : Vector3) : float {
if (desiredMovementDirection == Vector3.zero)
return 0;
else {
var zAxisEllipseMultiplier : float = (desiredMovementDirection.z &gt; 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");
}
 
<em>// Require a character controller to be attached to the same game object</em>
@script RequireComponent (CharacterController)
@script AddComponentMenu ("Character/Character Motor")

private var motor : CharacterMotor;
 
<em>// Use this for initialization</em>
function Awake () {
motor = GetComponent(CharacterMotor);
}
 
<em>// Update is called once per frame</em>
function Update () {
<em>// Get the input vector from kayboard or analog stick</em>
var directionVector = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
 
if (directionVector != Vector3.zero) {
<em>// Get the length of the directon vector and then normalize it</em>
<em>// Dividing by the length is cheaper than normalizing when we already have the length anyway</em>
var directionLength = directionVector.magnitude;
directionVector = directionVector / directionLength;
 
<em>// Make sure the length is no bigger than 1</em>
directionLength = Mathf.Min(1, directionLength);
 
<em>// Make the input vector more sensitive towards the extremes and less sensitive in the middle</em>
<em>// This makes it easier to control slow speeds when using analog sticks</em>
directionLength = directionLength * directionLength;
 
<em>// Multiply the normalized direction vector by the modified length</em>
directionVector = directionVector * directionLength;
}
 
<em>// Apply the direction to the CharacterMotor</em>
motor.inputMoveDirection = transform.rotation * directionVector;
motor.inputJump = Input.GetButton("Jump");
}
 
<em>// Require a character controller to be attached to the same game object</em>
@script RequireComponent (CharacterMotor)
@script AddComponentMenu ("Character/FPS Input Controller")

using UnityEngine;
using System.Collections;
 
<em>/// MouseLook rotates the transform based on the mouse delta.</em>
<em>/// Minimum and Maximum values can be used to constrain the possible rotation</em>
 
<em>/// To make an FPS style character:</em>
<em>/// - Create a capsule.</em>
<em>/// - Add the MouseLook script to the capsule.</em>
<em>///   -&gt; Set the mouse look to use LookX. (You want to only turn character but not tilt it)</em>
<em>/// - Add FPSInputController script to the capsule</em>
<em>///   -&gt; A CharacterMotor and a CharacterController component will be automatically added.</em>
 
<em>/// - Create a camera. Make the camera a child of the capsule. Reset it's transform.</em>
<em>/// - Add a MouseLook script to the camera.</em>
<em>///   -&gt; Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)</em>
[AddComponentMenu("Camera-Control/Mouse Look")]
public class MouseLookClick : 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)
{
if (Input.GetMouseButton (2))
{
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)
{
if (Input.GetMouseButton (2))
{
transform.Rotate (0, Input.GetAxis ("Mouse X") * sensitivityX, 0);
}
}
else
{
if (Input.GetMouseButton (2))
{
rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
 
transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, 0);
}
}
}
 
void Start ()
{
<em>// Make the rigid body not change rotation</em>
if (GetComponent&lt;Rigidbody&gt;())
GetComponent&lt;Rigidbody&gt;().freezeRotation = true;
}
}

if (Input.GetMouseButton (2))

var material : Material;
 
var object : GameObject;
 
function OnMouseDown(){
 
GetComponent.<Renderer>().material = material;
 
}

var Menu : Canvas;
 
function  OnTriggerEnter () {
Menu.enabled = true;
}
 
function OnTriggerExit () {
Menu.enabled = false;
}

var Tree : GameObject;
 
function  Start () {
Tree.enabled = true;
}