change move controls relative to player

var inAirControlAcceleration = 3.0;

// How high do we jump when pressing jump and letting go immediately var jumpHeight = 0.5; // We add extraJumpHeight meters on top when holding the button down longer while jumping var extraJumpHeight = 2.5;

// The gravity for the character var gravity = 20.0; // The gravity in controlled descent mode var controlledDescentGravity = 2.0; var speedSmoothing = 10.0; var rotateSpeed = 500.0; var trotAfterSeconds = 3.0;

var canJump = true; var canControlDescent = true; var canWallJump = false;

private var jumpRepeatTime = 0.05; private var wallJumpTimeout = 0.15; 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; // Average normal of the last touched geometry private var wallJumpContactNormal : Vector3; private var wallJumpContactNormalHeight : float;

// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.) private var lastJumpStartHeight = 0.0; // When did we touch the wall the first time during this jump (Used for wall jumping) private var touchWallJumpTime = -1.0;

private var inAirVelocity = Vector3.zero;

private var lastGroundedTime = 0.0;

private var lean = 0.0; private var slammed = false;

private var isControllable = true;

function Awake () {

 moveDirection = transform.TransformDirection(Vector3.forward);

}

function UpdateSmoothedMovementDirection () { var cameraTransform = Camera.main.transform; var grounded = IsGrounded();

 // Forward vector relative to the camera along the x-z plane    
 var forward = 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)
 {
     // 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);

// Pick speed modifier if (Input.GetButton ("Fire3")) { targetSpeed = runSpeed; } else if (Time.time - trotAfterSeconds > walkTimeStart) { targetSpeed = trotSpeed; } else { targetSpeed *= walkSpeed; }

     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 () { 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; touchWallJumpTime = -1; lastJumpButtonTime = -10; }

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);
 wallJumpContactNormal = Vector3.zero;
 collisionFlags = controller.Move(movement);


 if (IsGrounded())
 {
     //sets rotation to the move direction
     transform.rotation = Quaternion.LookRotation(moveDirection);

 }   

 // 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; wallJumpContactNormal = hit.normal; }

function GetSpeed () { return moveSpeed; }

function IsJumping () { return jumping && !slammed; }

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

function SuperJump (height : float) { verticalSpeed = CalculateJumpVerticalSpeed (height); collisionFlags = CollisionFlags.None; SendMessage("DidJump", SendMessageOptions.DontRequireReceiver); }

function SuperJump (height : float, jumpVelocity : Vector3) { verticalSpeed = CalculateJumpVerticalSpeed (height); inAirVelocity = jumpVelocity;

 collisionFlags = CollisionFlags.None;
 SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);

}

function Slam (direction : Vector3) { verticalSpeed = CalculateJumpVerticalSpeed (1); inAirVelocity = direction * 6; direction.y = 0.6; Quaternion.LookRotation(-direction); var controller : CharacterController = GetComponent(CharacterController); controller.height = 0.5; slammed = true; collisionFlags = CollisionFlags.None; SendMessage("DidJump", SendMessageOptions.DontRequireReceiver); }

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 IsControlledDescent () { // * When falling down we use controlledDescentGravity (only when holding down jump) var jumpButton = Input.GetButton("Jump"); return canControlDescent && verticalSpeed <= 0.0 && jumpButton && jumping; }