add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Demo/damageCharacterOnCollision.cs

@@ -0,0 +1,216 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+public class damageCharacterOnCollision : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool damageEnabled = true;
+
+    public bool addForceToRigidbodies = true;
+    public float forceAmountToRigidbodies = 1000;
+
+    public bool applyDamageWhenPushCharacter;
+    public float extraForceOnCollision;
+
+    [Space]
+    [Header ("Objects To Detect Settings")]
+    [Space]
+
+    public bool useLayerToDetect;
+    public LayerMask layerToDetect;
+
+    [Space]
+
+    public bool useTagToDetect;
+
+    public List<string> tagToDetectList = new List<string> ();
+
+    [Space]
+    [Header ("Collisions Settings")]
+    [Space]
+
+    public bool useMinimumCollisionSpeed;
+    public float minimumCollisionSpeed;
+
+    public bool checkMinimumSpeedOnMainRigidbody;
+    public float minimumSpeedOnMainRigidbody;
+
+    [Space]
+    [Header ("Damage Settings")]
+    [Space]
+
+    public bool killCharacterOnCollision = true;
+    public bool pushCharacterOnCollision;
+
+    public bool ignoreShield;
+
+    public int damageTypeID = -1;
+
+    public bool damageCanBeBlocked = true;
+
+    public bool canActivateReactionSystemTemporally;
+    public int damageReactionID = -1;
+
+    public float damageMultiplier = 1;
+
+    public bool applyFixedDamageValue;
+    public float fixedDamageValue;
+
+    [Space]
+    [Header ("Debug Settings")]
+    [Space]
+
+    public bool showDebugPrint;
+
+    [Space]
+    [Header ("Remote Events Settings")]
+    [Space]
+
+    public bool useRemoteEventOnObjectsFound;
+    public List<string> remoteEventNameList = new List<string> ();
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Rigidbody mainRigidbody;
+
+    ContactPoint currentContact;
+    GameObject collisionObject;
+
+
+    void OnCollisionEnter (Collision collision)
+    {
+        if (!damageEnabled) {
+            return;
+        }
+
+        bool checkLayerCollisionDetectionResult = false;
+		bool checkTagCollisionDetectionResult = false;
+
+		if (useLayerToDetect) {
+			if ((1 << collision.gameObject.layer & layerToDetect.value) == 1 << collision.gameObject.layer) {
+				checkLayerCollisionDetectionResult = true;
+			}
+		}
+
+		if (useTagToDetect) {
+			if (tagToDetectList.Contains (collision.gameObject.tag)) {
+				checkTagCollisionDetectionResult = true;
+			}
+		}
+
+		if (useLayerToDetect || useTagToDetect) {
+			if (!checkLayerCollisionDetectionResult && !checkTagCollisionDetectionResult) {
+				return;
+			}
+		}
+
+        bool canActivateCollisionReaction = true;
+
+        if (useMinimumCollisionSpeed) {
+            float collisionMagnitude = collision.relativeVelocity.magnitude;
+
+            if (Mathf.Abs (collisionMagnitude) < minimumCollisionSpeed) {
+                canActivateCollisionReaction = false;
+            }
+
+            if (showDebugPrint) {
+                print ("collision magnitude " + Mathf.Abs (collisionMagnitude));
+            }
+
+            if (checkMinimumSpeedOnMainRigidbody) {
+                if (mainRigidbody == null) {
+                    mainRigidbody = GetComponent<Rigidbody> ();
+                }
+
+                if (mainRigidbody != null) {
+                    float speedOnMainRigidbody = mainRigidbody.linearVelocity.magnitude;
+
+                    if (Mathf.Abs (speedOnMainRigidbody) < minimumSpeedOnMainRigidbody) {
+                        canActivateCollisionReaction = false;
+                    }
+                }
+            }
+        }
+
+        if (showDebugPrint) {
+            print ("can activate collision reaction result " + canActivateCollisionReaction);
+        }
+
+        if (canActivateCollisionReaction) {
+            currentContact = collision.contacts [0];
+
+            collisionObject = collision.gameObject;
+
+            if (useRemoteEventOnObjectsFound) {
+                remoteEventSystem currentRemoteEventSystem = collisionObject.GetComponent<remoteEventSystem> ();
+
+                if (currentRemoteEventSystem != null) {
+                    for (int i = 0; i < remoteEventNameList.Count; i++) {
+                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameList [i]);
+                    }
+                }
+            }
+
+            if (addForceToRigidbodies) {
+                if (applyDamage.canApplyForce (collisionObject)) {
+                    collision.rigidbody.AddExplosionForce (forceAmountToRigidbodies, collision.transform.position, 100);
+                }
+            }
+
+            if (killCharacterOnCollision) {
+                //applyDamage.killCharacter (collisionObject);
+                float damage = applyDamage.getCurrentHealthAmount (collisionObject);
+
+                applyDamage.checkHealth (gameObject, collisionObject, damage, transform.forward, currentContact.point, gameObject,
+                    false, true, ignoreShield, false, damageCanBeBlocked, canActivateReactionSystemTemporally, damageReactionID, damageTypeID);
+            } else {
+                if (pushCharacterOnCollision) {
+                    Vector3 pushDirection = (currentContact.point - transform.position).normalized;
+
+                    if (extraForceOnCollision > 0) {
+                        pushDirection *= extraForceOnCollision;
+                    }
+
+                    applyDamage.pushCharacter (collisionObject, pushDirection);
+                }
+
+                if (applyDamageWhenPushCharacter) {
+                    float damage = 0;
+
+                    if (applyFixedDamageValue) {
+                        damage = fixedDamageValue;
+                    } else {
+                        damage = collision.relativeVelocity.magnitude * damageMultiplier;
+                    }
+
+                    if (showDebugPrint) {
+                        print ("apply damage " + damage);
+                    }
+
+                    applyDamage.checkHealth (gameObject, collisionObject, damage, transform.forward, currentContact.point, gameObject,
+                        false, true, ignoreShield, false, damageCanBeBlocked, canActivateReactionSystemTemporally, damageReactionID, damageTypeID);
+                }
+            }
+        }
+    }
+
+    public void setDamageEnabledState (bool state)
+    {
+        damageEnabled = state;
+    }
+
+    public void disableDamage ()
+    {
+        setDamageEnabledState (false);
+    }
+
+    public void enableDamage ()
+    {
+        setDamageEnabledState (true);
+    }
+}