context: using UnityEngine;
  using System.Collections;
  using System.Collections.Generic;
  
  [RequireComponent(typeof(CharacterController))]
  [AddComponentMenu("Character/Character Motor")]
  
  
  public class CharacterMotor : MonoBehaviour
  {
      bool isInputEnabled = true;
      bool useFixedUpdate = true;
  	
  	public class CharacterMotorInput{
  		public Vector3 direction = Vector3.zero;
  		public bool jump = false;
  		public bool gravityOff = false;
  	}
  	public CharacterMotorInput input=new CharacterMotorInput();
  
      [System.Serializable]
      public class CharacterMotorMovement
      {
          // The maximum horizontal speed when moving
          public float maxForwardSpeed = 3.0f;
          public float maxSidewaysSpeed = 2.0f;
          public float maxBackwardsSpeed = 2.0f;
  
          // Curve for multiplying speed based on slope(negative = downwards)
          public AnimationCurve slopeSpeedMultiplier = new AnimationCurve(new Keyframe(-90, 1), new Keyframe(0, 1), new Keyframe(90, 0));
  
          // How fast does the character change speeds?  Higher is faster.
          public float maxGroundAcceleration = 30.0f;
          public float maxAirAcceleration = 20.0f;
  		
  		//Air acceleration variables for lo-gravity code
  		public float maxGravityAirAcceleration = 20.0f;
  		public float maxNoGravityAirAcceleration = 20.0f;
  		
  
          // The gravity for the character
  		[System.NonSerialized]
          public float gravity = 9.81f;
  		[System.NonSerialized]
  		public float regularGravity = 9.81f;
  		
          public float maxFallSpeed = 20.0f;
  		
          // The last collision flags returned from controller.Move
          [System.NonSerialized]
          public CollisionFlags collisionFlags;
  		
          [System.NonSerialized]
          public Vector3 velocity;
  
          // This keeps track of our current velocity while we're not grounded
          [System.NonSerialized]
          public Vector3 frameVelocity = Vector3.zero;
  
          [System.NonSerialized]
          public Vector3 hitPoint = Vector3.zero;
  
          [System.NonSerialized]
          public Vector3 lastHitPoint = new Vector3(Mathf.Infinity, 0, 0);
      }
  
      public CharacterMotorMovement movement = new CharacterMotorMovement();
  
      public 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.
      }
  	
      [System.Serializable]
      public class CharacterMotorJumping
      {
          public bool enabled = true;
          public float minHeight = 1.0f;
          public float maxHeight = 4.1f;
  
          // 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.
          public float perpAmount = 0.0f;
  
          // 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.
          public float steepPerpAmount = 0.5f;
  		
  		[System.NonSerialized]
          public bool jumping = false;
  
          [System.NonSerialized]
          public bool holdingJumpButton = false;
  
          // the time we jumped at(Used to determine for how long to apply extra jump power after jumping.)
          [System.NonSerialized]
          public float lastStartTime = 0.0f;
  
          [System.NonSerialized]
          public float lastButtonDownTime = -100.0f;
  
          [System.NonSerialized]
          public Vector3 jumpDir = Vector3.up;
      }
      public CharacterMotorJumping jumping = new CharacterMotorJumping();
  
      [System.Serializable]
      public class CharacterMotorMovingPlatform
      {
          public bool enabled = true;
  
          public MovementTransferOnJump movementTransfer = MovementTransferOnJump.PermaTransfer;
  
          [System.NonSerialized]
          public Transform hitPlatform;
  
          [System.NonSerialized]
          public Transform activePlatform;
  
          [System.NonSerialized]
          public Vector3 activeLocalPoint;
  
          [System.NonSerialized]
          public Vector3 activeGlobalPoint;
  
          [System.NonSerialized]
          public Quaternion activeLocalRotation;
  
          [System.NonSerialized]
          public Quaternion activeGlobalRotation;
  
          [System.NonSerialized]
          public Matrix4x4 lastMatrix;
  
          [System.NonSerialized]
          public Vector3 platformVelocity;
  
          [System.NonSerialized]
          public bool newPlatform;
      }
  
      public CharacterMotorMovingPlatform movingPlatform = new CharacterMotorMovingPlatform();
  
      [System.Serializable]
      public class CharacterMotorSliding
      {
          // Does the character slide on too steep surfaces?
          public bool enabled = true;
  
          // How fast does the character slide on steep surfaces?
          public float slidingSpeed = 15.0f;
  
          // How much can the player control the sliding direction?
          // ifthe value is 0.5 the player can slide sideways with half the speed of the downwards sliding speed.
          public float sidewaysControl = 1.0f;
  
          // How much can the player influence the sliding speed?
          // ifthe value is 0.5 the player can speed the sliding up to 150% or slow it down to 50%.
          public float speedControl = 0.4f;
      }
      public CharacterMotorSliding sliding = new CharacterMotorSliding();
  
      [System.NonSerialized]
      public bool grounded = true;
  
      [System.NonSerialized]
      public Vector3 groundNormal = Vector3.zero;
  	
      private Vector3 lastGroundNormal = Vector3.zero;
      public Transform tr;
      private CharacterController controller;
  	
  	[System.NonSerialized]
  	public GameObject lastFloorGameObject;
  	
      void Awake()
      {
          controller = GetComponent<CharacterController>();
          tr = transform;
      }
  	
  	private void ApplyMovingPlatform(){
          if(!MoveWithPlatform())
  			return;
  		
          Vector3 moveDistance = Vector3.zero;
              Vector3 newGlobalPoint = movingPlatform.activePlatform.TransformPoint(movingPlatform.activeLocalPoint);
              moveDistance = (newGlobalPoint - movingPlatform.activeGlobalPoint);
              if(moveDistance != Vector3.zero)
                  controller.Move(moveDistance);
  
              // Support moving platform rotation as well:
              Quaternion newGlobalRotation = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;
              Quaternion rotationDiff = 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);
              }
          
  	}
  	
  	private void ApplyGroundedUpdate(float pushDownOffset){
  		        // 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 ifthere 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);
          }
  	}
  	
      private void UpdateFunction()
      {
          // We copy the actual velocity into a temporary variable that we can manipulate.
          Vector3 velocity = movement.velocity;
  		
  		updateGravity();
  		
          // Update velocity based on input
          velocity = ApplyInputVelocityChange(velocity);
  
          // Apply gravity and jumping force
          velocity = ApplyGravityAndJumping(velocity);
  
          ApplyMovingPlatform();
  
          // Save lastPosition for velocity calculation.
          Vector3 lastPosition = tr.position;
  
          // We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
          Vector3 currentMovementOffset = 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.
          float pushDownOffset = Mathf.Max(controller.stepOffset, new 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.
          Vector3 oldHVelocity = new Vector3(velocity.x, 0, velocity.z);
          movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
          Vector3 newHVelocity = 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
          {
              float projectedNewVelocity = 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;
              }
          }
  		
  		ApplyGroundedUpdate(pushDownOffset);
  
  
          // 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.5f + 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;
  		}
      }
  	
      void FixedUpdate()
      {
          if(movingPlatform.enabled)
          {
              if(movingPlatform.activePlatform != null)
              {
                  if(!movingPlatform.newPlatform)
                  {
                      // unused: Vector3 lastVelocity = 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();
      }
  
      void Update()
      {
          if(!useFixedUpdate)
              UpdateFunction();
      }
  
      private Vector3 ApplyInputVelocityChange(Vector3 velocity)
      {
          if(!isInputEnabled)
              input.direction = Vector3.zero;
  
          // Find desired velocity
          Vector3 desiredVelocity;
          if(grounded && TooSteep())
          {
              // The direction we're sliding in
              desiredVelocity = new Vector3(groundNormal.x, 0, groundNormal.z).normalized;
              // Find the input movement direction projected onto the sliding direction
              var projectedMoveDir = Vector3.Project(input.direction, desiredVelocity);
              // Add the sliding direction, the spped control, and the sideways control vectors
              desiredVelocity = desiredVelocity + projectedMoveDir * sliding.speedControl + (input.direction - 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
          float maxVelocityChange = GetMaxAcceleration(grounded) * Time.deltaTime;
          Vector3 velocityChangeVector = (desiredVelocity - velocity);
          if(velocityChangeVector.sqrMagnitude > maxVelocityChange * maxVelocityChange)
          {
              velocityChangeVector = velocityChangeVector.normalized * maxVelocityChange;
          }
          // ifwe're in the air and don't have control, don't apply any velocity change at all.
          // ifwe're on the ground and don't have control we do apply it - it will correspond to friction.
          if(grounded || isInputEnabled)
              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 Vector3 ApplyGravityAndJumping(Vector3 velocity)
      {
  
          if(!input.jump || !isInputEnabled)
          {
              jumping.holdingJumpButton = false;
              jumping.lastButtonDownTime = -100;
          }
  
          if(input.jump && jumping.lastButtonDownTime < 0 && isInputEnabled){
              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.
                  // ifwe're still less than that duration after the jumping time, apply the force.
                  if(Time.time < jumping.lastStartTime + jumping.maxHeight / CalculateJumpVerticalSpeed(jumping.minHeight))
                  {
                      // 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 ifthe jump button was pressed down in the last 0.2 seconds.
              // We use this check instead of checking ifit's pressed down right now
              // because players will often try to jump in the exact moment when hitting the ground after a jump
              // and ifthey 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 && isInputEnabled && (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.minHeight);
  
                  // 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;
      }
  
      private void OnControllerColliderHit(ControllerColliderHit hit)
      {
          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;
  				lastFloorGameObject=hit.gameObject;
  			}else{
                  groundNormal = lastGroundNormal;
  			}
  			
              movingPlatform.hitPlatform = hit.collider.transform;
              movement.hitPoint = hit.point;
              movement.frameVelocity = Vector3.zero;
  			
  
          }
      }
  
      private IEnumerator 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)
              {
                  Transform platform = movingPlatform.activePlatform;
                  yield return new WaitForFixedUpdate();
                  yield return new WaitForFixedUpdate();
                  if(grounded && platform == movingPlatform.activePlatform)
                      yield break;
              }
              movement.velocity -= movingPlatform.platformVelocity;
          }
      }
  
      private bool MoveWithPlatform()
      {
          return (movingPlatform.enabled
              && (grounded || movingPlatform.movementTransfer == MovementTransferOnJump.PermaLocked)
              && movingPlatform.activePlatform != null
          );
      }
  
      private Vector3 GetDesiredHorizontalVelocity()
      {
          // Find desired velocity
          Vector3 desiredLocalDirection = tr.InverseTransformDirection(input.direction);
          float maxSpeed = 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 Vector3 AdjustGroundVelocityToNormal(Vector3 hVelocity, Vector3 groundNormal)
      {
          Vector3 sideways = Vector3.Cross(Vector3.up, hVelocity);
          return Vector3.Cross(sideways, groundNormal).normalized * hVelocity.magnitude;
      }
  
      private bool IsGroundedTest()
      {
  
gt:         return (groundNormal.y > 0.01);