add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Abilities System/Custom Abilities/drainStatSystem.cs

@@ -0,0 +1,387 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class drainStatSystem : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool drainEnabled;
+
+    public LayerMask layerToCheck;
+
+    public bool useSphereCastAll;
+    public float sphereCastAllRadius;
+
+    [Space]
+    [Header ("Drain Settings")]
+    [Space]
+
+    public bool drainStatsEnabled = true;
+    public bool activateDrainCoroutineDirectly;
+
+    public float drainStatRate = 0.3f;
+    public float maxDrainDistance = 20;
+
+    public bool moveObjectCloserToPlayer;
+    public float moveObjectSpeed = 5;
+    public float lookObjectSpeed = 5;
+    public float minDistanceToMove = 3;
+
+    public float startDrainDelay;
+
+    public bool stopDrainDirectly = true;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+
+    public bool drainActive;
+    public bool drainActionPaused;
+    public bool moveObjectActive;
+
+    public List<GameObject> detectedGameObjectList = new List<GameObject> ();
+
+    [Space]
+    [Header ("Stats Settings")]
+    [Space]
+
+    public List<statsInfo> statsInfoList = new List<statsInfo> ();
+
+    [Space]
+    [Header ("Remote Event Settings")]
+    [Space]
+
+    public bool useRemoteEventOnObjectsFound;
+    public List<string> remoteEventNameListOnStart = new List<string> ();
+    public List<string> remoteEventNameListOnEnd = new List<string> ();
+
+    [Space]
+    [Header ("Event Settings")]
+    [Space]
+
+    public UnityEvent eventOnStartDrain;
+    public UnityEvent envetOnEndDrain;
+
+    public UnityEvent eventToStopDrainManually;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Transform mainCameraTransform;
+    public Transform playerTransform;
+
+    public playerStatsSystem mainPlayerStatsSystem;
+
+
+    List<playerStatsSystem> playerStatsSystemList = new List<playerStatsSystem> ();
+
+    RaycastHit hit;
+
+    Coroutine drainCoroutine;
+
+    remoteEventSystem currentRemoteEventSystem;
+
+    RaycastHit [] hitsList;
+
+    Coroutine moveCoroutine;
+
+
+    public void stopDrainManually ()
+    {
+        if (drainActive) {
+            eventToStopDrainManually.Invoke ();
+        }
+    }
+    public void stopDrainIfActive ()
+    {
+        if (drainActive) {
+            stopDrain ();
+
+            if (!stopDrainDirectly) {
+                envetOnEndDrain.Invoke ();
+            }
+        }
+    }
+
+    public void checkTargetToDrain ()
+    {
+        if (!drainEnabled) {
+            return;
+        }
+
+        if (drainActionPaused) {
+            return;
+        }
+
+        if (drainActive) {
+            stopDrainManually ();
+
+            return;
+        }
+
+        if (Physics.Raycast (mainCameraTransform.position, mainCameraTransform.forward, out hit, maxDrainDistance, layerToCheck)) {
+            bool startDrain = false;
+
+            detectedGameObjectList.Clear ();
+
+            playerStatsSystemList.Clear ();
+
+            if (useSphereCastAll) {
+                Ray newRay = new Ray (hit.point, mainCameraTransform.forward);
+
+                hitsList = Physics.SphereCastAll (newRay, sphereCastAllRadius, maxDrainDistance, layerToCheck);
+
+                List<GameObject> temporalGameObjectList = new List<GameObject> ();
+
+                for (int i = 0; i < hitsList.Length; i++) {
+                    temporalGameObjectList.Add (hitsList [i].collider.gameObject);
+                }
+
+                for (int i = 0; i < temporalGameObjectList.Count; i++) {
+                    playerComponentsManager currentPlayerComponentsManager = temporalGameObjectList [i].GetComponent<playerComponentsManager> ();
+
+                    if (currentPlayerComponentsManager != null) {
+                        playerStatsSystem statsSystemDetected = currentPlayerComponentsManager.getPlayerStatsSystem ();
+
+                        if (statsSystemDetected != null) {
+                            playerStatsSystemList.Add (statsSystemDetected);
+
+                            detectedGameObjectList.Add (temporalGameObjectList [i]);
+
+                            startDrain = true;
+                        }
+                    }
+                }
+            } else {
+                playerComponentsManager currentPlayerComponentsManager = hit.collider.GetComponent<playerComponentsManager> ();
+
+                if (currentPlayerComponentsManager != null) {
+                    playerStatsSystem statsSystemDetected = currentPlayerComponentsManager.getPlayerStatsSystem ();
+
+                    if (statsSystemDetected != null) {
+                        playerStatsSystemList.Add (statsSystemDetected);
+
+                        detectedGameObjectList.Add (hit.collider.gameObject);
+
+                        startDrain = true;
+                    }
+                }
+            }
+
+            if (startDrain) {
+                if (showDebugPrint) {
+                    print ("start drain");
+                }
+
+                eventOnStartDrain.Invoke ();
+
+                drainActive = true;
+
+                if (activateDrainCoroutineDirectly) {
+                    startDrainCoroutine ();
+                }
+            }
+        }
+    }
+
+    public void startDrainCoroutine ()
+    {
+        stopActivateDrainStatCoroutine ();
+
+        drainCoroutine = StartCoroutine (activateDrainStatCoroutine ());
+    }
+
+    public void stopActivateDrainStatCoroutine ()
+    {
+        if (drainCoroutine != null) {
+            StopCoroutine (drainCoroutine);
+        }
+    }
+
+    IEnumerator activateDrainStatCoroutine ()
+    {
+        yield return new WaitForSeconds (startDrainDelay);
+
+        if (drainStatsEnabled) {
+            bool statTotallyDrained = false;
+
+            int statsDrainedAmount = 0;
+
+            while (!statTotallyDrained) {
+                yield return new WaitForSeconds (drainStatRate);
+
+                for (int i = 0; i < statsInfoList.Count; i++) {
+
+                    mainPlayerStatsSystem.addOrRemovePlayerStatAmount (statsInfoList [i].statToIncrease, statsInfoList [i].increaseStatAmount);
+
+                    statsDrainedAmount = 0;
+
+                    for (int j = 0; j < statsInfoList [i].statToDrainList.Count; j++) {
+                        for (int k = 0; k < playerStatsSystemList.Count; k++) {
+                            playerStatsSystemList [k].addOrRemovePlayerStatAmount (statsInfoList [i].statToDrainList [j], statsInfoList [i].drainStatAmount);
+
+                            if (playerStatsSystemList [k].getStatValue (statsInfoList [i].statToDrainList [j]) <= 0) {
+                                statsDrainedAmount++;
+                            }
+                        }
+                    }
+
+                    if (useSphereCastAll) {
+                        if (statsDrainedAmount >= statsInfoList [i].statToDrainList.Count * playerStatsSystemList.Count) {
+                            statTotallyDrained = true;
+                        }
+                    } else {
+                        if (statsDrainedAmount >= statsInfoList [i].statToDrainList.Count) {
+                            statTotallyDrained = true;
+                        }
+                    }
+                }
+
+                yield return null;
+            }
+        }
+
+        yield return null;
+
+        stopDrain ();
+
+        if (!stopDrainDirectly) {
+            envetOnEndDrain.Invoke ();
+        }
+    }
+
+    public void stopDrain ()
+    {
+        if (!drainEnabled) {
+            return;
+        }
+
+        if (drainActive) {
+            if (showDebugPrint) {
+                print ("stop drain");
+            }
+
+            stopActivateDrainStatCoroutine ();
+
+            if (stopDrainDirectly) {
+                envetOnEndDrain.Invoke ();
+            }
+
+            drainActive = false;
+
+            checkRemoteEventOnEnd ();
+
+            moveObjectActive = false;
+
+            stopMoveObjectCoroutine ();
+
+            drainActionPaused = false;
+        }
+    }
+
+    public void checkRemoteEventOnStart ()
+    {
+        if (useRemoteEventOnObjectsFound) {
+            for (int i = 0; i < detectedGameObjectList.Count; i++) {
+                currentRemoteEventSystem = detectedGameObjectList [i].GetComponent<remoteEventSystem> ();
+
+                if (currentRemoteEventSystem != null) {
+                    for (int j = 0; j < remoteEventNameListOnStart.Count; j++) {
+
+                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameListOnStart [j]);
+                    }
+                }
+            }
+        }
+    }
+
+    public void checkRemoteEventOnEnd ()
+    {
+        if (useRemoteEventOnObjectsFound) {
+            for (int i = 0; i < detectedGameObjectList.Count; i++) {
+                currentRemoteEventSystem = detectedGameObjectList [i].GetComponent<remoteEventSystem> ();
+
+                if (currentRemoteEventSystem != null) {
+                    for (int j = 0; j < remoteEventNameListOnEnd.Count; j++) {
+
+                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameListOnEnd [j]);
+                    }
+                }
+            }
+        }
+    }
+
+    public void startMoveObjectCoroutine ()
+    {
+        stopMoveObjectCoroutine ();
+
+        moveCoroutine = StartCoroutine (moveObjectCoroutine ());
+    }
+
+    public void stopMoveObjectCoroutine ()
+    {
+        if (moveCoroutine != null) {
+            StopCoroutine (moveCoroutine);
+        }
+    }
+
+    IEnumerator moveObjectCoroutine ()
+    {
+        while (drainActive) {
+            if (moveObjectCloserToPlayer && moveObjectActive) {
+                for (int i = 0; i < detectedGameObjectList.Count; i++) {
+                    moveObject (detectedGameObjectList [i].transform);
+                }
+            }
+
+            yield return null;
+        }
+    }
+
+    void moveObject (Transform objectToMove)
+    {
+        float currentDistance = GKC_Utils.distance (playerTransform.position, objectToMove.position);
+
+        if (currentDistance > minDistanceToMove) {
+            objectToMove.position = Vector3.Lerp (objectToMove.position, playerTransform.position, Time.deltaTime * moveObjectSpeed);
+        }
+
+        Vector3 lookDirection = playerTransform.position - objectToMove.position;
+        lookDirection = lookDirection / lookDirection.magnitude;
+
+        Quaternion targetRotation = Quaternion.LookRotation (lookDirection);
+
+        objectToMove.rotation = Quaternion.Lerp (objectToMove.rotation, targetRotation, Time.deltaTime * lookObjectSpeed);
+    }
+
+    public void setDrainActionPausedState (bool state)
+    {
+        drainActionPaused = state;
+    }
+
+    public void setMoveObjectActiveState (bool state)
+    {
+        moveObjectActive = state;
+
+        if (moveObjectActive) {
+            startMoveObjectCoroutine ();
+        }
+    }
+
+    [System.Serializable]
+    public class statsInfo
+    {
+        public string statToIncrease;
+
+        public float increaseStatAmount = 5;
+        public float drainStatAmount = 5;
+
+        public List<string> statToDrainList = new List<string> ();
+    }
+}