// Does this script currently respond to Input?
var canControl = true;

// The character will spawn at spawnPoint's position when needed.  This could be changed via a script at runtime to implement, e.g. waypoints/savepoints.
var spawnPoint : Transform;

class PlatformerControllerMovement {
  // The speed when walking  
  var walkSpeed = 3.0;
  // when pressing "Fire1" button (control) we start running
  var runSpeed = 10.0;

  var inAirControlAcceleration = 1.0;

  // The gravity for the character
  var gravity = 60.0;
  var maxFallSpeed = 20.0;

  // How fast does the character change speeds?  Higher is faster.
  var speedSmoothing = 5.0;

  // This controls how fast the graphics of the character "turn around" when the player turns around using the controls.
  var rotationSmoothing = 10.0;

  // The current move direction in x-y.  This will always been (1,0,0) or (-1,0,0)
  // The next line, @System.NonSerialized , tells Unity to not serialize the variable or show it in the inspector view.  Very handy for organization!
  @System.NonSerialized
  var direction = Vector3.zero;

  // The current vertical speed
  @System.NonSerialized
  var verticalSpeed = 0.0;

  // The current movement speed.  This gets smoothed by speedSmoothing.
  @System.NonSerialized
  var speed = 0.0;

  // Is the user pressing the left or right movement keys?
  @System.NonSerialized
  var isMoving = false;

  // The last collision flags returned from controller.Move
  @System.NonSerialized
  var collisionFlags : CollisionFlags;  

  // We will keep track of an approximation of the character's current velocity, so that we return it from GetVelocity () for our camera to use for prediction.
  @System.NonSerialized
  var velocity : Vector3;
   
  // This keeps track of our current velocity while we're not grounded?
  @System.NonSerialized
  var inAirVelocity = Vector3.zero;

  // This will keep track of how long we have we been in the air (not grounded)
  @System.NonSerialized
  var hangTime = 0.0;
}

var movement : PlatformerControllerMovement;

// We will contain all the jumping related variables in one helper class for clarity.
class PlatformerControllerJumping {
  // Can the character jump?
  var enabled = true;

  // How high do we jump when pressing jump and letting go immediately
  var height = 1.0;
  // We add extraHeight units (meters) on top when holding the button down longer while jumping
  var extraHeight = 4.1;
   
  // This prevents inordinarily too quick jumping
  // The next line, @System.NonSerialized , tells Unity to not serialize the variable or show it in the inspector view.  Very handy for organization!
  @System.NonSerialized
  var repeatTime = 0.05;

  @System.NonSerialized
  var timeout = 0.15;

  // Are we jumping? (Initiated with jump button and not grounded yet)
  @System.NonSerialized
  var jumping = false;
   
  @System.NonSerialized
  var reachedApex = false;
    
  // Last time the jump button was clicked down
  @System.NonSerialized
  var lastButtonTime = -10.0;
   
  // Last time we performed a jump
  @System.NonSerialized
  var lastTime = -1.0;

  // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
  @System.NonSerialized
  var lastStartHeight = 0.0;
}

var jump : PlatformerControllerJumping;

private var controller : CharacterController;

// Moving platform support.
private var activePlatform : Transform;
private var activeLocalPlatformPoint : Vector3;
private var activeGlobalPlatformPoint : Vector3;
private var lastPlatformVelocity : Vector3;

// This is used to keep track of special effects in UpdateEffects ();
private var areEmittersOn = false;

function Awake () {
  movement.direction = transform.TransformDirection (Vector3.forward);
  controller = GetComponent (CharacterController);
  Spawn ();
}

function Spawn () {
  // reset the character's speed
  movement.verticalSpeed = 0.0;
  movement.speed = 0.0;
   
  // reset the character's position to the spawnPoint
  transform.position = spawnPoint.position;
   
}

function OnDeath () {
  Spawn ();
}

function UpdateSmoothedMovementDirection () {  
  var h = Input.GetAxisRaw ("Horizontal");
   
  if (!canControl)
   h = 0.0;
   
  movement.isMoving = Mathf.Abs (h) > 0.1;
    
  if (movement.isMoving)
   movement.direction = Vector3 (h, 0, 0);
   
  // Grounded controls
  if (controller.isGrounded) {
   // Smooth the speed based on the current target direction
   var curSmooth = movement.speedSmoothing * Time.deltaTime;
    
   // Choose target speed
   var targetSpeed = Mathf.Min (Mathf.Abs(h), 1.0);
   
   // Pick speed modifier
   if (Input.GetButton ("Fire2") && canControl)
    targetSpeed *= movement.runSpeed;
   else
    targetSpeed *= movement.walkSpeed;
    
   movement.speed = Mathf.Lerp (movement.speed, targetSpeed, curSmooth);
    
   movement.hangTime = 0.0;
  }
  else {
   // In air controls
   movement.hangTime += Time.deltaTime;
   if (movement.isMoving)
    movement.inAirVelocity += Vector3 (Mathf.Sign(h), 0, 0) * Time.deltaTime * movement.inAirControlAcceleration;
  }
}

function FixedUpdate () {
  // Make sure we are absolutely always in the 2D plane.
  transform.position.z = 0;

}

