using System;
using System.Timers;
using UnityEngine;
using System.Collections;

public class Move : MonoBehaviour
{

      public float speed;
      public float fallSpeed = 1;
      public bool isGrounded = false;

      private Transform camera, player, mesh;
      private SphereCollider sphereCollider;
      private Transform myTrans;
      private Vector3 direction;
      private CharacterController controller;
      private Vector3 rotVect;
      private float Yjump;
        

   // Use this for initialization
   void Start ()
   {
       direction = Vector3.zero;
       speed = speed == 0 ? 10:speed;
       camera = GameObject.FindGameObjectWithTag("Camera").transform;
       player = GameObject.FindGameObjectWithTag("Player").transform;
          mesh = GameObject.FindGameObjectWithTag("Mesh").transform;
       sphereCollider = gameObject.GetComponent<SphereCollider>();
       myTrans = transform;
       controller = this.gameObject.GetComponent<CharacterController>();
   }
     
   // Update is called once per frame
   void Update ()
   {
       direction = Vector3.zero;

       if (Input.GetKey(KeyCode.W))
       {
           direction += camera.forward;
           direction.y = 0;
       }

          if (Input.GetKey(KeyCode.S))
          {
              direction += -camera.forward;
              direction.y = 0;
          }

          if (Input.GetKey(KeyCode.D))
          {
              direction += camera.right;
              direction.y = 0;   
          }

          if (Input.GetKey(KeyCode.A))
          {
              direction += -camera.right;
              direction.y = 0;
          }

       if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.D))
       {
           mesh.forward = direction.normalized;
           controller.Move(direction.normalized*speed*Time.deltaTime);
             // myTrans.Translate(direction.normalized * speed * Time.deltaTime);
       }
          Debug.Log(controller.isGrounded);
   }

      void FixedUpdate()
      {
          if (Input.GetKeyDown(KeyCode.Space))
          {
              if (isGrounded)//controller.isGrounded)
                  Yjump = 1f;
          }

          if (Yjump != 0 || Yjump>0)
          {     
              controller.Move(myTrans.up*Yjump);
              Yjump -= Time.deltaTime;
              if (Yjump < 0)
                  Yjump = 0;
          }

          if (!isGrounded)
          {
              fallSpeed += 0.5f;
              controller.Move(Vector3.down * Time.deltaTime * fallSpeed);
          }
      }

      void OnTriggerEnter(Collider other)
      {
          if (other.tag == "Ground")
          {
              isGrounded = true;
                  Yjump = 0;
                  fallSpeed = 0;
              Debug.Log("grounded from enter");
          }
      }

      void OnTriggerExit(Collider other)
      {
          if (other.tag == "Ground")
          {
              isGrounded = false;
              Debug.Log("ungrounded!");
          }
      }

      void OnTriggerStay(Collider other)
      {
          if (other.tag == "Ground")
          {
              isGrounded = true;
              Debug.Log("grounded from stay");
          }
      }
}

void OnTriggerStay(Collider other)
      {
          if (other.tag == "Ground")
          {
              isGrounded = true;
              Debug.Log("grounded from stay");
          }
      }

void FixedUpdate()  
       {  
           if (Input.GetKeyDown(KeyCode.Space))  
           {  
               if (isGrounded)//controller.isGrounded)  
                   Yjump = 1f;  
           }  

           if (Yjump != 0 || Yjump>0)  
           {      
               controller.Move(myTrans.up*Yjump);  
               Yjump -= Time.deltaTime;  
               if (Yjump < 0)  
                   Yjump = 0;  
           }  

           if (!isGrounded)  
           {  
               fallSpeed += 0.5f;  
               controller.Move(Vector3.down * Time.deltaTime * fallSpeed);  
           }  
       }  

       void OnTriggerEnter(Collider other)  
       {  
           if (other.tag == "Ground")  
           {  
               isGrounded = true;  
                   Yjump = 0;  
                   fallSpeed = 0;  
               Debug.Log("grounded from enter");  
           }  
       }  

       void OnTriggerExit(Collider other)  
       {  
           if (other.tag == "Ground")  
           {  
               isGrounded = false;  
               Debug.Log("ungrounded!");  
           }  
       }  

       void OnTriggerStay(Collider other)  
       {  
           if (other.tag == "Ground")  
           {  
               isGrounded = true;  
               Debug.Log("grounded from stay");  
           }  
       }  
}

var ground : boolean = true;

function OnTriggerStay (hit : Collider) {
      if (hit.tag == "Floor")  ground = true;
}   
function OnTriggerExit (hit : Collider) {
      if (hit.tag == "Floor")  ground = false;
}

