add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Stats System/playerStatsSystem.cs

@@ -0,0 +1,795 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Serialization;
+
+public class playerStatsSystem : MonoBehaviour
+{
+    public bool playerStatsActive = true;
+
+    public bool initializeStatsValuesAtStartActive = true;
+
+    public bool initializeStatsOnlyWhenLoadingGame;
+
+    public bool saveCurrentPlayerStatsToSaveFile;
+
+    public List<statInfo> statInfoList = new List<statInfo> ();
+
+    public bool isLoadingGame;
+
+    public bool initializeValuesWhenNotLoadingFromTemplate;
+
+    public statsSettingsTemplate mainStatsSettingsTemplate;
+
+    public bool useByAI;
+
+
+    float currentMaxAmount;
+
+    void Awake ()
+    {
+        if (useByAI) {
+            initializeStatsValues ();
+        }
+    }
+
+    public void initializeStatsValues ()
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        bool initializingValuesFromTemplate = false;
+
+        if (initializeStatsValuesAtStartActive) {
+            if (initializeValuesWhenNotLoadingFromTemplate && !isLoadingGame) {
+                loadSettingsFromTemplate (false);
+
+                initializingValuesFromTemplate = true;
+            }
+        }
+
+        statInfo currentStatInfo = null;
+
+        if (initializeStatsValuesAtStartActive && (!initializeStatsOnlyWhenLoadingGame || isLoadingGame || initializingValuesFromTemplate)) {
+            int statInfoListCount = statInfoList.Count;
+
+            for (int k = 0; k < statInfoListCount; k++) {
+                currentStatInfo = statInfoList [k];
+
+                if (currentStatInfo.initializeStatWithThisValue) {
+                    if (currentStatInfo.statIsAmount) {
+                        if (currentStatInfo.useCustomStatTypeForEvents) {
+                            currentStatInfo.customStatType.eventToInitializeStat (currentStatInfo.currentValue);
+                        } else {
+                            currentStatInfo.eventToInitializeStat.Invoke (currentStatInfo.currentValue);
+                        }
+                    } else {
+                        if (currentStatInfo.useCustomStatTypeForEvents) {
+                            currentStatInfo.customStatType.eventToInitializeBoolStat (currentStatInfo.currentBoolState);
+                        } else {
+                            currentStatInfo.eventToInitializeBoolStat.Invoke (currentStatInfo.currentBoolState);
+                        }
+                    }
+                } else {
+                    if (currentStatInfo.statIsAmount) {
+                        if (currentStatInfo.useCustomStatTypeForEvents) {
+                            currentStatInfo.customStatType.eventToInitializeStatOnComponent ();
+                        } else {
+                            currentStatInfo.eventToInitializeStatOnComponent.Invoke ();
+                        }
+                    } else {
+                        if (currentStatInfo.useCustomStatTypeForEvents) {
+                            currentStatInfo.customStatType.eventToInitializeBoolStatOnComponent ();
+                        } else {
+                            currentStatInfo.eventToInitializeBoolStatOnComponent.Invoke ();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void setIsLoadingGameState (bool state)
+    {
+        isLoadingGame = state;
+    }
+
+    public bool isLoadingGameState ()
+    {
+        return isLoadingGame;
+    }
+
+    public float getStatMaxAmountByIndex (int statIndex)
+    {
+        statInfo currentStatInfo = statInfoList [statIndex];
+
+        currentMaxAmount = currentStatInfo.maxAmount;
+
+        if (currentStatInfo.useOtherStatAsMaxAmount) {
+            currentMaxAmount = getStatValue (currentStatInfo.otherStatAsMaxAmountName);
+
+            if (currentMaxAmount < 0) {
+                currentMaxAmount = currentStatInfo.currentValue;
+            }
+        }
+
+        return currentMaxAmount;
+    }
+
+    public float getStatMaxAmountByName (string statName)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                if (currentStatInfo.useMaxAmount) {
+                    currentMaxAmount = currentStatInfo.maxAmount;
+
+                    if (currentStatInfo.useOtherStatAsMaxAmount) {
+                        currentMaxAmount = getStatValue (currentStatInfo.otherStatAsMaxAmountName);
+
+                        if (currentMaxAmount < 0) {
+                            currentMaxAmount = currentStatInfo.currentValue;
+                        }
+                    }
+
+                    return currentMaxAmount;
+                } else {
+                    return -1;
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    public bool isStatOnMaxAmount (string statName)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                if (currentStatInfo.useMaxAmount) {
+                    currentMaxAmount = currentStatInfo.maxAmount;
+
+                    if (currentStatInfo.useOtherStatAsMaxAmount) {
+                        currentMaxAmount = getStatValue (currentStatInfo.otherStatAsMaxAmountName);
+
+                        if (currentMaxAmount < 0) {
+                            currentMaxAmount = currentStatInfo.currentValue;
+                        }
+                    }
+
+                    if (currentStatInfo.currentValue >= currentMaxAmount) {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    string temporalStatName;
+
+    public void increasePlayerStatWithNameAndAmount (string statNameAndAmountString)
+    {
+        bool splitSymbolLocated = statNameAndAmountString.Contains (";");
+
+        if (splitSymbolLocated) {
+            string [] nameAndAmount = statNameAndAmountString.Split (';');
+
+            if (nameAndAmount.Length > 1) {
+                string nameValue = nameAndAmount [0];
+
+                float amountValue = float.Parse (nameAndAmount [1]);
+
+                if (amountValue > 0) {
+                    increasePlayerStat (nameValue, amountValue);
+                }
+            }
+        }
+    }
+
+    public void setTemporalStatName (string statName)
+    {
+        temporalStatName = statName;
+    }
+
+    public void increasePlayerStateOfTemporalStat (float statExtraValue)
+    {
+        if (temporalStatName != "") {
+            increasePlayerStat (temporalStatName, statExtraValue);
+
+            temporalStatName = "";
+        }
+    }
+
+    public void increasePlayerStatByMultiplier (string statName, float statMultiplier)
+    {
+        float temporalValue = getStatValue (statName);
+
+        if (temporalValue > 0) {
+            float amountToIncrease = (statMultiplier * temporalValue) / 100;
+
+            increasePlayerStat (statName, amountToIncrease);
+        }
+    }
+
+    public void increasePlayerStat (string statName, float statExtraValue)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentValue += statExtraValue;
+
+                if (currentStatInfo.useMaxAmount) {
+                    currentStatInfo.currentValue = Mathf.Clamp (currentStatInfo.currentValue, 0, getStatMaxAmountByIndex (k));
+                }
+
+                if (currentStatInfo.useCustomStatTypeForEvents) {
+                    currentStatInfo.customStatType.eventToIncreaseStat (statExtraValue);
+                } else {
+                    currentStatInfo.eventToIncreaseStat.Invoke (statExtraValue);
+                }
+
+                return;
+            }
+        }
+    }
+
+    public void increaseExtraPlayerStat (string statName, float statExtraValue)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentValue += statExtraValue;
+
+                currentStatInfo.extraCurrentValue += statExtraValue;
+
+                if (currentStatInfo.useMaxAmount) {
+                    currentStatInfo.currentValue = Mathf.Clamp (currentStatInfo.currentValue, 0, getStatMaxAmountByIndex (k));
+                }
+
+                if (currentStatInfo.useCustomStatTypeForEvents) {
+                    currentStatInfo.customStatType.eventToIncreaseStat (statExtraValue);
+                } else {
+                    currentStatInfo.eventToIncreaseStat.Invoke (statExtraValue);
+                }
+
+                return;
+            }
+        }
+    }
+
+    public void usePlayerStat (string statName, float statValueToUse)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentValue -= statValueToUse;
+
+                if (currentStatInfo.currentValue < 0) {
+                    currentStatInfo.currentValue = 0;
+                }
+
+                if (currentStatInfo.useCustomStatTypeForEvents) {
+                    currentStatInfo.customStatType.eventToUseStat (statValueToUse);
+                } else {
+                    currentStatInfo.eventToUseStat.Invoke (statValueToUse);
+                }
+
+                return;
+            }
+        }
+    }
+
+    public void usePlayerStatByIndex (int statIndex, float statValueToUse)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        if (statIndex < 0 || statIndex >= statInfoList.Count) {
+            return;
+        }
+
+        usePlayerStat (statInfoList [statIndex].Name, statValueToUse);
+    }
+
+    public void addOrRemovePlayerStatAmount (string statName, float amountToUse)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentValue += amountToUse;
+
+                if (currentStatInfo.currentValue < 0) {
+                    currentStatInfo.currentValue = 0;
+                } else {
+                    if (currentStatInfo.useMaxAmount) {
+                        currentStatInfo.currentValue = Mathf.Clamp (currentStatInfo.currentValue, 0, getStatMaxAmountByIndex (k));
+                    }
+                }
+
+                if (amountToUse > 0) {
+                    if (currentStatInfo.useCustomStatTypeForEvents) {
+                        currentStatInfo.customStatType.eventToAddAmount (amountToUse);
+                    } else {
+                        currentStatInfo.eventToAddAmount.Invoke (amountToUse);
+                    }
+                } else {
+                    if (currentStatInfo.useCustomStatTypeForEvents) {
+                        currentStatInfo.customStatType.eventToUseStat (-amountToUse);
+                    } else {
+                        currentStatInfo.eventToUseStat.Invoke (-amountToUse);
+                    }
+                }
+
+                return;
+            }
+        }
+    }
+
+    public string getStatName (int index)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (k == index) {
+                return currentStatInfo.Name;
+            }
+        }
+
+        return string.Empty;
+    }
+
+    public List<string> getStatsNames ()
+    {
+        List<string> names = new List<string> ();
+
+        for (int k = 0; k < statInfoList.Count; k++) {
+            names.Add (statInfoList [k].Name);
+        }
+
+        return names;
+    }
+
+    public float getStatValue (string statName)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                return currentStatInfo.currentValue;
+            }
+        }
+
+        return -1;
+    }
+
+    public bool checkIfStatValueAvailable (string statName, int statAmount)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                return currentStatInfo.currentValue >= statAmount;
+            }
+        }
+
+        return false;
+    }
+
+    public float getStatValueByIndex (int statIndex)
+    {
+        if (statIndex < 0) {
+            return -1;
+        }
+
+        return statInfoList [statIndex].currentValue;
+    }
+
+    public int getStatValueIndex (string statName)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                return k;
+            }
+        }
+
+        return -1;
+    }
+
+    public void updateStatValue (string statName, float newValue)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentValue = newValue;
+
+                if (currentStatInfo.useMaxAmount) {
+                    currentStatInfo.currentValue = Mathf.Clamp (currentStatInfo.currentValue, 0, getStatMaxAmountByIndex (k));
+                }
+
+                if (currentStatInfo.useEventToSendValueOnUpdateStat) {
+                    currentStatInfo.eventToSendValueOnUpdateStat.Invoke (k, currentStatInfo.currentValue);
+                }
+
+                return;
+            }
+        }
+    }
+
+    public void updateStatValueExternally (int statIndex, float newValue)
+    {
+        updateStatValueExternally (getStatName (statIndex), newValue);
+    }
+
+    public void updateStatValueExternally (string statName, float newValue)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentValue = newValue;
+
+                if (currentStatInfo.useMaxAmount) {
+                    currentStatInfo.currentValue = Mathf.Clamp (currentStatInfo.currentValue, 0, getStatMaxAmountByIndex (k));
+                }
+
+                if (currentStatInfo.useEventToSendValueOnUpdateStatExternally) {
+                    currentStatInfo.eventToSendValueOnUpdateStatExternally.Invoke (k, currentStatInfo.currentValue);
+                }
+
+                return;
+            }
+        }
+    }
+
+    public void updateStatValue (int statIndex, float newValue)
+    {
+        updateStatValue (getStatName (statIndex), newValue);
+    }
+
+    public void enableOrDisableBoolPlayerStat (string statName, bool boolStateValue)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentBoolState = boolStateValue;
+
+                if (currentStatInfo.useCustomStatTypeForEvents) {
+                    currentStatInfo.customStatType.eventToActivateBoolStat (boolStateValue);
+                } else {
+                    currentStatInfo.eventToActivateBoolStat.Invoke (boolStateValue);
+                }
+
+                return;
+            }
+        }
+    }
+
+    public bool getBoolStatValue (string statName)
+    {
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                return currentStatInfo.currentBoolState;
+            }
+        }
+
+        return false;
+    }
+
+    public void updateBoolStatValue (string statName, bool boolStateValue)
+    {
+        if (!playerStatsActive) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            currentStatInfo = statInfoList [k];
+
+            if (currentStatInfo.Name.Equals (statName)) {
+                currentStatInfo.currentBoolState = boolStateValue;
+            }
+        }
+    }
+
+    public void setPlayerStatsActiveState (bool state)
+    {
+        playerStatsActive = state;
+    }
+
+    public void saveSettingsToTemplate ()
+    {
+        if (mainStatsSettingsTemplate == null) {
+            return;
+        }
+
+        mainStatsSettingsTemplate.statTemplateInfoList.Clear ();
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int i = 0; i < statInfoListCount; i++) {
+            statTemplateInfo newStatTemplateInfo = new statTemplateInfo ();
+
+            newStatTemplateInfo.Name = statInfoList [i].Name;
+
+            newStatTemplateInfo.currentValue = statInfoList [i].currentValue;
+
+            newStatTemplateInfo.currentBoolState = statInfoList [i].currentBoolState;
+
+            mainStatsSettingsTemplate.statTemplateInfoList.Add (newStatTemplateInfo);
+        }
+
+        updateComponent ();
+
+        GKC_Utils.updateDirtyScene ("Save Stats Settings To Template", gameObject);
+
+        print ("States values saved to template");
+    }
+
+    public void loadSettingsFromTemplate (bool loadingFromEditor)
+    {
+        if (mainStatsSettingsTemplate == null) {
+            return;
+        }
+
+        statInfo currentStatInfo = null;
+
+        int statInfoListCount = statInfoList.Count;
+
+        for (int i = 0; i < statInfoListCount; i++) {
+            int statIndex = mainStatsSettingsTemplate.statTemplateInfoList.FindIndex (a => a.Name == statInfoList [i].Name);
+
+            if (statIndex > -1) {
+
+                statTemplateInfo newStatTemplateInfo = mainStatsSettingsTemplate.statTemplateInfoList [statIndex];
+
+                currentStatInfo = statInfoList [i];
+
+                currentStatInfo.currentBoolState = newStatTemplateInfo.currentBoolState;
+                currentStatInfo.currentValue = newStatTemplateInfo.currentValue;
+            }
+        }
+
+        if (loadingFromEditor) {
+            updateComponent ();
+
+            GKC_Utils.updateDirtyScene ("Load Stats Settings From Template", gameObject);
+
+            print ("Stats values loaded from template");
+        }
+    }
+
+    public void initializeAllStatValuesFromEditor ()
+    {
+        int statInfoListCount = statInfoList.Count;
+
+        for (int k = 0; k < statInfoListCount; k++) {
+            initializeStatValueFromEditor (statInfoList [k].Name, false);
+        }
+
+        updateComponent ();
+
+        GKC_Utils.updateDirtyScene ("Initialize All Stat Values From Editor", gameObject);
+    }
+
+    public void initializeStatValueFromEditor (string statName, bool updateComponentValue)
+    {
+        int statIndex = statInfoList.FindIndex (a => a.Name.Equals (statName));
+
+        if (statIndex > -1) {
+            statInfo currentStatInfo = statInfoList [statIndex];
+
+            if (currentStatInfo.statIsAmount) {
+                if (currentStatInfo.useCustomStatTypeForEvents) {
+                    currentStatInfo.customStatType.eventToInitializeStat (currentStatInfo.currentValue);
+                } else {
+                    currentStatInfo.eventToInitializeStat.Invoke (currentStatInfo.currentValue);
+                }
+            } else {
+                if (currentStatInfo.useCustomStatTypeForEvents) {
+                    currentStatInfo.customStatType.eventToInitializeBoolStat (currentStatInfo.currentBoolState);
+                } else {
+                    currentStatInfo.eventToInitializeBoolStat.Invoke (currentStatInfo.currentBoolState);
+                }
+            }
+        }
+
+        if (updateComponentValue) {
+            updateComponent ();
+
+            GKC_Utils.updateDirtyScene ("Initialize Stat Value From Editor", gameObject);
+        }
+    }
+
+    public void updateStatValueFromEditor (string statName, float newValue)
+    {
+        updateStatValue (statName, newValue);
+
+        updateComponent ();
+
+        GKC_Utils.updateDirtyScene ("Update Stat Value From Editor", gameObject);
+    }
+
+    public void setPlayerStatsActiveStateFromEditor (bool state)
+    {
+        setPlayerStatsActiveState (state);
+
+        updateComponent ();
+
+        GKC_Utils.updateDirtyScene ("Update Stats System", gameObject);
+    }
+
+    public void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+    }
+
+
+    [System.Serializable]
+    public class statInfo
+    {
+        public string Name;
+
+        public bool statIsAmount = true;
+
+        public float currentValue;
+
+        public float extraCurrentValue;
+
+        public eventParameters.eventToCallWithAmount eventToInitializeStat;
+
+        public eventParameters.eventToCallWithAmount eventToIncreaseStat;
+
+        public eventParameters.eventToCallWithAmount eventToUseStat;
+
+        public eventParameters.eventToCallWithAmount eventToAddAmount;
+
+        [FormerlySerializedAs ("useEventToSendValueOnUpdateState")]
+        public bool useEventToSendValueOnUpdateStat;
+
+        [FormerlySerializedAs ("eventToSendValueOnUpdateState")]
+        public eventParameters.eventToCallWithIntAndFloat eventToSendValueOnUpdateStat;
+
+        public bool currentBoolState;
+
+        public eventParameters.eventToCallWithBool eventToInitializeBoolStat;
+
+        public eventParameters.eventToCallWithBool eventToActivateBoolStat;
+
+        public bool initializeStatWithThisValue = true;
+        public UnityEvent eventToInitializeStatOnComponent;
+        public UnityEvent eventToInitializeBoolStatOnComponent;
+
+        public bool useCustomStatTypeForEvents;
+        public statType customStatType;
+
+        public bool useMaxAmount;
+        public float maxAmount;
+        public bool useOtherStatAsMaxAmount;
+        public string otherStatAsMaxAmountName;
+
+        public bool useEventToSendValueOnUpdateStatExternally;
+
+        public eventParameters.eventToCallWithIntAndFloat eventToSendValueOnUpdateStatExternally;
+
+        public bool ignoreStatInitializationOnLoadGame;
+    }
+
+    [System.Serializable]
+    public class statTemplateInfo
+    {
+        public string Name;
+
+        public float currentValue;
+
+        public bool currentBoolState;
+    }
+}