Commits

Radiated Pixel e.U.  committed 0e2e2fb

unity project

  • Participants
  • Parent commits 972179f

Comments (0)

Files changed (148)

File 101 things-csharp.sln

+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2008
+
+Project("{051F9DC4-2B53-7000-CA47-F72FA3FA58B4}") = "101 things", "Assembly-CSharp-firstpass-vs.csproj", "{2155EBB1-D419-1CB5-CD97-909E34396122}"
+EndProject
+Project("{051F9DC4-2B53-7000-CA47-F72FA3FA58B4}") = "101 things", "Assembly-CSharp-vs.csproj", "{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+						GlobalSection(MonoDevelopProperties) = preSolution
+		StartupItem = Assembly-CSharp.csproj
+		Policies = $0
+		$0.TextStylePolicy = $1
+		$1.inheritsSet = null
+		$1.scope = text/x-csharp
+		$0.CSharpFormattingPolicy = $2
+		$2.inheritsSet = Mono
+		$2.inheritsScope = text/x-csharp
+		$2.scope = text/x-csharp
+		$0.TextStylePolicy = $3
+		$3.FileWidth = 120
+		$3.TabWidth = 4
+		$3.EolMarker = Unix
+		$3.inheritsSet = Mono
+		$3.inheritsScope = text/plain
+		$3.scope = text/plain
+	EndGlobalSection
+
+EndGlobal

File 101 things-csharp.v11.suo

Binary file added.

File 101 things.sln

+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2008
+
+Project("{051F9DC4-2B53-7000-CA47-F72FA3FA58B4}") = "101 things", "Assembly-CSharp-firstpass.csproj", "{2155EBB1-D419-1CB5-CD97-909E34396122}"
+EndProject
+Project("{051F9DC4-2B53-7000-CA47-F72FA3FA58B4}") = "101 things", "Assembly-CSharp.csproj", "{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}"
+EndProject
+Project("{051F9DC4-2B53-7000-CA47-F72FA3FA58B4}") = "101 things", "Assembly-UnityScript-firstpass.unityproj", "{B13B2CF0-CCF8-2FD9-9E25-13F690DE3D55}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2155EBB1-D419-1CB5-CD97-909E34396122}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BD6BB2D1-BDCB-FE5E-C2C5-61C6DC37B778}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B13B2CF0-CCF8-2FD9-9E25-13F690DE3D55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B13B2CF0-CCF8-2FD9-9E25-13F690DE3D55}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B13B2CF0-CCF8-2FD9-9E25-13F690DE3D55}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B13B2CF0-CCF8-2FD9-9E25-13F690DE3D55}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+					GlobalSection(MonoDevelopProperties) = preSolution
+		StartupItem = Assembly-CSharp.csproj
+		Policies = $0
+		$0.TextStylePolicy = $1
+		$1.inheritsSet = null
+		$1.scope = text/x-csharp
+		$0.CSharpFormattingPolicy = $2
+		$2.inheritsSet = Mono
+		$2.inheritsScope = text/x-csharp
+		$2.scope = text/x-csharp
+		$0.TextStylePolicy = $3
+		$3.FileWidth = 120
+		$3.TabWidth = 4
+		$3.EolMarker = Unix
+		$3.inheritsSet = Mono
+		$3.inheritsScope = text/plain
+		$3.scope = text/plain
+	EndGlobalSection
+
+EndGlobal

File 101 things.userprefs

+<Properties>
+  <MonoDevelop.Ide.Workspace ActiveConfiguration="Debug" />
+  <MonoDevelop.Ide.Workbench ActiveDocument="Assets\101 Things Assets\Scripts\Microphone Input.cs">
+    <Files>
+      <File FileName="Assets\101 Things Assets\Scripts\Microphone Input.cs" Line="7" Column="11" />
+    </Files>
+  </MonoDevelop.Ide.Workbench>
+  <MonoDevelop.Ide.DebuggingService.Breakpoints>
+    <BreakpointStore />
+  </MonoDevelop.Ide.DebuggingService.Breakpoints>
+  <MonoDevelop.Ide.DebuggingService.PinnedWatches />
+</Properties>