using UnityEngine;
using System.Collections;
   
[RequireComponent (typeof (CharacterController))]
public class ChrContP: MonoBehaviour {
   
     public float walkSpeed = 6.0f;
  public float rotspeed = 20f;
     public float runSpeed = 11.0f;
     public bool limitDiagonalSpeed = true;
     public bool toggleRun = false;
     public float jumpSpeed = 8.0f;
     public float gravity = 20.0f;
     public float fallingDamageThreshold = 10.0f;
     public bool slideWhenOverSlopeLimit = false;
     public bool slideOnTaggedObjects = false;
     public float slideSpeed = 12.0f;
     public bool airControl = false;
     public float antiBumpFactor = .75f;
     public int antiBunnyHopFactor = 1;
     private Vector3 moveDirection = Vector3.zero;
     private bool grounded = false;
     private CharacterController controller;
     private Transform myTransform;
     private float speed;
     private RaycastHit hit;
     private float fallStartLevel;
     private bool falling;
     private float slideLimit;
     private float rayDistance;
     private Vector3 contactPoint;
     private bool playerControl = false;
     private int jumpTimer;
   
     void Start() {
         controller = GetComponent<CharacterController>();
         myTransform = transform;
         speed = walkSpeed;
         rayDistance = controller.height * .5f + controller.radius;
         slideLimit = controller.slopeLimit - .1f;
         jumpTimer = antiBunnyHopFactor;
     }
   
     void FixedUpdate() {
         float inputX = Input.GetAxis("Horizontal");
         float inputY = Input.GetAxis("Vertical");
         float inputModifyFactor = (inputX != 0.0f && inputY != 0.0f && limitDiagonalSpeed)? .7071f : 1.0f;
   
         if (grounded) {
             bool sliding = false;
             if (Physics.Raycast(myTransform.position, -Vector3.up, out hit, rayDistance)) {
                 if (Vector3.Angle(hit.normal, Vector3.up) > slideLimit)
                     sliding = true;
             }
             else {
                 Physics.Raycast(contactPoint + Vector3.up, -Vector3.up, out hit);
                 if (Vector3.Angle(hit.normal, Vector3.up) > slideLimit)
                     sliding = true;
             }
   
             if (falling) {
                 falling = false;
                 if (myTransform.position.y < fallStartLevel - fallingDamageThreshold)
                     FallingDamageAlert (fallStartLevel - myTransform.position.y);
             }
   
             if (!toggleRun)
                 speed = Input.GetButton("Run")? runSpeed : walkSpeed;
   
             if ( (sliding && slideWhenOverSlopeLimit) || (slideOnTaggedObjects && hit.collider.tag == "Slide") ) {
                 Vector3 hitNormal = hit.normal;
                 moveDirection = new Vector3(hitNormal.x, -hitNormal.y, hitNormal.z);
                 Vector3.OrthoNormalize (ref hitNormal, ref moveDirection);
                 moveDirection *= slideSpeed;
                 playerControl = false;
             }
             else {
                 moveDirection = new Vector3(0, -antiBumpFactor, inputY * inputModifyFactor);//inputX * inputModifyFactor
                 moveDirection = myTransform.TransformDirection(moveDirection) * speed;
                 playerControl = true;
             }
   
             if (!Input.GetButton("Jump"))
                 jumpTimer++;
             else if (jumpTimer >= antiBunnyHopFactor) {
                 moveDirection.y = jumpSpeed;
                 jumpTimer = 0;
             }
         }
         else {
             if (!falling) {
                 falling = true;
                 fallStartLevel = myTransform.position.y;
             }
   
             if (airControl && playerControl) {
                 moveDirection.z = inputY * speed * inputModifyFactor;
                 moveDirection = myTransform.TransformDirection(moveDirection);
             }
         }
   
         moveDirection.y -= gravity * Time.deltaTime;
    transform.Rotate(0,inputX * rotspeed * Time.deltaTime,0);
         grounded = (controller.Move(moveDirection * Time.deltaTime) & CollisionFlags.Below) != 0;
     }
   
     void Update () {
         if (toggleRun && grounded && Input.GetButtonDown("Run"))
             speed = (speed == walkSpeed? runSpeed : walkSpeed);
     }
   
     void OnControllerColliderHit (ControllerColliderHit hit) {
         contactPoint = hit.point;
     }
   
     void FallingDamageAlert (float fallDistance) {
         print ("Ouch! Fell " + fallDistance + " units!");    
     }
}