function ApplyJumping () {
  // Prevent jumping too fast after each other
  if (jump.lastTime + jump.repeatTime > Time.time)
   return;

  if (controller.isGrounded) {
   // Jump
   // - Only when pressing the button down
   // - With a timeout so you can press the button slightly before landing   
   if (jump.enabled && Time.time < jump.lastButtonTime + jump.timeout) {
    movement.verticalSpeed = CalculateJumpVerticalSpeed (jump.height);
    movement.inAirVelocity = lastPlatformVelocity;
    SendMessage ("DidJump", SendMessageOptions.DontRequireReceiver);
   }
  }
}

function ApplyGravity () {
  // Apply gravity
  var jumpButton = Input.GetButton ("Jump");
   
  if (!canControl)
   jumpButton = false;
   
  // When we reach the apex of the jump we send out a message
  if (jump.jumping && !jump.reachedApex && movement.verticalSpeed <= 0.0) {
   jump.reachedApex = true;
   SendMessage ("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
  }
   
  // * 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
  var extraPowerJump =  jump.jumping && movement.verticalSpeed > 0.0 && jumpButton && transform.position.y < jump.lastStartHeight + jump.extraHeight && !IsTouchingCeiling ();
   
  if (extraPowerJump)
   return;
  else if (controller.isGrounded)
   movement.verticalSpeed = -movement.gravity * Time.deltaTime;
  else
   movement.verticalSpeed -= movement.gravity * Time.deltaTime;
    
  // Make sure we don't fall any faster than maxFallSpeed.  This gives our character a terminal velocity.
  movement.verticalSpeed = Mathf.Max (movement.verticalSpeed, -movement.maxFallSpeed);
}

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 DidJump () {
  jump.jumping = true;
  jump.reachedApex = false;
  jump.lastTime = Time.time;
  jump.lastStartHeight = transform.position.y;
  jump.lastButtonTime = -10;
}

function UpdateEffects () {
  wereEmittersOn = areEmittersOn;
  areEmittersOn = jump.jumping && movement.verticalSpeed > 0.0;
   
  // By comparing the previous value of areEmittersOn to the new one, we will only update the particle emitters when needed
  if (wereEmittersOn != areEmittersOn) {
   for (var emitter in GetComponentsInChildren (ParticleEmitter)) {
    emitter.emit = areEmittersOn;
   }
  }
}

function Update () {
  if (Input.GetButtonDown ("Jump") && canControl) {
   jump.lastButtonTime = Time.time;
  }

  UpdateSmoothedMovementDirection();
   
  // Apply gravity
  // - extra power jump modifies gravity
  ApplyGravity ();

  // Apply jumping logic
  ApplyJumping ();
   
  // Moving platform support
  if (activePlatform != null) {
   var newGlobalPlatformPoint = activePlatform.TransformPoint(activeLocalPlatformPoint);
   var moveDistance = (newGlobalPlatformPoint - activeGlobalPlatformPoint);
   transform.position = transform.position + moveDistance;
   lastPlatformVelocity = (newGlobalPlatformPoint - activeGlobalPlatformPoint) / Time.deltaTime;
  } else {
   lastPlatformVelocity = Vector3.zero;  
  }
   
  activePlatform = null;
   
  // Save lastPosition for velocity calculation.
  lastPosition = transform.position;
   
  // Calculate actual motion
  var currentMovementOffset = movement.direction * movement.speed + Vector3 (0, movement.verticalSpeed, 0) + movement.inAirVelocity;
   
  // We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
  currentMovementOffset *= Time.deltaTime;
   
     // Move our character!
  movement.collisionFlags = controller.Move (currentMovementOffset);
   
  // 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.
  movement.velocity = (transform.position - lastPosition) / Time.deltaTime;
   
  // Moving platforms support
  if (activePlatform != null) {
   activeGlobalPlatformPoint = transform.position;
   activeLocalPlatformPoint = activePlatform.InverseTransformPoint (transform.position);
  }
   
  // Set rotation to the move direction  
  if (movement.direction.sqrMagnitude > 0.01)
   transform.rotation = Quaternion.Slerp (transform.rotation, Quaternion.LookRotation (movement.direction), Time.deltaTime * movement.rotationSmoothing);
   
  // We are in jump mode but just became grounded
  if (controller.isGrounded) {
   movement.inAirVelocity = Vector3.zero;
   if (jump.jumping) {
    jump.jumping = false;
    SendMessage ("DidLand", SendMessageOptions.DontRequireReceiver);

    var jumpMoveDirection = movement.direction * movement.speed + movement.inAirVelocity;
    if (jumpMoveDirection.sqrMagnitude > 0.01)
     movement.direction = jumpMoveDirection.normalized;
   }
  }  

  // Update special effects like rocket pack particle effects
  UpdateEffects ();
}

function OnControllerColliderHit (hit : ControllerColliderHit)
{
  if (hit.moveDirection.y > 0.01)  
   return;
   
  // Make sure we are really standing on a straight platform
  // Not on the underside of one and not falling down from it either!
  if (hit.moveDirection.y < -0.9 && hit.normal.y > 0.9) {
   activePlatform = hit.collider.transform;  
  }
}

// Various helper functions below:
function GetSpeed () {
  return movement.speed;
}

function GetVelocity () {
  return movement.velocity;
}

function IsMoving () {
  return movement.isMoving;
}

function IsJumping () {
  return jump.jumping;
}

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

function GetDirection () {
  return movement.direction;
}

function GetHangTime() {
  return movement.hangTime;
}

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

function SetControllable (controllable : boolean) {
  canControl = controllable;
}

// Require a character controller to be attached to the same game object
@script RequireComponent (CharacterController)
@script AddComponentMenu ("2D Platformer/Platformer Controller")