add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Weapons/Projectiles/plasmaCutterProjectile.cs

@@ -0,0 +1,697 @@
+using System.Collections;
+using System.Collections.Generic;
+using GameKitController.Audio;
+using UnityEngine;
+
+public class plasmaCutterProjectile : projectileSystem
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public Material defaultSliceMaterial;
+
+    public float forceToApplyToCutPart;
+    public ForceMode forceMode;
+    public float forceRadius;
+
+    public bool cutMultipleTimesActive;
+
+    public bool useCutLimit;
+    public int cutLimit;
+
+    public bool activateRigidbodiesOnNewObjects = true;
+
+    [Space]
+    [Header ("Shatter Object Settings")]
+    [Space]
+
+    public bool shatterObjectActive;
+    public int shatterAmount;
+
+    public bool applyForceOnShatter;
+
+    public bool addSliceComponentToPieces = true;
+
+    [Space]
+    [Header ("Damage Settings")]
+    [Space]
+
+    public bool activateDamageOnSlice;
+    public float damageAmountToApplyOnSlice;
+    public bool ignoreShieldOnDamage = true;
+    public bool canActivateReactionSystemTemporally;
+    public int damageReactionID = -1;
+
+    public int damageTypeID = -1;
+
+    [Space]
+    [Header ("Physics Settings")]
+    [Space]
+
+    public bool updateLastObjectSpeed;
+
+    public bool applyForcesOnObjectsDetected;
+    public float addForceMultiplier;
+    public bool applyImpactForceToVehicles;
+    public float impactForceToVehiclesMultiplier;
+
+    public bool checkObjectLayerAndTagToApplyForces;
+
+    public LayerMask targetToApplyForceLayer;
+    public List<string> tagetToApplyForceTagList = new List<string> ();
+
+    [Space]
+    [Header ("Other Settings")]
+    [Space]
+
+    public float minDelayToSliceSameObject = 0.01f;
+
+    public Transform cutPositionTransform;
+
+    public Vector3 cutOverlapBoxSize = new Vector3 (5, 0.1f, 5);
+
+    public bool addRigidbodyToBothSlicedObjects;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+
+    public List<GameObject> objectsDetected = new List<GameObject> ();
+
+    [Space]
+    [Header ("Gizmo Settings")]
+    [Space]
+
+    public bool showGizmo;
+    public Color gizmoColor = Color.red;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Transform cutDirectionTransform;
+    public Transform planeDefiner1;
+    public Transform planeDefiner2;
+    public Transform planeDefiner3;
+
+    surfaceToSlice currentSurfaceToSlice;
+
+    int currentNumberOfCuts;
+
+    List<GameObject> objectsToShatter;
+    bool objectShattered = false;
+
+    public void checkObjectDetected (Collider col)
+    {
+        if (canActivateEffect (col)) {
+
+            objectShattered = false;
+
+            if (currentProjectileInfo.impactAudioElement != null) {
+                currentProjectileInfo.impactAudioElement.audioSource = GetComponent<AudioSource> ();
+                AudioPlayer.PlayOneShot (currentProjectileInfo.impactAudioElement, gameObject);
+            }
+
+            Collider objectCollider = col.GetComponent<Collider> ();
+
+            objectToDamage = objectCollider.gameObject;
+
+            processObject (objectToDamage, objectCollider, cutPositionTransform.position);
+
+            if (!cutMultipleTimesActive || currentNumberOfCuts >= cutLimit) {
+                setProjectileUsedState (true);
+
+                mainRigidbody.isKinematic = true;
+
+                projectilePaused = true;
+
+                destroyProjectile ();
+            }
+        }
+    }
+
+    public void processObject (GameObject objectToCheck, Collider objectCollider, Vector3 slicePosition)
+    {
+        if (cutMultipleTimesActive) {
+            if (objectsDetected.Contains (objectToCheck)) {
+                return;
+            }
+        }
+
+        currentSurfaceToSlice = objectToCheck.GetComponent<surfaceToSlice> ();
+
+        if (currentSurfaceToSlice == null) {
+            currentSurfaceToSlice = sliceSystemUtils.getSurfaceToSlice (objectToCheck);
+        }
+
+        bool isVehicle = applyDamage.isVehicle (objectToCheck);
+
+        if (isVehicle) {
+            GameObject currentVehicle = applyDamage.getVehicle (objectToCheck);
+
+            if (currentVehicle != null) {
+                currentSurfaceToSlice = currentVehicle.GetComponent<surfaceToSlice> ();
+
+                if (currentSurfaceToSlice != null) {
+                    objectToCheck = currentVehicle;
+                }
+            }
+        }
+
+        bool objectIsSliceSurfaceDisabled = false;
+
+        bool objectCanBeSliced = false;
+
+        if (showDebugPrint) {
+            print ("processing object " + objectToCheck.name);
+        }
+
+        bool ignoreRegularDamageIfCutSurfaceNotEnabled = false;
+
+        bool isIgnoreDamageIfSliceNotActivatedActive = false;
+
+        if (currentSurfaceToSlice != null) {
+            bool isCutSurfaceEnabled = currentSurfaceToSlice.isCutSurfaceEnabled ();
+
+            bool sliceCanBeActivated = currentSurfaceToSlice.sliceCanBeActivated (minDelayToSliceSameObject);
+
+            bool checkSliceDirectionResult = currentSurfaceToSlice.checkSliceDirectionResult (cutPositionTransform.right, cutPositionTransform.up);
+
+            isIgnoreDamageIfSliceNotActivatedActive = currentSurfaceToSlice.isIgnoreDamageIfSliceNotActivatedActive ();
+
+            if (showDebugPrint) {
+                print ("Surface cut enabled state " + isCutSurfaceEnabled +
+                " can activate slice " + sliceCanBeActivated);
+            }
+
+            if (isCutSurfaceEnabled && sliceCanBeActivated && checkSliceDirectionResult) {
+                Material crossSectionMaterial = currentSurfaceToSlice.getCrossSectionMaterial ();
+
+                if (crossSectionMaterial == null) {
+                    crossSectionMaterial = defaultSliceMaterial;
+                }
+
+                sliceCurrentObject (objectToCheck, objectCollider, crossSectionMaterial, slicePosition);
+
+                objectCanBeSliced = true;
+            } else {
+                if (isVehicle && isCutSurfaceEnabled) {
+                    objectCanBeSliced = true;
+                }
+            }
+
+            if (!isCutSurfaceEnabled) {
+                objectIsSliceSurfaceDisabled = true;
+
+                ignoreRegularDamageIfCutSurfaceNotEnabled = currentSurfaceToSlice.isIgnoreRegularDamageIfCutSurfaceNotEnabled ();
+            }
+        } else {
+            if (showDebugPrint) {
+                print ("Surface to slice not found on " + objectToCheck.name);
+            }
+        }
+
+        if (!objectCanBeSliced && !ignoreRegularDamageIfCutSurfaceNotEnabled) {
+            if (activateDamageOnSlice && !isIgnoreDamageIfSliceNotActivatedActive) {
+                Vector3 damagePosition = cutPositionTransform.position;
+
+                if (applyDamage.checkIfDead (objectToCheck)) {
+                    damagePosition = objectToCheck.transform.position;
+                }
+
+                applyDamage.checkCanBeDamaged (gameObject, objectToCheck, damageAmountToApplyOnSlice, -cutPositionTransform.forward, damagePosition,
+                    currentProjectileInfo.owner, true, true, ignoreShieldOnDamage, false, true, canActivateReactionSystemTemporally,
+                    damageReactionID, damageTypeID);
+            }
+
+            if (applyForcesOnObjectsDetected && !objectIsSliceSurfaceDisabled) {
+                if (!checkObjectLayerAndTagToApplyForces ||
+                    ((1 << objectToCheck.layer & targetToApplyForceLayer.value) == 1 << objectToCheck.layer && tagetToApplyForceTagList.Contains (objectToCheck.tag))) {
+                    checkForceToApplyOnObject (objectToCheck);
+                }
+            }
+        }
+    }
+
+    public void sliceCurrentObject (GameObject objectToCheck, Collider objectCollider, Material crossSectionMaterial, Vector3 slicePosition)
+    {
+        if (useCutLimit) {
+            currentNumberOfCuts++;
+        }
+
+        // slice the provided object using the transforms of this object
+        if (currentSurfaceToSlice.isObjectCharacter ()) {
+            //			print ("character found " + objectToCheck.name + " is dead " + applyDamage.checkIfDead (objectToCheck));
+
+            if (applyDamage.getCharacterOrVehicle (objectToCheck) != null && !applyDamage.checkIfDead (objectToCheck)) {
+                processCharacter (objectToCheck);
+
+                return;
+            }
+
+            Rigidbody mainObject = objectToCheck.GetComponent<Rigidbody> ();
+
+            bool mainObjectHasRigidbody = mainObject != null;
+
+            Vector3 lastSpeed = Vector3.zero;
+
+            if (mainObjectHasRigidbody) {
+                lastSpeed = mainObject.linearVelocity;
+            }
+
+            currentSurfaceToSlice.checkEventBeforeSlice ();
+
+            currentSurfaceToSlice.getMainSimpleSliceSystem ().activateSlice (objectCollider, positionInWorldSpace,
+                normalInWorldSpace, slicePosition, updateLastObjectSpeed, lastSpeed);
+
+            currentSurfaceToSlice.checkEventOnCut ();
+
+            currentSurfaceToSlice.checkTimeBulletOnCut ();
+        } else {
+            if (shatterObjectActive) {
+                shatterObject (objectToCheck, crossSectionMaterial);
+
+                return;
+            }
+
+            // slice the provided object using the transforms of this object
+            bool objectSliced = false;
+
+            GameObject object1 = null;
+            GameObject object2 = null;
+
+            currentSurfaceToSlice.checkEventBeforeSlice ();
+
+            objectToCheck = currentSurfaceToSlice.getMainSurfaceToSlice ();
+
+            // slice the provided objectToCheck	ect using the transforms of this object
+            sliceSystemUtils.sliceObject (transform.position, objectToCheck, cutDirectionTransform.up, crossSectionMaterial, ref objectSliced, ref object1, ref object2);
+
+            Vector3 objectPosition = objectToCheck.transform.position;
+            Quaternion objectRotation = objectToCheck.transform.rotation;
+
+            Transform objectParent = objectToCheck.transform.parent;
+
+            if (objectSliced) {
+                if (currentSurfaceToSlice.useParticlesOnSlice) {
+                    Quaternion particlesRotation = Quaternion.LookRotation (positionInWorldSpace);
+
+                    Instantiate (currentSurfaceToSlice.particlesOnSlicePrefab, slicePosition, particlesRotation);
+                }
+
+                currentSurfaceToSlice.checkEventOnCut ();
+
+                currentSurfaceToSlice.checkTimeBulletOnCut ();
+
+                Rigidbody mainObject = objectToCheck.GetComponent<Rigidbody> ();
+                bool mainObjectHasRigidbody = mainObject != null;
+
+                object1.transform.position = objectPosition;
+                object1.transform.rotation = objectRotation;
+
+                object2.transform.position = objectPosition;
+                object2.transform.rotation = objectRotation;
+
+                if (objectParent != null) {
+                    object1.transform.SetParent (objectParent);
+                    object2.transform.SetParent (objectParent);
+                }
+
+                surfaceToSlice newSurfaceToSlice1 = object1.AddComponent<surfaceToSlice> ();
+                surfaceToSlice newSurfaceToSlice2 = object2.AddComponent<surfaceToSlice> ();
+
+                currentSurfaceToSlice.copySurfaceInfo (newSurfaceToSlice1);
+                currentSurfaceToSlice.copySurfaceInfo (newSurfaceToSlice2);
+
+                newSurfaceToSlice1.checkDestroySlicedPartsAfterDelay ();
+                newSurfaceToSlice2.checkDestroySlicedPartsAfterDelay ();
+
+                float currentForceToApply = forceToApplyToCutPart;
+
+                ForceMode currentForceMode = forceMode;
+
+                if (currentSurfaceToSlice.useCustomForceMode) {
+                    currentForceMode = currentSurfaceToSlice.customForceMode;
+                }
+
+                if (mainObjectHasRigidbody || activateRigidbodiesOnNewObjects) {
+
+                    if (currentSurfaceToSlice.useCustomForceAmount) {
+                        currentForceToApply = currentSurfaceToSlice.customForceAmount;
+                    }
+
+                    Rigidbody object1Rigidbody = object1.AddComponent<Rigidbody> ();
+
+                    Rigidbody object2Rigidbody = object2.AddComponent<Rigidbody> ();
+
+                    object2Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
+
+                    object1Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
+                } else {
+                    if (currentSurfaceToSlice.useCustomForceAmount) {
+                        currentForceToApply = currentSurfaceToSlice.customForceAmount;
+                    }
+
+                    bool addRigidbodyToObject1 = false;
+                    bool addRigidbodyToObject2 = false;
+
+                    if (addRigidbodyToBothSlicedObjects) {
+                        addRigidbodyToObject1 = true;
+                        addRigidbodyToObject2 = true;
+                    } else {
+                        float distance1 = GKC_Utils.distance (objectToCheck.transform.position, object1.transform.position);
+                        float distance2 = GKC_Utils.distance (objectToCheck.transform.position, object2.transform.position);
+
+                        if (distance1 < distance2) {
+                            addRigidbodyToObject1 = true;
+                        } else {
+                            addRigidbodyToObject2 = true;
+                        }
+                    }
+
+                    if (addRigidbodyToObject1) {
+                        Rigidbody object2Rigidbody = object2.AddComponent<Rigidbody> ();
+
+                        object2Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
+                    }
+
+                    if (addRigidbodyToObject2) {
+                        Rigidbody object1Rigidbody = object1.AddComponent<Rigidbody> ();
+
+                        object1Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
+                    }
+                }
+
+                if (currentSurfaceToSlice.useBoxCollider) {
+                    object1.AddComponent<BoxCollider> ();
+                    object2.AddComponent<BoxCollider> ();
+                } else {
+                    MeshCollider object1Collider = object1.AddComponent<MeshCollider> ();
+                    MeshCollider object2Collider = object2.AddComponent<MeshCollider> ();
+
+                    object1Collider.convex = true;
+                    object2Collider.convex = true;
+                }
+
+                if (currentSurfaceToSlice.setNewLayerOnCut) {
+                    object1.layer = LayerMask.NameToLayer (currentSurfaceToSlice.newLayerOnCut);
+                    object2.layer = LayerMask.NameToLayer (currentSurfaceToSlice.newLayerOnCut);
+                }
+
+                if (currentSurfaceToSlice.setNewTagOnCut) {
+                    object1.tag = currentSurfaceToSlice.newTagOnCut;
+                    object2.tag = currentSurfaceToSlice.newTagOnCut;
+                }
+
+                if (cutMultipleTimesActive) {
+                    if (!objectsDetected.Contains (object1)) {
+                        objectsDetected.Add (object1);
+                    }
+
+                    if (!objectsDetected.Contains (object2)) {
+                        objectsDetected.Add (object2);
+                    }
+                }
+
+                objectToCheck.SetActive (false);
+            }
+        }
+    }
+
+    void processCharacter (GameObject currentCharacter)
+    {
+        StartCoroutine (processCharacterCoroutine (currentCharacter));
+    }
+
+    List<Collider> colliders = new List<Collider> ();
+
+    IEnumerator processCharacterCoroutine (GameObject currentCharacter)
+    {
+        applyDamage.pushCharacterWithoutForceAndPauseGetUp (currentCharacter);
+
+        Vector3 slicePosition = cutPositionTransform.position;
+
+        Collider [] temporalHits = Physics.OverlapBox (slicePosition, cutOverlapBoxSize, cutDirectionTransform.rotation, currentProjectileInfo.targetToDamageLayer);
+
+        bool bodyPartFound = false;
+
+        if (temporalHits.Length > 0) {
+            bool ragdollCollidersFoundOnCharacter = false;
+
+            colliders = null;
+
+            ragdollActivator currentRagdollActivator = currentCharacter.GetComponent<ragdollActivator> ();
+
+            if (currentRagdollActivator != null) {
+                colliders = currentRagdollActivator.getBodyColliderList ();
+
+                if (colliders != null && colliders.Count > 0) {
+                    ragdollCollidersFoundOnCharacter = true;
+                }
+            }
+
+            Collider colliderToCheck = null;
+
+            float minDistance = 1000;
+
+            for (int i = 0; i < temporalHits.Length; i++) {
+                Collider currentCollider = temporalHits [i];
+
+                bool canActivateSliceResult = false;
+
+                if (ragdollCollidersFoundOnCharacter) {
+                    if (showDebugPrint) {
+                        print ("ragoll detected");
+                    }
+
+                    if (colliders.Contains (currentCollider)) {
+                        canActivateSliceResult = true;
+
+                        if (showDebugPrint) {
+                            print ("ragdoll part found");
+                        }
+                    }
+                } else {
+                    canActivateSliceResult = true;
+                }
+
+                if (canActivateSliceResult) {
+
+                    if (applyDamage.isCharacter (currentCollider.gameObject)) {
+                        bodyPartFound = true;
+
+                        float currentDistance = GKC_Utils.distance (slicePosition, currentCollider.transform.position);
+
+                        if (currentDistance < minDistance) {
+                            minDistance = currentDistance;
+
+                            colliderToCheck = currentCollider;
+                        }
+                    }
+                }
+            }
+
+            if (bodyPartFound) {
+                if (currentCharacter != null) {
+                    applyDamage.killCharacter (currentCharacter);
+                }
+
+                processObject (colliderToCheck.gameObject, colliderToCheck, slicePosition);
+            }
+        }
+
+        yield return null;
+    }
+
+    private Vector3 positionInWorldSpace
+    {
+        get
+        {
+            return (planeDefiner1.position + planeDefiner2.position + planeDefiner3.position) / 3f;
+        }
+    }
+
+    private Vector3 normalInWorldSpace
+    {
+        get
+        {
+            Vector3 t0 = planeDefiner1.position;
+            Vector3 t1 = planeDefiner2.position;
+            Vector3 t2 = planeDefiner3.position;
+
+            Vector3 vectorValue;
+
+            vectorValue.x = t0.y * (t1.z - t2.z) + t1.y * (t2.z - t0.z) + t2.y * (t0.z - t1.z);
+            vectorValue.y = t0.z * (t1.x - t2.x) + t1.z * (t2.x - t0.x) + t2.z * (t0.x - t1.x);
+            vectorValue.z = t0.x * (t1.y - t2.y) + t1.x * (t2.y - t0.y) + t2.x * (t0.y - t1.y);
+
+            return vectorValue;
+        }
+    }
+
+    public void checkForceToApplyOnObject (GameObject objectToDamage)
+    {
+        Rigidbody objectToDamageRigidbody = objectToDamage.GetComponent<Rigidbody> ();
+
+        Vector3 forceDirection = cutDirectionTransform.forward;
+
+        float forceAmount = addForceMultiplier;
+
+        float forceToVehiclesMultiplier = impactForceToVehiclesMultiplier;
+
+        if (applyImpactForceToVehicles) {
+            Rigidbody objectToDamageMainRigidbody = applyDamage.applyForce (objectToDamage);
+
+            if (objectToDamageMainRigidbody != null) {
+                Vector3 force = forceAmount * forceDirection;
+
+                bool isVehicle = applyDamage.isVehicle (objectToDamage);
+
+                if (isVehicle) {
+                    force *= forceToVehiclesMultiplier;
+                }
+
+                objectToDamageMainRigidbody.AddForce (objectToDamageMainRigidbody.mass * force, forceMode);
+            }
+        } else {
+            if (applyDamage.canApplyForce (objectToDamage)) {
+                //print (objectToDamage.name);
+                Vector3 force = forceAmount * forceDirection;
+
+                if (objectToDamageRigidbody == null) {
+                    objectToDamageRigidbody = objectToDamage.GetComponent<Rigidbody> ();
+                }
+
+                objectToDamageRigidbody.AddForce (objectToDamageRigidbody.mass * force, forceMode);
+            }
+        }
+    }
+
+    public override void setProjectileSpecialActionActiveState (bool state)
+    {
+        setShatterObjectActiveState (state);
+    }
+
+    //SHATTER FUNCTIONS
+    public void setShatterObjectActiveState (bool state)
+    {
+        shatterObjectActive = state;
+    }
+
+    public void shatterObject (GameObject objectToCheck, Material crossSectionMaterial)
+    {
+        if (objectShattered) {
+            return;
+        }
+
+        objectsToShatter = new List<GameObject> ();
+
+        if (objectToCheck.transform.parent != null) {
+            objectToCheck.transform.SetParent (null);
+        }
+
+        objectsToShatter.Add (objectToCheck);
+
+        for (int i = 0; i < shatterAmount; i++) {
+            randomShatter (crossSectionMaterial);
+        }
+
+        objectShattered = true;
+    }
+
+    public void randomShatter (Material crossSectionMaterial)
+    {
+        List<GameObject> adders = new List<GameObject> ();
+        List<GameObject> removals = new List<GameObject> ();
+
+        foreach (GameObject objectToShatter in objectsToShatter) {
+            GameObject [] shatters = randomShatterSingle (objectToShatter, crossSectionMaterial);
+
+            if (shatters != null) {
+                foreach (GameObject add in shatters) {
+                    adders.Add (add);
+                }
+
+                removals.Add (objectToShatter);
+            }
+        }
+
+        foreach (GameObject rem in removals) {
+            objectsToShatter.Remove (rem);
+        }
+
+        foreach (GameObject add in adders) {
+            objectsToShatter.Add (add);
+        }
+    }
+
+    public GameObject [] randomShatterSingle (GameObject objectToShatter, Material crossSectionMaterial)
+    {
+        Vector3 shatterPosition = objectToShatter.transform.position;
+
+        GameObject [] shatters = sliceSystemUtils.shatterObject (objectToShatter, shatterPosition, crossSectionMaterial);
+
+        if (shatters != null && shatters.Length > 0) {
+            objectToShatter.SetActive (false);
+
+            Vector3 cutPosition = objectToShatter.transform.position;
+
+            // add rigidbodies and colliders
+            foreach (GameObject shatteredObject in shatters) {
+                shatteredObject.AddComponent<MeshCollider> ().convex = true;
+
+                if (applyForceOnShatter) {
+                    Rigidbody currentObjectRigidbody = shatteredObject.AddComponent<Rigidbody> ();
+
+                    currentObjectRigidbody.AddExplosionForce (forceToApplyToCutPart, cutPosition, 10, 1, forceMode);
+                } else {
+                    shatteredObject.AddComponent<Rigidbody> ();
+                }
+
+                if (addSliceComponentToPieces) {
+                    surfaceToSlice newSurfaceToSlice = shatteredObject.AddComponent<surfaceToSlice> ();
+
+                    newSurfaceToSlice.setCrossSectionMaterial (crossSectionMaterial);
+                }
+            }
+        }
+
+        return shatters;
+    }
+
+    public override void resetProjectile ()
+    {
+        base.resetProjectile ();
+
+        currentNumberOfCuts = 0;
+
+        objectsDetected.Clear ();
+    }
+
+#if UNITY_EDITOR
+    void OnDrawGizmos ()
+    {
+        if (!showGizmo) {
+            return;
+        }
+
+        if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
+            DrawGizmos ();
+        }
+    }
+
+    void OnDrawGizmosSelected ()
+    {
+        DrawGizmos ();
+    }
+
+    void DrawGizmos ()
+    {
+        if (showGizmo) {
+            GKC_Utils.drawRectangleGizmo (cutPositionTransform.position, cutPositionTransform.rotation, Vector3.zero, cutOverlapBoxSize, gizmoColor);
+        }
+    }
+#endif
+}