void OnControllerColliderHit(ControllerColliderHit hit)
    {
        Rigidbody body = hit.collider.attachedRigidbody;

        // no rigidbody
        if (body == null || body.isKinematic)
            return;

        // We dont want to push objects below us

        if (hit.moveDirection.y < -0.5)
        {
            //platform = hit.transform;
            return;
        }

        // Calculate push direction from move direction,
        // we only push objects to the sides never up and down
        // if you wanted up and down pushing, change 0 to hit.moveDirection.y
        Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);

        // If you know how fast your character is trying to move,
        // then you can also multiply the push velocity by that.
        // Apply the push and decrease speed to 25% of the normal walk speed.
        body.velocity = (pushDir * Speed)/4;
    }

 /*////////////////////////////////////*/
 //Fonction des Dommages
 /*////////////////////////////////////*/
 void OnControllerColliderHit(ControllerColliderHit collision)
 {
     if(collision.gameObject.tag == "Player")
     {
         animator.SetBool("Hit", true);
     }
 }

 void OnControllerColliderHit(ControllerColliderHit coll)
 {
     if(coll.gameObject.tag == damageTag)
     {
         myKillable.Damage(damageRate);
     }
 }

 void OnControllerColliderHit(ControllerColliderHit other)
 {
     if (other.gameObject.GetComponent<DeathOnContact>() != null)
     {
         Kill();
     }
 }

    public void OnControllerColliderHit(ControllerColliderHit hit)
    {

       


    }

    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        if (hit.gameObject.Equals (lastColl) || isAnimation) {
            //Debug.Log("Nothing new: " + hit.gameObject.name);
            return;
        }
        Debug.Log ("Collision with: " + hit.gameObject);
        lastColl = hit.gameObject;
        transform.parent = lastColl.transform; // Aneinander kleben

        if (hit.gameObject.tag == "Finish")
            Application.LoadLevel (1);
        else if (hit.gameObject.tag == "Respawn") {
            Application.LoadLevel (0);
        } else if (hit.gameObject.tag == "Weiß" || hit.gameObject.tag == "Schwarz") {
            FeldControl2 fc = hit.gameObject.GetComponent<FeldControl2>();
            Debug.Log("Auf Schachbrett " + (1 + fc.Board) + " auf Feld " + fc.Field);
            PosText.text = "B: " + (fc.Board + 1) + " - P: " + fc.Field;
            if (!cBretterWeiß.AnimInProgress && !cBretterSchwarz.AnimInProgress) {
                if (hit.gameObject.tag == "Weiß") {
                    transform.parent = BretterWeiß.transform;
                    cBretterWeiß.BeginAnimation();
                } else {
                    transform.parent = BretterSchwarz.transform;
                    cBretterSchwarz.BeginAnimation();
                }
            }
        } else {
            Debug.Log("Collission not recognized: " + lastColl);
        }
        grounded = true;
    }

 void OnControllerColliderHit(ControllerColliderHit hit)
 {
     if(hit.gameObject.tag == "boulder")
     {
         hit.rigidbody.AddForce(transform.forward * speed);
     }
 }

 void OnControllerColliderHit(ControllerColliderHit hit)
 {
     if(hit.transform.tag == "Building")
     {
         GameOver();
     }
 }

    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        //Debug.Log ("detect a controller collider hit");
        Rigidbody body = hit.collider.attachedRigidbody;
        Vector3 pushDir;

        //Debug.Log ("body = " + (body==null));
        if (body!=null)
            //Debug.Log ("body = " + (body.isKinematic));
        // no rigidbody
        if (body == null || body.isKinematic) { return; }

        //Debug.Log (hit.moveDirection);
        // We dont want to push objects below us
        if (hit.moveDirection.y < -0.3) { return; }

        if (body.tag == "Door") {
            //Debug.Log("Pushing door");
            body.AddForce(-transform.forward * 1000f, ForceMode.Acceleration);
            body.useGravity = true;
        } else {
            // Calculate push direction from move direction,
            // we only push objects to the sides never up and down
            pushDir = new Vector3 (hit.moveDirection.x, 0, hit.moveDirection.z);

            // If you know how fast your character is trying to move,
            // then you can also multiply the push velocity by that.

            // Apply the push
            body.velocity = pushDir * pushPower;
        }
    }

 public CollisionNodeInfo(CollisionNodeToggler hitNode, Collider colliderObj, Collision collisionObj, ControllerColliderHit cchit)
 {
     this.hitNode = hitNode;
     collider = colliderObj;
     collision = collisionObj;
     controllerColliderHit = cchit;
 }

    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        if (hit.gameObject.name == "Spaceship")
        {
            hit.gameObject.SendMessage("EnterSpaceship", SendMessageOptions.DontRequireReceiver);
            return;
        }

        Rigidbody body = hit.collider.attachedRigidbody;
        // no rigidbody
        if (body == null || body.isKinematic)
            return;

        // Only push rigidbodies in the right layers
        int bodyLayerMask = 1 << body.gameObject.layer;
        if ((bodyLayerMask & pushLayers.value) == 0)
            return;

        // We dont want to push objects below us
        if (hit.moveDirection.y < -0.3)
            return;

        // Calculate push direction from move direction, we only push objects to the sides
        // never up and down
        Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);

        // push with move speed but never more than walkspeed
        body.velocity = pushDir * pushPower * Mathf.Min (controller.GetSpeed (), controller.movement.walkSpeed);
    }

 public bool handleCollision(ControllerColliderHit hit, Rigidbody body, float force)
 {
     Vector3 pushDir = new Vector3 (hit.moveDirection.x, 0, hit.moveDirection.z);
     //		body.velocity = pushDir * force;
     body.AddForce (pushDir * force);
     return false;
 }

	void OnControllerColliderHit(ControllerColliderHit hit){
		GameObject go = GameObject.FindGameObjectWithTag ("Player");
		MainPjMovement target = go.GetComponent ("MainPjMovement") as MainPjMovement;

		if (target.getHP () != target.getMAXHP ()) {
			if (hit.gameObject.tag == "BigHealPotion") {
				PJAudio.DrinkPotion();
				target.increaseHeal (200);
				Destroy (hit.gameObject);
			}
			if (hit.gameObject.tag == "LittleHealPotion") {
				PJAudio.DrinkPotion();
				target.increaseHeal (100);
				Destroy (hit.gameObject);
			}
		}
		if (target.getMP () != target.getMAXMP ()) {
			if (hit.gameObject.tag == "BigManaPotion") {
				target.increaseMana (200);
				Destroy (hit.gameObject);
			}
			if (hit.gameObject.tag == "BigManaPotion") {
				target.increaseMana (100);
				Destroy (hit.gameObject);
			}
		}
		if (hit.gameObject.tag == "Shield") {
			target.setShield(true);
			
			Destroy(hit.gameObject);
		}
	}

    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        Rigidbody body = hit.collider.attachedRigidbody;
        // no rigidbody
        if (body == null || body.isKinematic)
            return;

        // Only push rigidbodies in the right layers
        var bodyLayerMask = 1 << body.gameObject.layer;
        if ((bodyLayerMask & pushLayers.value) == 0)
            return;

        // We dont want to push objects below us
        //if (hit.moveDirection.y < -0.3)
        //    return;

        // Calculate push direction from move direction, we only push objects to the sides
        // never up and down
        //Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);

        // push with move speed but never more than walkspeed
        //body.velocity = pushDir * pushPower * Mathf.Min (controller.GetSpeed (), controller.movement.walkSpeed);
        body.AddForceAtPosition(hit.normal*(-pushPower), hit.point);
        //print(hit.normal);
    }

 //OnControllerColliderHit(ControllerColliderHit hit)
 void OnControllerColliderHit(ControllerColliderHit hit)
 {
     if (hit.transform.tag == "shark"){
         Destroy(gameObject);
         Application.LoadLevel(Application.loadedLevel);
     }
 }

        public override void OnCharacterCollided(ControllerColliderHit hit, Transform other)
        {
            base.OnCharacterCollided(hit, other);

            if (Colliding)
                return;

            //check if hit point beneath player
            var dir = (hit.point - other.position).normalized;
            if (dir.y < -0.9)
                CollisionType = DaggerfallAction.TriggerTypes.WalkOn;
            else
            {
                if (thisAction.TriggerFlag == DaggerfallConnect.DFBlock.RdbTriggerFlags.Collision01)
                {
                    Vector3 origin = new Vector3(hit.controller.transform.position.x, hit.controller.transform.position.y - hit.controller.height / 2, hit.controller.transform.position.z);
                    Ray ray = new Ray(origin, Vector3.down);
                    RaycastHit hitInfo;

                    //if hit not below controller, see if player standing on this action object w/ raycast & if action flag is Collision01 (walk on)
                    //set trigger type & activate if so - to avoid player being able to push against wall to avoid
                    if (hit.collider.Raycast(ray, out hitInfo, hit.controller.skinWidth))
                        CollisionType = DaggerfallAction.TriggerTypes.WalkOn;
                    else
                        CollisionType = DaggerfallAction.TriggerTypes.WalkInto;
                }
                else
                    CollisionType = DaggerfallAction.TriggerTypes.WalkInto;

            }

            Colliding = true;
        }

	void OnControllerColliderHit(ControllerColliderHit col){
		Debug.Log(col.gameObject.name);
		if(col.gameObject.tag == "Core"){
			score++;
			Destroy(col.gameObject);
		}
	}

    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        GameObject body = hit.gameObject;
        switch (body.tag){
            case "Target":
            if(state == STATE.HOOKING && body.name ==hookTarget){
                state = STATE.STUCK;
                lastStuck = body.name;
                hookTarget = "";
                foreach(GameObject item in passedThrough)
                    item.collider.enabled = true;

                passedThrough.Clear ();
            }
            else{
                passedThrough.AddFirst(body);
                body.collider.enabled=false;
            }
            break;
            case "Platform":
                state = STATE.GROUNDED;
                break;
        }

          //  body.velocity = pushDir * pushPower;
    }

    void ApplyHit(ControllerColliderHit hit)
    {
        if (hit.normal.y > 0.7f) {
            Vector3 normalVelocity = Vector3.Project(move.velocity, Vector3.up);
            Vector3 tangentialVelocity = Vector3.ProjectOnPlane(move.velocity, Vector3.up);

            var movingSurface = hit.gameObject.GetComponentInParent<MovingSurface>();
            if (movingSurface == null) {
                tangentialVelocity = Vector3.zero;
            } else {
                Vector3 radiusVector = hit.point - movingSurface.transform.position;
                //Vector3 rotationVelocity = Vector3.Cross(movingSurface.currentAngularVelocity * Mathf.Deg2Rad, radiusVector);

                //Vector3 localHitPoint = movingSurface.transform.InverseTransformPoint(hit.point);
                Vector3 nextRadiusVector = Quaternion.Euler(movingSurface.currentAngularVelocity * Time.fixedDeltaTime) * radiusVector;
                Vector3 rotationVelocity = (nextRadiusVector - radiusVector) / Time.fixedDeltaTime;

                //Debug.Log("movingSurface.currentAngularVelocity: " + movingSurface.currentAngularVelocity);
                //Debug.Log("rotationVelocity: " + rotationVelocity);

                Vector3 hitPointVelocity = movingSurface.currentVelocity + rotationVelocity;

                tangentialVelocity = hitPointVelocity;

                //Debug.Log("Final tangentialVelocity: " + tangentialVelocity);
            }

            move.velocity = normalVelocity + tangentialVelocity;

            move.angularVelocity = movingSurface != null ? movingSurface.currentAngularVelocity : Vector3.zero;
            //move.angularVelocity = move.angularVelocity.Change(x: 0, z: 0);
        }
    }

 void OnControllerColliderHit(ControllerColliderHit hit)
 {
     if (hit.collider.gameObject.name == "Box")
     {
         Debug.Log("Collision!!!!!");
     }
 }