File Assets/101 Things Assets/Scenes/audiotest.unity

Binary file added.

File Assets/101 Things Assets/Scripts/MicrophoneInput.cs

+using UnityEngine;
+using System.Collections;
+
+public class MicrophoneInput : MonoBehaviour {
+
+    public float volume;
+    private AudioClip record;
+    public GameObject indicator;
+    private Vector3 scale;
+    private float timeSinceLastUpdate = 0;
+    // Use this for initialization
+    void Start()
+    {
+        volume = 0.0f;
+        Debug.Log("Num Mic Devices: " + Microphone.devices.Length);
+        foreach (string f in Microphone.devices)
+        {
+            Debug.Log(f);
+        }
+        scale = indicator.transform.localScale;
+        audio.clip = Microphone.Start(Microphone.devices[0], true, 999, 44100);
+        while (!(Microphone.GetPosition(Microphone.devices[0]) > 0))
+        {
+
+        } audio.Play();
+    
+    }
+ 
+ // Update is called once per frame
+    void Update()
+    {
+        timeSinceLastUpdate += Time.deltaTime;
+
+            float[] data = new float[735];
+            float comma = Time.realtimeSinceStartup - (int)(Mathf.Floor(Time.realtimeSinceStartup));
+            audio.GetOutputData(data, 0);
+            //record.GetData(data, (int)(comma * 44100));
+            float sum = 0;
+            foreach (float f in data)
+            {
+                sum += Mathf.Abs(f);
+            }
+            sum /= 735f;
+            //Debug.Log(i);
+            indicator.transform.localScale = scale + Vector3.right * sum * 100;
+            volume = sum;
+            Debug.Log(volume);
+    }
+}

File Assets/101 Things Assets/Scripts/controller.cs

+using UnityEngine;
+using System.Collections;
+
+public class controller : MonoBehaviour {
+
+    private const int power = 20;
+
+    private Rigidbody[] rigids;
+    private GameObject player;
+    private MicrophoneInput mic;
+    private float cooldown;
+
+	// Use this for initialization
+	void Start () {
+	    rigids = (Rigidbody[])GameObject.FindObjectsOfType(typeof(Rigidbody));
+        player = GameObject.FindGameObjectWithTag("Player");
+        mic = (MicrophoneInput)GameObject.FindObjectOfType(typeof(MicrophoneInput));
+        cooldown = 0.0f;
+	}
+	
+	// Update is called once per frame
+	void Update () {
+        if (cooldown > 0.0f) { cooldown -= Time.deltaTime; }
+        Debug.Log(cooldown);
+
+        if (cooldown < 0.01f && Mathf.Abs(mic.volume) > 0.01f)
+        {
+            cooldown = 1.0f;
+            foreach (Rigidbody rigid in rigids)
+            {
+                Vector3 direction = rigid.transform.position - player.transform.position;
+                if (direction.magnitude < power)
+                {
+                    rigid.AddForce(direction.normalized * (power - direction.magnitude) * 10 * Mathf.Pow(Mathf.Abs(mic.volume), 2), ForceMode.Impulse);
+                }
+            }
+        }
+	}
+}

File Assets/Standard Assets/Character Controllers/3rd Person Controller.prefab

Binary file added.

File Assets/Standard Assets/Character Controllers/First Person Controller.prefab

Binary file added.

File Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Constructor.FBX

Binary file added.

File Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Materials/constructor_done.mat

Binary file added.

File Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_diffuse.png

Added
New image

File Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_normals.png

Added
New image

File Assets/Standard Assets/Character Controllers/Sources/Scripts/CharacterMotor.js

+#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")

File Assets/Standard Assets/Character Controllers/Sources/Scripts/FPSInputController.js

