Problemas con el movimiento del pj

No se porque cuando el personaje esta parado y toco alguna de las teclas de movimiento(en este caso atrás, derecha e izquierda) gira muy rápido como a 180° aprox. Quisiera saber como puedo solucionar esto. Adjunto el script de los movimientos y un vídeo para que vean que pasa. Espero respuestas. Gracias




SCRIPT:


// Requiere un controlador de caracteres que se adjunta al objeto mismo juego
@script RequireComponent(CharacterController)

public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpAnimation : 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;


// La velocidad al caminar
var walkSpeed = 2.0;
// Después de trotar tras unos segundos de caminata llegamos al trote con trotSpeed
var trotSpeed = 4.0;
// Al pulsar "Fire3" botón (cmd) que comienza a correr
var runSpeed = 6.0;

var inAirControlAcceleration = 3.0;

// Qué tan alto que saltemos al pulsar saltar y soltar inmediatamente
var jumpHeight = 0.5;

// La gravedad para el carácter
var gravity = 20.0;
// La gravedad en el modo de descenso controlado
var speedSmoothing = 10.0;
var rotateSpeed = 10.0;
var trotAfterSeconds = 3.0;

var canJump = true;

private var jumpRepeatTime = 0.05;
private var jumpTimeout = 0.15;
private var groundedTimeout = 0.25;

// La cámara no se inicia después de la final de forma inmediata, sino que espera por una fracción de segundo para evitar el exceso ondeando a su alrededor.
private var lockCameraTimer = 0.0;

// La dirección del movimiento actual en x-z
private var moveDirection = Vector3.zero;
// The current vertical speed
private var verticalSpeed = 0.0;
// La velocidad vertical actual
private var moveSpeed = 0.0;

// Las banderas último choque de regresar de controller.Move
private var collisionFlags : CollisionFlags;

// ¿Estamos saltando? (Iniciado con el botón de salto y no conectado a tierra aún)
private var jumping = false;
private var jumpingReachedApex = false;

// ¿Nos estamos moviendo hacia atrás (Esto bloquea la cámara para no hacer un giro de 180 grados)
private var movingBack = false;
// ¿El usuario ha pulsado ninguna tecla?
private var isMoving = false;
// Cuando el usuario se empiezan a caminar (Se utiliza para entrar en trote después de un rato)
private var walkTimeStart = 0.0;
// La última vez que el botón de salto se ha hecho clic abajo
private var lastJumpButtonTime = -10.0;
// La última vez que se realizó un salto
private var lastJumpTime = -1.0;


// La altura que saltó de (utilizado para determinar por cuánto tiempo se debe aplicar potencia de salto adicional después de saltar.)
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(!jumpAnimation && 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();

// Delantero vector con respecto a la cámara a lo largo del plano xz
var forward = cameraTransform.TransformDirection(Vector3.forward);
forward.y = 0;
forward = forward.normalized;

// Relativa vector Derecho a la cámara
// Siempre ortogonal al vector hacia adelante
var right = Vector3(forward.z, 0, -forward.x);

var v = Input.GetAxisRaw("Vertical");
var h = Input.GetAxisRaw("Horizontal");

// ¿Nos estamos moviendo hacia atrás o mirando hacia atrás
if (v < -0.2)
movingBack = true;
else
movingBack = false;

var wasMoving = isMoving;
isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;

// Blanco con respecto a la dirección de la cámara
var targetDirection = h * right + v * forward;

// Controles desde el suelo
if (grounded)
{
// Bloqueo cámara por un período breve durante la transición en movimiento y parado
lockCameraTimer += Time.deltaTime;
if (isMoving != wasMoving)
lockCameraTimer = 0.0;

// Guardamos la velocidad y la dirección por separado,
// Por lo que cuando el personaje se queda quieto todavía tenemos un sentido de avance válida
// MoveDirection se normaliza siempre, y sólo se actualizará si hay entrada del usuario.
if (targetDirection != Vector3.zero)
{
// Si estamos realmente lento, simplemente saca a la dirección de destino
if (moveSpeed < walkSpeed * 0.9 && grounded)
{
moveDirection = targetDirection.normalized;
}
// En caso contrario suavemente gire hacia ella
else
{
moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 10);

moveDirection = moveDirection.normalized;
}
}

// Alise la velocidad en función de la dirección de destino actual
var curSmooth = speedSmoothing * Time.deltaTime;

// Elegir velocidad objetivo
// * Queremos apoyar a la entrada analógica pero asegúrese de que no te puedes caminar más rápido que en diagonal justo delante o hacia los lados
var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);

_characterState = CharacterState.Idle;

// Captura modificador de velocidad
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);

// Cambiar inicio caminata momento en que frenar
if (moveSpeed < walkSpeed * 0.3)
walkTimeStart = Time.time;
}
// En los controles de aire
else
{
// Lock cámara mientras está en el aire
if (jumping)
lockCameraTimer = 0.0;

if (isMoving)
inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
}



}


function ApplyJumping ()
{
// Evitar saltar demasiado rápido después de la otra
if (lastJumpTime + jumpRepeatTime > Time.time)
return;

if (IsGrounded()) {
// Saltar
// - Sólo cuando se presiona el botón
// - Con un tiempo de espera para pulsar ligeramente el botón antes de aterrizar
if (canJump && Time.time < lastJumpButtonTime + jumpTimeout) {
verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);
SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
}
}
}


function ApplyGravity ()
{
if (isControllable) // No se mueven en absoluto jugador si no controlable.
{
// Aplicar gravedad
var jumpButton = Input.GetButton("Jump");


// Cuando se llega a la cima del salto de enviar un mensaje
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)
{
// A partir de la altura del salto y la gravedad se deduce la velocidad hacia arriba
// Para el personaje para llegar a la cima.
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)
{
// Eliminar todas las entradas, si no controlables.
Input.ResetInputAxes();
}

if (Input.GetButtonDown ("Jump"))
{
lastJumpButtonTime = Time.time;
}

UpdateSmoothedMovementDirection();

// Aplicar gravedad
// - Aumento de potencia adicional modifica la gravedad
// - Modo controlledDescent modifica gravedad
ApplyGravity ();

// Aplicar la lógica salta
ApplyJumping ();

// Calcular el movimiento real
var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;
movement *= Time.deltaTime;

// Mover el controlador
var controller : CharacterController = GetComponent(CharacterController);
collisionFlags = controller.Move(movement);

// ANIMATION sector
if(_animation) {
if(_characterState == CharacterState.Jumping)
{
if(!jumpingReachedApex) {
_animation[jumpAnimation.name].speed = jumpAnimationSpeed;
_animation[jumpAnimation.name].wrapMode = WrapMode.ClampForever;
_animation.CrossFade(jumpAnimation.name);
} else {
_animation[jumpAnimation.name].speed = -landAnimationSpeed;
_animation[jumpAnimation.name].wrapMode = WrapMode.ClampForever;
_animation.CrossFade(jumpAnimation.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

// Establecer la rotación a la dirección de movimiento
if (IsGrounded())
{

transform.rotation = Quaternion.LookRotation(moveDirection);

}
else
{
var xzMove = movement;
xzMove.y = 0;
if (xzMove.sqrMagnitude > 0.001)
{
transform.rotation = Quaternion.LookRotation(xzMove);
}
}

// Estamos en modo de salto, pero sólo se convirtió en tierra
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";
}