NullReferenceException: Object reference not set to an instance of an object

I fixed the camera on my third person character Now I'm trying to put a third person controller script on the camera as it required. I found the "Null" references but i don't know what to change them to. I would like to know how to fix it but more importantly WHY this is happening. Is there a video somewhere? Here's the Javascript

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
 ApplyJumping ();
 
 // Calculate actual motion
 var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;
 movement *= Time.deltaTime;
 
 // Move the controller
 var controller : CharacterController = GetComponent(CharacterController);
 collisionFlags = controller.Move(movement);
 
 // ANIMATION sector
 if(_animation) {
     if(_characterState == CharacterState.Jumping) 
     {
         if(!jumpingReachedApex) {
             _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
             _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
             _animation.CrossFade(jumpPoseAnimation.name);
         } else {
             _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
             _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
             _animation.CrossFade(jumpPoseAnimation.name);                
         }
     } 
     else 
     {
         if(controller.velocity.sqrMagnitude < 0.1) {
             _animation.CrossFade(idleAnimation.name);
         }
         else 
         {
             if(_characterState == CharacterState.Running) {
                 _animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
                 _animation.CrossFade(runAnimation.name);    
             }
             else if(_characterState == CharacterState.Trotting) {
                 _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed);
                 _animation.CrossFade(walkAnimation.name);    
             }
             else if(_characterState == CharacterState.Walking) {
                 _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);
                 _animation.CrossFade(walkAnimation.name);    
             }
             
         }
     }
 }
 // ANIMATION sector
 
 // Set rotation to the move direction
 if (IsGrounded())
 {
     
     transform.rotation = Quaternion.LookRotation(moveDirection);
         
 }    
 else
 {
     var xzMove = movement;
     xzMove.y = 0;
     if (xzMove.sqrMagnitude > 0.001)
     {
         transform.rotation = Quaternion.LookRotation(xzMove);
     }
 }    
 
 // We are in jump mode but just became grounded
 if (IsGrounded())
 {
     lastGroundedTime = Time.time;
     inAirVelocity = Vector3.zero;
     if (jumping)
     {
         jumping = false;
         SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
     }
 }

}

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

function GetSpeed () { return moveSpeed; }

function IsJumping () { return jumping; }

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

function GetDirection () { return moveDirection; }

function IsMovingBackwards () { return movingBack; }

function GetLockCameraTimer () { return lockCameraTimer; }

function IsMoving () : boolean { return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5; }

function HasJumpReachedApex () { return jumpingReachedApex; }

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

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