+private var motor : CharacterMotor;
+
+// Use this for initialization
+function Awake () {
+	motor = GetComponent(CharacterMotor);
+}
+
+// Update is called once per frame
+function Update () {
+	// Get the input vector from kayboard or analog stick
+	var 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");
+}
+
+// Require a character controller to be attached to the same game object
+@script RequireComponent (CharacterMotor)
+@script AddComponentMenu ("Character/FPS Input Controller")

File Assets/Standard Assets/Character Controllers/Sources/Scripts/MouseLook.cs

+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 (rigidbody)
+			rigidbody.freezeRotation = true;
+	}
+}

File Assets/Standard Assets/Character Controllers/Sources/Scripts/PlatformInputController.js

+// This makes the character turn to face the current movement speed per default.
+var autoRotate : boolean = true;
+var maxRotationSpeed : float = 360;
+
+private var motor : CharacterMotor;
+
+// Use this for initialization
+function Awake () {
+	motor = GetComponent(CharacterMotor);
+}
+
+// Update is called once per frame
+function Update () {
+	// Get the input vector from kayboard or analog stick
+	var 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) {
+		var newForward : Vector3 = ConstantSlerp(
+			transform.forward,
+			directionVector,
+			maxRotationSpeed * Time.deltaTime
+		);
+		newForward = ProjectOntoPlane(newForward, transform.up);
+		transform.rotation = Quaternion.LookRotation(newForward, transform.up);
+	}
+}
+
+function ProjectOntoPlane (v : Vector3, normal : Vector3) {
+	return v - Vector3.Project(v, normal);
+}
+
+function ConstantSlerp (from : Vector3, to : Vector3, angle : float) {
+	var value : float = Mathf.Min(1, angle / Vector3.Angle(from, to));
+	return Vector3.Slerp(from, to, value);
+}
+
+// Require a character controller to be attached to the same game object
+@script RequireComponent (CharacterMotor)
+@script AddComponentMenu ("Character/Platform Input Controller")

File Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonCamera.js

