add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Powers/launchedObjects.cs

@@ -0,0 +1,218 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+public class launchedObjects : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool checkCollisionsEnabled = true;
+
+    public bool removeComponentOnCollisionEnabled = true;
+
+    [Space]
+    [Header ("Damage Settings")]
+    [Space]
+
+    public bool useCustomDamageAmount;
+    public float customDamageAmount;
+
+    public bool searchPlayerAsDamageAttacker;
+
+    public int damageTypeID = -1;
+
+    public bool damageCanBeBlocked = true;
+
+    [Space]
+    [Header ("Other Settings")]
+    [Space]
+
+    public bool checkOnTriggerEnterEnabled;
+
+    public LayerMask layermaskToCheckOnTriggerEnter;
+
+    [Space]
+    [Header ("Events Settings")]
+    [Space]
+
+    public bool useRemoteEventOnObjectsFound;
+    public List<string> remoteEventNameList = new List<string> ();
+
+
+    bool ignoreShield;
+    bool canActivateReactionSystemTemporally;
+    int damageReactionID = -1;
+
+    float timer = 0;
+    GameObject currentPlayer;
+    Collider currentPlayerCollider;
+    Collider mainCollider;
+
+
+    //this script is for the objects launched by the player, to check the object which collides with them
+
+    void Update ()
+    {
+        if (!checkCollisionsEnabled) {
+            return;
+        }
+
+        //if the launched objects does not collide with other object, remove the script
+        if (timer > 0) {
+            timer -= Time.deltaTime;
+
+            if (timer < 0) {
+                activateCollision ();
+            }
+        }
+    }
+
+    void OnCollisionEnter (Collision collision)
+    {
+        if (!checkCollisionsEnabled) {
+            return;
+        }
+
+        checkObjectDetected (collision.collider, collision.relativeVelocity.magnitude, collision.contacts [0].point, false);
+    }
+    public void setOnTriggerInfoCheckState (bool state, LayerMask newLayermask)
+    {
+        checkOnTriggerEnterEnabled = state;
+
+        layermaskToCheckOnTriggerEnter = newLayermask;
+    }
+
+    void OnTriggerEnter (Collider colliderDetected)
+    {
+        if (!checkCollisionsEnabled) {
+            return;
+        }
+
+        if (checkOnTriggerEnterEnabled) {
+            if ((1 << colliderDetected.gameObject.layer & layermaskToCheckOnTriggerEnter.value) != 1 << colliderDetected.gameObject.layer) {
+                return;
+            }
+
+            checkObjectDetected (colliderDetected, GetComponent<Rigidbody> ().linearVelocity.magnitude, transform.position, true);
+        }
+    }
+
+    public void setUseCustomDamageAmountValues (bool state, float amount)
+    {
+        useCustomDamageAmount = state;
+
+        customDamageAmount = amount;
+    }
+    void checkObjectDetected (Collider colliderDetected, float collisionVelocity, Vector3 collisionPosition, bool checkIfIsTrigger)
+    {
+        if (!colliderDetected.isTrigger || checkIfIsTrigger) {
+            //if the object has a health script, it reduces the amount of life according to the launched object velocity
+            float damageAmountToUse = 0;
+
+            if (useCustomDamageAmount) {
+                damageAmountToUse = customDamageAmount;
+            } else {
+                damageAmountToUse = GetComponent<Rigidbody> ().linearVelocity.magnitude;
+
+                if (damageAmountToUse == 0) {
+                    damageAmountToUse = collisionVelocity;
+                }
+            }
+
+            GameObject currentObjectFound = colliderDetected.gameObject;
+
+            bool objectToDamageFound = applyDamage.objectCanBeDamaged (currentObjectFound);
+
+            if (objectToDamageFound) {
+
+                if (searchPlayerAsDamageAttacker && currentPlayer == null) {
+                    currentPlayer = GKC_Utils.findMainPlayerOnScene ();
+                }
+
+                if (damageAmountToUse > 0) {
+                    applyDamage.checkHealth (gameObject, currentObjectFound, damageAmountToUse, -transform.forward, transform.position, currentPlayer,
+                        false, true, ignoreShield, false, damageCanBeBlocked, canActivateReactionSystemTemporally, damageReactionID, damageTypeID);
+                }
+
+                bool isVehicle = applyDamage.isVehicle (currentObjectFound);
+
+                if (isVehicle) {
+                    Rigidbody objectToDamageMainRigidbody = applyDamage.applyForce (currentObjectFound);
+
+                    if (objectToDamageMainRigidbody != null) {
+                        Vector3 collisionDirection = (collisionPosition - transform.position).normalized;
+
+                        objectToDamageMainRigidbody.AddForce (collisionDirection * damageAmountToUse * objectToDamageMainRigidbody.mass, ForceMode.Impulse);
+                    }
+                }
+
+                activateCollision ();
+
+                if (currentObjectFound != null) {
+                    if (useRemoteEventOnObjectsFound) {
+                        remoteEventSystem currentRemoteEventSystem = currentObjectFound.GetComponent<remoteEventSystem> ();
+
+                        if (currentRemoteEventSystem != null) {
+                            for (int i = 0; i < remoteEventNameList.Count; i++) {
+                                currentRemoteEventSystem.callRemoteEvent (remoteEventNameList [i]);
+                            }
+                        }
+                    }
+                }
+            }
+            //else, set the timer to disable the script
+            else {
+                timer = 1;
+            }
+        }
+    }
+
+    void activateCollision ()
+    {
+        if (currentPlayerCollider != null) {
+
+            mainCollider = GetComponent<Collider> ();
+
+            if (mainCollider != null) {
+                Physics.IgnoreCollision (mainCollider, currentPlayerCollider, false);
+            }
+        }
+
+        if (removeComponentOnCollisionEnabled) {
+            Destroy (this);
+        }
+    }
+
+    public void setCurrentPlayer (GameObject player)
+    {
+        currentPlayer = player;
+    }
+
+    public void setCurrentPlayerAndCollider (GameObject player, Collider playerCollider)
+    {
+        currentPlayer = player;
+
+        currentPlayerCollider = playerCollider;
+    }
+
+    public void setIgnoreShieldState (bool state)
+    {
+        ignoreShield = state;
+    }
+
+    public void setCanActivateReactionSystemTemporally (bool state)
+    {
+        canActivateReactionSystemTemporally = state;
+    }
+
+    public void setCamageReactionID (int newValue)
+    {
+        damageReactionID = newValue;
+    }
+
+    public void setCheckCollisionsEnabledState (bool state)
+    {
+        checkCollisionsEnabled = state;
+    }
+}