add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Health/shieldSystem.cs

@@ -0,0 +1,506 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+
+public class shieldSystem : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool useShield;
+    public float maxShieldAmount;
+    public float shieldAmount = 100;
+    public bool regenerateShield;
+    public bool constantShieldRegenerate;
+    public float regenerateShieldSpeed = 0;
+    public float regenerateShieldTime;
+    public float regenerateShieldAmount;
+
+    public bool useHealthBarManager = true;
+
+    public string shieldStatName = "Current Shield";
+
+    public string maxShieldStatName = "Max Shield";
+
+    public string mainManagerName = "Health Bar Manager";
+
+    [Space]
+    [Header ("Shield Slider Setting")]
+    [Space]
+
+    public bool showShieldBarPanelEnabled = true;
+
+    public bool hideSliderWhenNotDamageReceived;
+    public float timeToHideSliderAfterDamage;
+    public RectTransform mainSliderParent;
+    public RectTransform hiddenSliderParent;
+    public RectTransform mainSliderTransform;
+
+    Coroutine hideSliderCoroutine;
+
+    float lastTimeHideSliderChecked;
+
+    [Space]
+    [Header ("Events Setting")]
+    [Space]
+
+    public UnityEvent eventOnStartShield;
+    public UnityEvent eventOnDamageShield;
+    public eventParameters.eventToCallWithGameObject eventOnDamageShieldWithAttacker;
+    public UnityEvent eventOnShieldDestroyed;
+    public UnityEvent eventOnStartRegenerateShield;
+
+    public UnityEvent eventToCheckIfShieldIsActive;
+    public UnityEvent eventToCheckIfShieldIsNotActive;
+    public UnityEvent eventToCheckIfShieldIsDestroyed;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public GameObject shieldPanel;
+    public Slider shieldSlider;
+    public Text shieldSliderText;
+
+    public health mainHealth;
+    public healthBarManagementSystem healthBarManager;
+
+    public playerStatsSystem playerStatsManager;
+
+
+    bool hasPlayerStatsManager;
+
+    float auxShieldAmount;
+    float lastShieldDamageTime = 0;
+
+    bool shieldPreviouslyDestroyed;
+
+    bool hasShieldSlider;
+
+    bool dead;
+
+    bool originalUseShield;
+
+    bool healthBarManagerLocated;
+
+    void getHealthManager ()
+    {
+        healthBarManagerLocated = healthBarManager != null;
+
+        if (!healthBarManagerLocated) {
+            healthBarManager = healthBarManagementSystem.Instance;
+
+            healthBarManagerLocated = healthBarManager != null;
+        }
+
+        if (!healthBarManagerLocated) {
+            GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (healthBarManagementSystem.getMainManagerName (), typeof (healthBarManagementSystem), true);
+
+            healthBarManager = healthBarManagementSystem.Instance;
+
+            healthBarManagerLocated = healthBarManager != null;
+        }
+    }
+
+    public void startShieldComponents ()
+    {
+        if (!healthBarManagerLocated) {
+            getHealthManager ();
+        }
+
+        if (maxShieldAmount == 0) {
+            maxShieldAmount = shieldAmount;
+        }
+
+        auxShieldAmount = shieldAmount;
+
+        if (shieldSlider != null) {
+
+            hasShieldSlider = true;
+
+            shieldSlider.maxValue = maxShieldAmount;
+            shieldSlider.value = shieldAmount;
+
+            if (shieldSliderText != null) {
+                shieldSliderText.text = maxShieldAmount.ToString ();
+            }
+
+            if (hideSliderWhenNotDamageReceived) {
+                checkSetSliderParent (false);
+            }
+        }
+
+        if (useHealthBarManager) {
+            hasShieldSlider = true;
+        }
+
+        if (playerStatsManager != null) {
+            hasPlayerStatsManager = true;
+        }
+
+        eventOnStartShield.Invoke ();
+
+        originalUseShield = useShield;
+    }
+
+    public void disableShield ()
+    {
+        setUseShieldState (false);
+    }
+
+    public void updateSliderState ()
+    {
+        if (!useShield) {
+            return;
+        }
+
+        if (!dead) {
+            if (regenerateShield) {
+                if (constantShieldRegenerate) {
+                    if (regenerateShieldSpeed > 0 && shieldAmount < maxShieldAmount) {
+                        if (Time.time > lastShieldDamageTime + regenerateShieldTime && Time.time > mainHealth.getLastDamageTime () + regenerateShieldTime) {
+                            getShield (regenerateShieldSpeed * Time.deltaTime);
+                        }
+                    }
+                } else {
+                    if (shieldAmount < maxShieldAmount) {
+                        if (Time.time > lastShieldDamageTime + regenerateShieldTime && Time.time > mainHealth.getLastDamageTime () + regenerateShieldTime) {
+                            getShield (regenerateShieldAmount);
+                            lastShieldDamageTime = Time.time;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void updateShieldSlider (float value)
+    {
+        if (hasShieldSlider) {
+            if (shieldSlider != null) {
+                shieldSlider.value = value;
+
+                if (shieldSliderText != null) {
+                    shieldSliderText.text = Mathf.RoundToInt (value).ToString ();
+                }
+
+                checkHideSliderParent ();
+            }
+
+            if (useHealthBarManager && healthBarManagerLocated) {
+                healthBarManager.setShieldSliderAmount (mainHealth.getHealthID (), value);
+            }
+
+            updatePlayerStatsManagerShieldValue ();
+        }
+    }
+
+    void updatePlayerStatsManagerShieldValue ()
+    {
+        if (hasPlayerStatsManager) {
+            playerStatsManager.updateStatValue (shieldStatName, shieldAmount);
+        }
+    }
+
+    void updatePlayerStatsManagerMaxShieldValue ()
+    {
+        if (hasPlayerStatsManager) {
+            playerStatsManager.updateStatValue (maxShieldStatName, maxShieldAmount);
+        }
+    }
+
+    void updateShieldSliderInternally (float value)
+    {
+        if (hasShieldSlider) {
+            if (shieldSlider != null) {
+                shieldSlider.value = value;
+
+                if (shieldSliderText != null) {
+                    shieldSliderText.text = Mathf.RoundToInt (value).ToString ();
+                }
+            }
+        }
+    }
+
+    public void updateShieldSliderMaxValue (float newMaxValue)
+    {
+        if (hasShieldSlider) {
+            if (shieldSlider != null) {
+                shieldSlider.maxValue = newMaxValue;
+            }
+
+            if (useHealthBarManager && healthBarManagerLocated) {
+                healthBarManager.updateShieldSliderMaxValue (mainHealth.getHealthID (), newMaxValue);
+            }
+
+            checkHideSliderParent ();
+        }
+    }
+
+    void updateShieldSliderMaxValueInternally (float newMaxValue)
+    {
+        if (hasShieldSlider) {
+            if (shieldSlider != null) {
+                shieldSlider.maxValue = newMaxValue;
+            }
+        }
+    }
+
+    public void checkHideSliderParent ()
+    {
+        if (hideSliderWhenNotDamageReceived) {
+            stopCheckHideSliderCoroutine ();
+
+            lastTimeHideSliderChecked = Time.time;
+
+            hideSliderCoroutine = StartCoroutine (checkHideSliderCoroutine ());
+        }
+    }
+
+    void stopCheckHideSliderCoroutine ()
+    {
+        if (hideSliderCoroutine != null) {
+            StopCoroutine (hideSliderCoroutine);
+        }
+    }
+
+    IEnumerator checkHideSliderCoroutine ()
+    {
+        checkSetSliderParent (true);
+
+        bool targetReached = false;
+
+        while (!targetReached) {
+
+            if (Time.time > timeToHideSliderAfterDamage + lastTimeHideSliderChecked) {
+                targetReached = true;
+            }
+
+            if (mainHealth.isPlayerMenuActive ()) {
+                targetReached = true;
+            }
+
+            yield return null;
+        }
+
+        checkSetSliderParent (false);
+    }
+
+    void checkSetSliderParent (bool setOnMainParent)
+    {
+        if (hideSliderWhenNotDamageReceived) {
+            if (setOnMainParent) {
+                mainSliderTransform.transform.SetParent (mainSliderParent);
+            } else {
+                mainSliderTransform.transform.SetParent (hiddenSliderParent);
+
+            }
+
+            mainSliderTransform.transform.localPosition = Vector3.zero;
+            mainSliderTransform.transform.localRotation = Quaternion.identity;
+        }
+    }
+
+    public void getShield (float amount)
+    {
+        if (!dead) {
+
+            shieldPreviouslyDestroyed = false;
+
+            if (shieldAmount == 0) {
+                shieldPreviouslyDestroyed = true;
+            }
+
+            shieldAmount += amount;
+
+            //check that the shield amount is not higher that the shield max value of the slider
+            if (shieldAmount >= maxShieldAmount) {
+                shieldAmount = maxShieldAmount;
+            }
+
+            updateShieldSlider (shieldAmount);
+
+            if (shieldPreviouslyDestroyed && shieldAmount > 0) {
+                eventOnStartRegenerateShield.Invoke ();
+            }
+        }
+
+        auxShieldAmount = shieldAmount;
+    }
+
+    public void setDeadState (bool state)
+    {
+        dead = state;
+    }
+
+    public bool receiveDamage (float damageAmount, GameObject attacker)
+    {
+        if (useShield && shieldAmount > 0) {
+
+            if (damageAmount > shieldAmount) {
+                damageAmount = shieldAmount;
+            }
+
+            shieldAmount -= damageAmount;
+            auxShieldAmount = shieldAmount;
+
+            eventOnDamageShield.Invoke ();
+
+            eventOnDamageShieldWithAttacker.Invoke (attacker);
+
+            if (shieldAmount <= 0) {
+                shieldAmount = 0;
+
+                eventOnShieldDestroyed.Invoke ();
+            }
+
+            updateShieldSlider (shieldAmount);
+
+            lastShieldDamageTime = Time.time;
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public float getShieldAmountToLimit ()
+    {
+        return maxShieldAmount - auxShieldAmount;
+    }
+
+    public void addAuxShieldAmount (float amount)
+    {
+        auxShieldAmount += amount;
+    }
+
+    public void increaseMaxShieldAmount (float newAmount)
+    {
+        maxShieldAmount += newAmount;
+
+        updateShieldSliderMaxValue (maxShieldAmount);
+    }
+
+    public void setShieldAmountOnMaxValue ()
+    {
+        getShield (maxShieldAmount - shieldAmount);
+    }
+
+    public void increaseRegenerateShieldSpeed (float newAmount)
+    {
+        regenerateShieldSpeed += newAmount;
+    }
+
+    public void initializeShieldAmount (float newValue)
+    {
+        shieldAmount = newValue;
+    }
+
+    public void initializeMaxShieldAmount (float newValue)
+    {
+        maxShieldAmount = newValue;
+    }
+
+    public void initializeRegenerateShieldSpeed (float newValue)
+    {
+        regenerateShieldSpeed = newValue;
+    }
+
+    public void increaseMaxShieldAmountByMultiplier (float amountMultiplier)
+    {
+        maxShieldAmount *= amountMultiplier;
+
+        updateShieldSliderMaxValue (maxShieldAmount);
+
+        updatePlayerStatsManagerMaxShieldValue ();
+
+        updateShieldAmountWithoutUpdatingStatManager (0, maxShieldAmount);
+
+        updatePlayerStatsManagerShieldValue ();
+    }
+
+    public void updateShieldAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        shieldAmount = amount;
+
+        updateShieldSliderInternally (shieldAmount);
+
+        auxShieldAmount = shieldAmount;
+    }
+
+    public void updateMaxShieldAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        maxShieldAmount = amount;
+
+        updateShieldSliderMaxValueInternally (maxShieldAmount);
+    }
+
+    public void updateRegenerateShieldSpeedAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        regenerateShieldSpeed = amount;
+    }
+
+    public void setUseShieldState (bool state)
+    {
+        useShield = state;
+
+        if (showShieldBarPanelEnabled) {
+            if (shieldPanel != null) {
+                if (shieldPanel.activeSelf != useShield) {
+                    shieldPanel.SetActive (useShield);
+                }
+            }
+        }
+    }
+
+    public void setShowShieldBarPanelEnabledState (bool state)
+    {
+        showShieldBarPanelEnabled = state;
+    }
+
+    public void setOriginalUseShieldState ()
+    {
+        setUseShieldState (originalUseShield);
+    }
+
+    public void checkEventsForShieldState ()
+    {
+        if (useShield) {
+            if (shieldAmount > 0) {
+                eventToCheckIfShieldIsActive.Invoke ();
+            } else {
+                eventToCheckIfShieldIsDestroyed.Invoke ();
+            }
+        } else {
+            eventToCheckIfShieldIsNotActive.Invoke ();
+        }
+    }
+
+    public float getCurrentShieldAmount ()
+    {
+        return shieldAmount;
+    }
+
+    public void setShowShieldBarPanelEnabledStateFromEditor (bool state)
+    {
+        setShowShieldBarPanelEnabledState (state);
+
+        updateComponent ();
+    }
+
+    public void setUseShieldStateFromEditor (bool state)
+    {
+        setUseShieldState (state);
+
+        updateComponent ();
+    }
+
+    void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+
+        GKC_Utils.updateDirtyScene ("Update Shield System", gameObject);
+    }
+}