+
+
+var cameraTransform : Transform;
+private var _target : Transform;
+
+// The distance in the x-z plane to the target
+
+var distance = 7.0;
+
+// the height we want the camera to be above the target
+var height = 3.0;
+
+var angularSmoothLag = 0.3;
+var angularMaxSpeed = 15.0;
+
+var heightSmoothLag = 0.3;
+
+var snapSmoothLag = 0.2;
+var snapMaxSpeed = 720.0;
+
+var clampHeadPositionScreenSpace = 0.75;
+
+var lockCameraTimeout = 0.2;
+
+private var headOffset = Vector3.zero;
+private var centerOffset = Vector3.zero;
+
+private var heightVelocity = 0.0;
+private var angleVelocity = 0.0;
+private var snap = false;
+private var controller : ThirdPersonController;
+private var targetHeight = 100000.0; 
+
+function 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)
+	{
+		var 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);
+}
+
+function DebugDrawStuff ()
+{
+	Debug.DrawLine(_target.position, _target.position + headOffset);
+
+}
+
+function AngleDistance (a : float, b : float)
+{
+	a = Mathf.Repeat(a, 360);
+	b = Mathf.Repeat(b, 360);
+	
+	return Mathf.Abs(b - a);
+}
+
+function Apply (dummyTarget : Transform, dummyCenter : Vector3)
+{
+	// Early out if we don't have a target
+	if (!controller)
+		return;
+	
+	var targetCenter = _target.position + centerOffset;
+	var targetHead = _target.position + headOffset;
+
+//	DebugDrawStuff();
+
+	// Calculate the current & target rotation angles
+	var originalTargetAngle = _target.eulerAngles.y;
+	var currentAngle = cameraTransform.eulerAngles.y;
+
+	// Adjust real target angle when camera is locked
+	var 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, 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, 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
+		var 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
+	var currentHeight = cameraTransform.position.y;
+	currentHeight = Mathf.SmoothDamp (currentHeight, targetHeight, heightVelocity, heightSmoothLag);
+
+	// Convert the angle into a rotation, by which we then reposition the camera
+	var 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.y = currentHeight;
+	
+	// Always look at the target	
+	SetUpRotation(targetCenter, targetHead);
+}
+
+function LateUpdate () {
+	Apply (transform, Vector3.zero);
+}
+
+function Cut (dummyTarget : Transform, dummyCenter : Vector3)
+{
+	var oldHeightSmooth = heightSmoothLag;
+	var oldSnapMaxSpeed = snapMaxSpeed;
+	var oldSnapSmooth = snapSmoothLag;
+	
+	snapMaxSpeed = 10000;
+	snapSmoothLag = 0.001;
+	heightSmoothLag = 0.001;
+	
+	snap = true;
+	Apply (transform, Vector3.zero);
+	
+	heightSmoothLag = oldHeightSmooth;
+	snapMaxSpeed = oldSnapMaxSpeed;
+	snapSmoothLag = oldSnapSmooth;
+}
+
+function SetUpRotation (centerPos : Vector3, headPos : Vector3)
+{
+	// 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
+	var cameraPos = cameraTransform.position;
+	var offsetToCenter = centerPos - cameraPos;
+	
+	// Generate base rotation only around y-axis
+	var yRotation = Quaternion.LookRotation(Vector3(offsetToCenter.x, 0, offsetToCenter.z));
+
+	var relativeOffset = Vector3.forward * distance + Vector3.down * height;
+	cameraTransform.rotation = yRotation * Quaternion.LookRotation(relativeOffset);
+
+	// Calculate the projected center position and top position in world space
+	var centerRay = cameraTransform.camera.ViewportPointToRay(Vector3(.5, 0.5, 1));
+	var topRay = cameraTransform.camera.ViewportPointToRay(Vector3(.5, clampHeadPositionScreenSpace, 1));
+
+	var centerRayPos = centerRay.GetPoint(distance);
+	var topRayPos = topRay.GetPoint(distance);
+	
+	var centerToTopAngle = Vector3.Angle(centerRay.direction, topRay.direction);
+	
+	var heightToAngle = centerToTopAngle / (centerRayPos.y - topRayPos.y);
+
+	var extraLookAngle = heightToAngle * (centerRayPos.y - centerPos.y);
+	if (extraLookAngle < centerToTopAngle)
+	{
+		extraLookAngle = 0;
+	}
+	else
+	{
+		extraLookAngle = extraLookAngle - centerToTopAngle;
+		cameraTransform.rotation *= Quaternion.Euler(-extraLookAngle, 0, 0);
+	}
+}
+
+function GetCenterOffset ()
+{
+	return centerOffset;
+}

File Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonController.js

+
+// Require a character controller to be attached to the same game object
+@script RequireComponent(CharacterController)
+
+public var idleAnimation : AnimationClip;
+public var walkAnimation : AnimationClip;
+public var runAnimation : AnimationClip;
+public var jumpPoseAnimation : AnimationClip;
+
+public var walkMaxAnimationSpeed : float = 0.75;
+public var trotMaxAnimationSpeed : float = 1.0;
+public var runMaxAnimationSpeed : float = 1.0;
+public var jumpAnimationSpeed : float = 1.15;
+public var landAnimationSpeed : float = 1.0;
+
+private var _animation : Animation;
+
+enum CharacterState {
+	Idle = 0,
+	Walking = 1,
+	Trotting = 2,
+	Running = 3,
+	Jumping = 4,
+}
+
+private var _characterState : CharacterState;
+
+// The speed when walking
+var walkSpeed = 2.0;
+// after trotAfterSeconds of walking we trot with trotSpeed
+var trotSpeed = 4.0;
+// when pressing "Fire3" button (cmd) we start running
+var runSpeed = 6.0;
+
+var inAirControlAcceleration = 3.0;
+
+// How high do we jump when pressing jump and letting go immediately
+var jumpHeight = 0.5;
+
+// The gravity for the character
+var gravity = 20.0;
+// The gravity in controlled descent mode
+var speedSmoothing = 10.0;
+var rotateSpeed = 500.0;
+var trotAfterSeconds = 3.0;
+
+var canJump = true;
+
+private var jumpRepeatTime = 0.05;
+private var jumpTimeout = 0.15;
+private var groundedTimeout = 0.25;
+
+// The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
+private var lockCameraTimer = 0.0;
+
+// The current move direction in x-z
+private var moveDirection = Vector3.zero;
+// The current vertical speed
+private var verticalSpeed = 0.0;
+// The current x-z move speed
+private var moveSpeed = 0.0;
+
+// The last collision flags returned from controller.Move
+private var collisionFlags : CollisionFlags; 
+
+// Are we jumping? (Initiated with jump button and not grounded yet)
+private var jumping = false;
+private var jumpingReachedApex = false;
+
+// Are we moving backwards (This locks the camera to not do a 180 degree spin)
+private var movingBack = false;
+// Is the user pressing any keys?
+private var isMoving = false;
+// When did the user start walking (Used for going into trot after a while)
+private var walkTimeStart = 0.0;
+// Last time the jump button was clicked down
+private var lastJumpButtonTime = -10.0;
+// Last time we performed a jump
+private var lastJumpTime = -1.0;
+
+
+// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
+private var lastJumpStartHeight = 0.0;
+
+
+private var inAirVelocity = Vector3.zero;
+
+private var lastGroundedTime = 0.0;
+
+
+private var isControllable = true;
+
+function 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.");
+	}
+			
+}
+
+
+function UpdateSmoothedMovementDirection ()
+{
+	var cameraTransform = Camera.main.transform;
+	var grounded = IsGrounded();
+	
+	// Forward vector relative to the camera along the x-z plane	
+	var forward = cameraTransform.TransformDirection(Vector3.forward);
+	forward.y = 0;
+	forward = forward.normalized;
+
+	// Right vector relative to the camera
+	// Always orthogonal to the forward vector
+	var right = Vector3(forward.z, 0, -forward.x);
+
+	var v = Input.GetAxisRaw("Vertical");
+	var h = Input.GetAxisRaw("Horizontal");
+
+	// Are we moving backwards or looking backwards
+	if (v < -0.2)
+		movingBack = true;
+	else
+		movingBack = false;
+	
+	var wasMoving = isMoving;
+	isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
+		
+	// Target direction relative to the camera
+	var 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.0;
+
+		// 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.9 && 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
+		var 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
+		var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);
+	
+		_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.3)
+			walkTimeStart = Time.time;
+	}
+	// In air controls
+	else
+	{
+		// Lock camera while in air
+		if (jumping)
+			lockCameraTimer = 0.0;
+
+		if (isMoving)
+			inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
+	}
+	
+
+		
+}
+
+
+function 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);
+		}
+	}
+}
+
+
+function ApplyGravity ()
+{
+	if (isControllable)	// don't move player at all if not controllable.
+	{
+		// Apply gravity
+		var jumpButton = Input.GetButton("Jump");
+		
+		
+		// When we reach the apex of the jump we send out a message
+		if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0)
+		{
+			jumpingReachedApex = true;
+			SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
+		}
+	
+		if (IsGrounded ())
+			verticalSpeed = 0.0;
+		else
+			verticalSpeed -= gravity * Time.deltaTime;
+	}
+}
+
+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 * gravity);
+}
+
+function DidJump ()
+{
+	jumping = true;
+	jumpingReachedApex = false;
+	lastJumpTime = Time.time;
+	lastJumpStartHeight = transform.position.y;
+	lastJumpButtonTime = -10;
+	
+	_characterState = CharacterState.Jumping;
+}
+
+function 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