add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Experience System/playerExperienceSystem.cs

@@ -0,0 +1,923 @@
+using System.Collections;
+using System.Collections.Generic;
+using GameKitController.Audio;
+using UnityEngine;
+
+using UnityEngine.Events;
+using UnityEngine.UI;
+
+public class playerExperienceSystem : MonoBehaviour
+{
+    public bool experienceSystemEnabled = true;
+
+    public string XPExtraString = " XP";
+
+    public List<levelInfo> levelInfoList = new List<levelInfo> ();
+
+    public List<statUIInfo> statUIInfoList = new List<statUIInfo> ();
+
+    public int currentLevelExperienceAmount;
+
+    public int currentLevelExperienceToNextLevel;
+
+    public int totalExperienceAmount;
+
+    public int totalExperiencePoints;
+
+    public int currentLevel = 1;
+
+    public int totalExperienceAmountLimit = 9999999;
+
+    public float experienceTextMovementSpeed;
+    public float experienceTextMovementDelay;
+
+    public float timeToShowLevelUpPanel;
+
+    [Range (0, 1)] public float experienceAmountTextOffset;
+
+    public bool useMaxLevel;
+    public int maxLevel;
+
+    public bool hideExperienceSliderAfterTime;
+    public float timeToHideExperienceSlider;
+
+    public bool experienceMenuActive = true;
+    public bool experienceMenuOpened;
+
+    public float currentExperienceMultiplier = 1;
+    public bool experienceMultiplerEnabled;
+    public GameObject experienceMultiplierTextPanel;
+    public Text experienceMultiplerText;
+    public UnityEvent eventOnExperienceMultiplerEnabled;
+    public UnityEvent eventOnExperienceMultiplerDisabled;
+
+    public string extraTextOnLevelNumber = "LV ";
+    public string extraTextOnNewLevelNumber = "LV ";
+
+    public string totalExperiencePointsName = "Skill Points";
+    public string totalExperienceAmountName = "Experience";
+    public string currentLevelExperienceAmountName = "Current Level Experience Amount";
+    public string currentLevelExperienceToNextLevelName = "Current Level Experience To Next Level Amount";
+    public string currentLevelName = "Level";
+
+    public bool setLevelManually;
+
+    public eventParameters.eventToCallWithString eventOnExperienceWithoutTextPosition;
+
+    public Transform experienceSliderPanelPositionInsideMenu;
+    public Transform experienceSliderPanelPositionOutsideMenu;
+
+    public GameObject statsMenuPanel;
+
+    public UnityEvent eventOnExperienceMenuOpened;
+    public UnityEvent eventOnExperienceMenuClosed;
+
+    public playerController playerControllerManager;
+    public playerCamera mainPlayerCamera;
+    public GameObject experienceMenuGameObject;
+    public GameObject experienceObtaniedTextPrefab;
+    public Transform experienceObtainedTextParent;
+
+    public Text currentLevelText;
+
+    public GameObject levelUpPanel;
+
+    public Text levelUpText;
+
+    public RectTransform experienceTextTargetPosition;
+    public RectTransform experienceSliderTransform;
+
+    public Slider experienceSlider;
+
+    public GameObject experienceSliderPanel;
+
+    public bool playSoundOnLevelUpEnabled = true;
+
+    public AudioSource levelUpAudioSource;
+    public AudioClip levelUpAudioClip;
+    public AudioElement levelUpAudioElement;
+
+    public playerSkillsSystem playerSkillManager;
+    public playerStatsSystem playerStatsManager;
+    public Camera mainCamera;
+    public menuPause pauseManager;
+
+    public bool useEventIfSystemDisabled;
+    public UnityEvent eventIfSystemDisabled;
+
+    public bool callEventOnLevelReachedOnLoadEnabled = true;
+
+    public string menuPanelName = "Experience System";
+
+    Vector2 mainCanvasSizeDelta;
+    Vector2 halfMainCanvasSizeDelta;
+
+    Vector2 iconPosition2d;
+    bool usingScreenSpaceCamera;
+    Vector3 screenPoint;
+    bool targetOnScreen;
+
+    Coroutine showLevelUpCoroutine;
+
+    Coroutine showSliderCoroutine;
+
+    float angle;
+    float cos;
+    float sin;
+    float m;
+    Vector3 screenBounds;
+    Vector3 screenCenter;
+
+    levelInfo currentLevelInfo;
+
+    bool startInitialized;
+
+    float screenWidth;
+    float screenHeight;
+
+    bool isLoadingGame;
+
+    private void InitializeAudioElements ()
+    {
+        if (levelUpAudioSource != null) {
+            levelUpAudioElement.audioSource = levelUpAudioSource;
+        }
+
+        if (levelUpAudioClip != null) {
+            levelUpAudioElement.clip = levelUpAudioClip;
+        }
+    }
+
+    void Start ()
+    {
+        InitializeAudioElements ();
+
+        if (!experienceSystemEnabled) {
+            checkEventOnSystemDisabled ();
+
+            if (experienceSliderPanel.activeSelf) {
+                experienceSliderPanel.SetActive (false);
+            }
+
+            return;
+        }
+
+        mainCanvasSizeDelta = mainPlayerCamera.getMainCanvasSizeDelta ();
+        halfMainCanvasSizeDelta = mainCanvasSizeDelta * 0.5f;
+        usingScreenSpaceCamera = mainPlayerCamera.isUsingScreenSpaceCamera ();
+
+        if (setLevelManually && currentLevel > 1) {
+            for (int i = 0; i < currentLevel; i++) {
+
+                currentLevelInfo = levelInfoList [i];
+
+                totalExperienceAmount += currentLevelInfo.experienceRequiredToNextLevel;
+
+                if (i + 1 <= levelInfoList.Count) {
+
+                    currentLevelInfo = levelInfoList [i + 1];
+
+                    currentLevelInfo.eventsOnLevelReached.Invoke ();
+
+                    currentLevelInfo.levelUnlocked = true;
+
+                    totalExperiencePoints += currentLevelInfo.experiencePointsAmount;
+
+                    currentLevelExperienceToNextLevel = currentLevelInfo.experienceRequiredToNextLevel;
+                }
+            }
+        }
+
+        if (callEventOnLevelReachedOnLoadEnabled) {
+            isLoadingGame = playerSkillManager.isLoadingGameActive ();
+
+            if (isLoadingGame) {
+                if (currentLevel > 1) {
+                    for (int i = 0; i < currentLevel; i++) {
+
+                        currentLevelInfo = levelInfoList [i];
+
+                        if (currentLevelInfo.levelNumber <= currentLevel) {
+                            if (currentLevelInfo.callEventOnLevelReachedOnLoad) {
+                                currentLevelInfo.eventsOnLevelReached.Invoke ();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        playerStatsManager.updateStatValue (totalExperiencePointsName, totalExperiencePoints);
+
+        playerStatsManager.updateStatValue (currentLevelExperienceToNextLevelName, currentLevelExperienceToNextLevel);
+
+        playerStatsManager.updateStatValue (currentLevelExperienceAmountName, currentLevelExperienceAmount);
+
+        playerStatsManager.updateStatValue (totalExperienceAmountName, totalExperienceAmount);
+
+        updateExperienceInfo ();
+
+        if (hideExperienceSliderAfterTime) {
+            if (experienceSliderPanel.activeSelf) {
+                experienceSliderPanel.SetActive (false);
+            }
+        }
+
+        StartCoroutine (initializeComponent ());
+    }
+
+    public void checkEventOnSystemDisabled ()
+    {
+        if (useEventIfSystemDisabled) {
+            eventIfSystemDisabled.Invoke ();
+        }
+    }
+
+    public bool checkIncreasePlayerLevel ()
+    {
+        if (useMaxLevel) {
+            if (currentLevel >= maxLevel) {
+                return false;
+            }
+        }
+
+        if (currentLevel <= levelInfoList.Count) {
+
+            currentLevelInfo = levelInfoList [currentLevel - 1];
+
+            if (currentLevelExperienceAmount >= currentLevelInfo.experienceRequiredToNextLevel) {
+
+                if (currentLevel + 1 <= levelInfoList.Count) {
+                    currentLevel++;
+
+                    currentLevelInfo = levelInfoList [currentLevel - 1];
+
+                    currentLevelInfo.eventsOnLevelReached.Invoke ();
+
+                    currentLevelInfo.levelUnlocked = true;
+
+                    currentLevelExperienceAmount = currentLevelExperienceAmount - levelInfoList [currentLevel - 2].experienceRequiredToNextLevel;
+
+                    totalExperiencePoints += currentLevelInfo.experiencePointsAmount;
+
+                    updateExperienceInfo ();
+
+                    if (startInitialized) {
+                        showLevelUpPanel ();
+                    }
+
+                    currentLevelExperienceToNextLevel = currentLevelInfo.experienceRequiredToNextLevel;
+
+                    for (int k = 0; k < currentLevelInfo.statInfoList.Count; k++) {
+
+                        if (currentLevelInfo.statInfoList [k].statIsAmount) {
+                            float extraValue = currentLevelInfo.statInfoList [k].statExtraValue;
+                            if (currentLevelInfo.statInfoList [k].useRandomRange) {
+                                extraValue = Random.Range (currentLevelInfo.statInfoList [k].randomRange.x, currentLevelInfo.statInfoList [k].randomRange.y);
+
+                                extraValue = Mathf.RoundToInt (extraValue);
+                            }
+
+                            playerStatsManager.increasePlayerStat (currentLevelInfo.statInfoList [k].Name, extraValue);
+                        } else {
+                            playerStatsManager.enableOrDisableBoolPlayerStat (currentLevelInfo.statInfoList [k].Name, currentLevelInfo.statInfoList [k].newBoolState);
+                        }
+
+                        if (currentLevelInfo.statInfoList [k].unlockSkill) {
+                            playerSkillManager.unlockSkillSlotByName (currentLevelInfo.statInfoList [k].skillNameToUnlock);
+                        }
+                    }
+
+                    playerStatsManager.updateStatValue (totalExperiencePointsName, totalExperiencePoints);
+
+                    playerStatsManager.updateStatValue (currentLevelExperienceToNextLevelName, currentLevelExperienceToNextLevel);
+
+                    playerStatsManager.updateStatValue (currentLevelExperienceAmountName, currentLevelExperienceAmount);
+
+                    playerStatsManager.updateStatValue (currentLevelName, currentLevel);
+
+                    return true;
+                } else {
+
+                    if (currentLevelExperienceAmount > levelInfoList [currentLevel - 1].experienceRequiredToNextLevel) {
+                        currentLevelExperienceAmount = levelInfoList [currentLevel - 1].experienceRequiredToNextLevel;
+                    }
+
+                    if (totalExperienceAmount > totalExperienceAmountLimit) {
+                        totalExperienceAmount = totalExperienceAmountLimit;
+                    }
+
+                    playerStatsManager.updateStatValue (totalExperienceAmountName, totalExperienceAmount);
+                    playerStatsManager.updateStatValue (currentLevelExperienceAmountName, currentLevelExperienceAmount);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public void getExperienceAmount (int newExperienceAmount)
+    {
+        if (!experienceSystemEnabled) {
+            return;
+        }
+
+        getExperienceAmount (newExperienceAmount, null, false, "");
+    }
+
+    public void getExperienceAmount (int newExperienceAmount, Transform objectTransform, bool useTransformAsExpTextPosition, string extraExperienceText)
+    {
+        if (!experienceSystemEnabled) {
+            return;
+        }
+
+        newExperienceAmount *= (int)currentExperienceMultiplier;
+
+        totalExperienceAmount += newExperienceAmount;
+
+        currentLevelExperienceAmount += newExperienceAmount;
+
+        experienceSlider.value = currentLevelExperienceAmount;
+
+        playerStatsManager.updateStatValue (totalExperienceAmountName, totalExperienceAmount);
+        playerStatsManager.updateStatValue (currentLevelExperienceAmountName, currentLevelExperienceAmount);
+
+        float experienceAcumulated = currentLevelExperienceAmount;
+
+        if (checkIncreasePlayerLevel ()) {
+            for (int k = 0; k < levelInfoList.Count; k++) {
+                if (!levelInfoList [k].levelUnlocked) {
+
+                    experienceAcumulated -= levelInfoList [currentLevel - 1].experienceRequiredToNextLevel;
+
+                    if (experienceAcumulated > 0) {
+                        checkIncreasePlayerLevel ();
+                    }
+                }
+            }
+        }
+
+        if (!startInitialized) {
+            return;
+        }
+
+        if (hideExperienceSliderAfterTime) {
+            if (!experienceSliderPanel.activeSelf) {
+                experienceSliderPanel.SetActive (true);
+            }
+
+            showExperienceSlider ();
+        }
+
+        if (mainCamera == null) {
+            mainCamera = mainPlayerCamera.getMainCamera ();
+        }
+
+        if (useTransformAsExpTextPosition) {
+            if (!usingScreenSpaceCamera) {
+                screenWidth = Screen.width;
+                screenHeight = Screen.height;
+            }
+
+            Vector3 objectPosition = objectTransform.position;
+
+            if (usingScreenSpaceCamera) {
+                screenPoint = mainCamera.WorldToViewportPoint (objectPosition);
+                targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
+            } else {
+                screenPoint = mainCamera.WorldToScreenPoint (objectPosition);
+                targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
+            }
+
+            GameObject newExperienceText = (GameObject)Instantiate (experienceObtaniedTextPrefab, Vector3.zero, Quaternion.identity, experienceObtainedTextParent);
+
+            newExperienceText.transform.localScale = Vector3.one;
+
+            if (!newExperienceText.activeSelf) {
+                newExperienceText.SetActive (true);
+            }
+
+            experienceObtainedInfo currentexperienceObtainedInfo = newExperienceText.GetComponent<experienceObtainedInfoPanel> ().experienceObtainedInfo;
+
+            if (usingScreenSpaceCamera) {
+                if (targetOnScreen) {
+                    iconPosition2d = new Vector2 ((screenPoint.x * mainCanvasSizeDelta.x) - halfMainCanvasSizeDelta.x,
+                        (screenPoint.y * mainCanvasSizeDelta.y) - halfMainCanvasSizeDelta.y);
+
+                    currentexperienceObtainedInfo.experienceObtainedRectTransform.anchoredPosition = iconPosition2d;
+                } else {
+                    iconPosition2d = new Vector2 ((screenPoint.x * mainCanvasSizeDelta.x) - halfMainCanvasSizeDelta.x,
+                        (screenPoint.y * mainCanvasSizeDelta.y) - halfMainCanvasSizeDelta.y);
+
+                    if (screenPoint.z < 0) {
+                        iconPosition2d *= -1;
+                    }
+
+                    angle = Mathf.Atan2 (iconPosition2d.y, iconPosition2d.x);
+                    angle -= 90 * Mathf.Deg2Rad;
+                    cos = Mathf.Cos (angle);
+                    sin = -Mathf.Sin (angle);
+                    m = cos / sin;
+                    screenBounds = halfMainCanvasSizeDelta * experienceAmountTextOffset;
+                    if (cos > 0) {
+                        iconPosition2d = new Vector2 (screenBounds.y / m, screenBounds.y);
+                    } else {
+                        iconPosition2d = new Vector2 (-screenBounds.y / m, -screenBounds.y);
+                    }
+
+                    if (iconPosition2d.x > screenBounds.x) {
+                        iconPosition2d = new Vector2 (screenBounds.x, screenBounds.x * m);
+                    } else if (iconPosition2d.x < -screenBounds.x) {
+                        iconPosition2d = new Vector2 (-screenBounds.x, -screenBounds.x * m);
+                    }
+
+                    currentexperienceObtainedInfo.experienceObtainedRectTransform.anchoredPosition = iconPosition2d;
+                }
+            } else {
+                if (targetOnScreen) {
+                    currentexperienceObtainedInfo.experienceObtainedRectTransform.position = new Vector3 (screenPoint.x, screenPoint.y, 0);
+                } else {
+                    if (screenPoint.z < 0) {
+                        screenPoint *= -1;
+                    }
+
+                    screenCenter = new Vector3 (screenWidth, screenHeight, 0) / 2;
+                    screenPoint -= screenCenter;
+                    angle = Mathf.Atan2 (screenPoint.y, screenPoint.x);
+                    angle -= 90 * Mathf.Deg2Rad;
+                    cos = Mathf.Cos (angle);
+                    sin = -Mathf.Sin (angle);
+                    m = cos / sin;
+                    screenBounds = screenCenter * experienceAmountTextOffset;
+                    if (cos > 0) {
+                        screenPoint = new Vector3 (screenBounds.y / m, screenBounds.y, 0);
+                    } else {
+                        screenPoint = new Vector3 (-screenBounds.y / m, -screenBounds.y, 0);
+                    }
+
+                    if (screenPoint.x > screenBounds.x) {
+                        screenPoint = new Vector3 (screenBounds.x, screenBounds.x * m, 0);
+                    } else if (screenPoint.x < -screenBounds.x) {
+                        screenPoint = new Vector3 (-screenBounds.x, -screenBounds.x * m, 0);
+                    }
+
+                    //set the position and rotation of the arrow
+                    screenPoint += screenCenter;
+
+                    currentexperienceObtainedInfo.experienceObtainedRectTransform.position = screenPoint;
+                }
+            }
+
+            currentexperienceObtainedInfo.experienceAmountText.text = newExperienceAmount + XPExtraString;
+            currentexperienceObtainedInfo.experienceAmount = newExperienceAmount;
+
+            currentexperienceObtainedInfo.moveExperienceTextPanel = StartCoroutine (moveExperienceTextPanelCoroutine (currentexperienceObtainedInfo));
+        } else {
+            eventOnExperienceWithoutTextPosition.Invoke (extraExperienceText + newExperienceAmount + XPExtraString);
+        }
+    }
+
+    IEnumerator moveExperienceTextPanelCoroutine (experienceObtainedInfo currentExperienceObtainedInfo)
+    {
+        yield return new WaitForSeconds (experienceTextMovementDelay);
+
+        float dist = GKC_Utils.distance (currentExperienceObtainedInfo.experienceObtainedRectTransform.position, experienceSliderTransform.position);
+
+        float duration = dist / experienceTextMovementSpeed;
+
+        float t = 0;
+
+        Vector2 targetPosition = experienceTextTargetPosition.position;
+
+        Vector2 currentPosition = currentExperienceObtainedInfo.experienceObtainedRectTransform.position;
+
+        float movementTimer = 0;
+
+        bool targetReached = false;
+        Vector2 experienceAmountPosition = Vector2.zero;
+        Vector2 experienceSliderTransformPosition = Vector2.zero;
+        float distance = 0;
+
+        while (!targetReached) {
+            t += Time.deltaTime / duration;
+
+            currentExperienceObtainedInfo.experienceObtainedRectTransform.position =
+                Vector2.Lerp (currentExperienceObtainedInfo.experienceObtainedRectTransform.position, targetPosition, t);
+
+            experienceAmountPosition = new Vector2 (currentExperienceObtainedInfo.experienceObtainedRectTransform.position.y, 0);
+            experienceSliderTransformPosition = new Vector2 (targetPosition.y, 0);
+
+            distance = GKC_Utils.distance (experienceAmountPosition, experienceSliderTransformPosition);
+
+            movementTimer += Time.deltaTime;
+
+            if (distance < 0.01f || movementTimer > (duration + 1)) {
+                targetReached = true;
+            }
+
+            yield return null;
+        }
+
+        Destroy (currentExperienceObtainedInfo.experienceObtainedRectTransform.gameObject);
+
+        StopCoroutine (currentExperienceObtainedInfo.moveExperienceTextPanel);
+    }
+
+    public void updateExperienceInfo ()
+    {
+        experienceSlider.maxValue = levelInfoList [currentLevel - 1].experienceRequiredToNextLevel;
+
+        experienceSlider.value = currentLevelExperienceAmount;
+
+        if (extraTextOnLevelNumber != "") {
+            currentLevelText.text = extraTextOnLevelNumber;
+        }
+
+        currentLevelText.text += currentLevel;
+    }
+
+    public void showLevelUpPanel ()
+    {
+        stopShowLevelUpPanelCoroutine ();
+
+        showLevelUpCoroutine = StartCoroutine (showLevelUpPanelCoroutine ());
+    }
+
+    public void stopShowLevelUpPanelCoroutine ()
+    {
+        if (showLevelUpCoroutine != null) {
+            StopCoroutine (showLevelUpCoroutine);
+        }
+    }
+
+    IEnumerator showLevelUpPanelCoroutine ()
+    {
+        if (playSoundOnLevelUpEnabled) {
+
+            if (levelUpAudioElement != null) {
+                AudioPlayer.PlayOneShot (levelUpAudioElement, gameObject);
+            }
+        }
+
+        if (!levelUpPanel.activeSelf) {
+            levelUpPanel.SetActive (true);
+        }
+
+        if (extraTextOnNewLevelNumber != "") {
+            levelUpText.text = extraTextOnNewLevelNumber;
+        }
+
+        levelUpText.text += currentLevel;
+
+        yield return new WaitForSeconds (timeToShowLevelUpPanel);
+
+        levelUpPanel.SetActive (false);
+    }
+
+    public void showExperienceSlider ()
+    {
+        stopShowExperienceSliderCoroutine ();
+
+        showSliderCoroutine = StartCoroutine (showExperienceSliderCoroutine ());
+    }
+
+    public void stopShowExperienceSliderCoroutine ()
+    {
+        if (showSliderCoroutine != null) {
+            StopCoroutine (showSliderCoroutine);
+        }
+    }
+
+    IEnumerator showExperienceSliderCoroutine ()
+    {
+        yield return new WaitForSeconds (timeToHideExperienceSlider);
+
+        if (experienceSliderPanel.activeSelf) {
+            experienceSliderPanel.SetActive (false);
+        }
+    }
+
+    public void openOrCloseExperienceMenu (bool state)
+    {
+        if (state) {
+            if (!pauseManager.checkIfMenuCanBeUsedByName (menuPanelName)) {
+                return;
+            }
+        }
+
+        bool checkResult =
+            (!playerControllerManager.isPlayerMenuActive () || experienceMenuOpened) &&
+            (!playerControllerManager.isUsingDevice () || playerControllerManager.isPlayerDriving ()) &&
+            !pauseManager.isGamePaused ();
+
+        if (checkResult) {
+            experienceMenuOpened = state;
+
+            pauseManager.openOrClosePlayerMenu (experienceMenuOpened, experienceMenuGameObject.transform, true);
+
+            experienceMenuGameObject.SetActive (experienceMenuOpened);
+
+            pauseManager.setIngameMenuOpenedState (menuPanelName, experienceMenuOpened, true);
+
+            pauseManager.enableOrDisablePlayerMenu (experienceMenuOpened, true, false);
+
+            if (experienceMenuOpened) {
+                updateStatsInfo ();
+
+                experienceSliderPanel.transform.SetParent (experienceSliderPanelPositionInsideMenu);
+
+                if (hideExperienceSliderAfterTime) {
+                    if (!experienceSliderPanel.activeSelf) {
+                        experienceSliderPanel.SetActive (true);
+                    }
+                }
+
+                eventOnExperienceMenuOpened.Invoke ();
+            } else {
+                experienceSliderPanel.transform.SetParent (experienceSliderPanelPositionOutsideMenu);
+
+                if (hideExperienceSliderAfterTime) {
+                    if (experienceSliderPanel.activeSelf) {
+                        experienceSliderPanel.SetActive (false);
+                    }
+                }
+
+                eventOnExperienceMenuClosed.Invoke ();
+            }
+
+            experienceSliderPanel.transform.localPosition = Vector3.zero;
+        }
+    }
+
+    public void enableOrDisableHUD (bool state)
+    {
+        if (!hideExperienceSliderAfterTime) {
+            if (experienceSliderPanel.activeSelf != state) {
+                experienceSliderPanel.SetActive (state);
+            }
+        }
+    }
+
+    public void openOrCLoseObjectiveMenuFromTouch ()
+    {
+        openOrCloseExperienceMenu (!experienceMenuOpened);
+    }
+
+    public void inputOpenOrCloseObjectiveMenu ()
+    {
+        if (experienceMenuActive) {
+
+            if (pauseManager.isOpenOrClosePlayerOpenMenuByNamePaused ()) {
+                return;
+            }
+
+            openOrCloseExperienceMenu (!experienceMenuOpened);
+        }
+    }
+
+    public void updateStatsInfo ()
+    {
+        for (int i = 0; i < statUIInfoList.Count; i++) {
+            if (statUIInfoList [i].statIsAmount) {
+                statUIInfoList [i].statAmountText.text =
+                    statUIInfoList [i].extraTextAtStart + playerStatsManager.getStatValue (statUIInfoList [i].Name) + statUIInfoList [i].extraTextAtEnd;
+            } else {
+                statUIInfoList [i].statAmountText.text =
+                    statUIInfoList [i].extraTextAtStart + playerStatsManager.getBoolStatValue (statUIInfoList [i].Name) + statUIInfoList [i].extraTextAtEnd;
+            }
+        }
+    }
+
+    public void initializeCurrentLevelExperienceAmount (float newValue)
+    {
+        currentLevelExperienceAmount = (int)newValue;
+
+        updateComponent ();
+    }
+
+    public void initializeTotalExperienceAmount (float newValue)
+    {
+        totalExperienceAmount = (int)newValue;
+
+        updateComponent ();
+    }
+
+    public void initializeTotalExperiencePointsAmount (float newValue)
+    {
+        totalExperiencePoints = (int)newValue;
+
+        updateComponent ();
+    }
+
+    public void initializeCurrentLevelAmount (float newValue)
+    {
+        currentLevel = (int)newValue;
+
+        updateComponent ();
+    }
+
+    public void increaseTotalExperiencePointsAmount (float extraValue)
+    {
+        totalExperiencePoints += (int)extraValue;
+    }
+
+    public void increaseTotalExperienceAmount (float extraValue)
+    {
+        totalExperienceAmount += ((int)extraValue * (int)currentExperienceMultiplier);
+    }
+
+    public void initializeCurrentLevelExperienceToNextLevelAmount (float newValue)
+    {
+        currentLevelExperienceToNextLevel = (int)newValue;
+
+        updateComponent ();
+    }
+
+    public void updateCurrentLevelAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        currentLevel = (int)amount;
+    }
+
+    public void updateTotalExperiencePointsAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        totalExperiencePoints = (int)amount;
+    }
+
+    public void updateTotalExperienceAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        totalExperienceAmount = (int)amount;
+    }
+
+    public void updateCurrentLevelExperienceToNextLevelAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        currentLevelExperienceToNextLevel = (int)amount;
+    }
+
+    public void updateCurrentLevelExperienceAmountWithoutUpdatingStatManager (int statId, float amount)
+    {
+        currentLevelExperienceAmount = (int)amount;
+    }
+
+    public int getCurrentLevel ()
+    {
+        return currentLevel;
+    }
+
+    public int getSkillPointsAmount ()
+    {
+        return totalExperiencePoints;
+    }
+
+    public void useSkillPoints (int amountToUse)
+    {
+        totalExperiencePoints -= amountToUse;
+
+        if (totalExperiencePoints < 0) {
+            totalExperiencePoints = 0;
+        }
+
+        playerStatsManager.updateStatValue (totalExperiencePointsName, totalExperiencePoints);
+
+        updateStatsInfo ();
+    }
+
+    public void getSkillPoints (int amountToUse)
+    {
+        totalExperiencePoints += amountToUse;
+
+        playerStatsManager.updateStatValue (totalExperiencePointsName, totalExperiencePoints);
+    }
+
+    Coroutine experienceMultiplierCoroutine;
+
+    public void setExperienceMultiplier (float experienceMultiplierAmount, float experienceMultiplierDuration)
+    {
+        stopSetExperienceMultiplier ();
+
+        experienceMultiplierCoroutine = StartCoroutine (setExperienceMultiplierCoroutine (experienceMultiplierAmount, experienceMultiplierDuration));
+    }
+
+    public void stopSetExperienceMultiplier ()
+    {
+        if (experienceMultiplierCoroutine != null) {
+            StopCoroutine (experienceMultiplierCoroutine);
+        }
+    }
+
+    IEnumerator setExperienceMultiplierCoroutine (float experienceMultiplierAmount, float experienceMultiplierDuration)
+    {
+        currentExperienceMultiplier = experienceMultiplierAmount;
+
+        experienceMultiplerEnabled = true;
+
+        eventOnExperienceMultiplerEnabled.Invoke ();
+
+        if (!experienceMultiplierTextPanel.activeSelf) {
+            experienceMultiplierTextPanel.SetActive (true);
+        }
+
+        experienceMultiplerText.text = currentExperienceMultiplier.ToString ();
+
+        yield return new WaitForSeconds (experienceMultiplierDuration);
+
+        currentExperienceMultiplier = 1;
+
+        experienceMultiplerEnabled = true;
+
+        eventOnExperienceMultiplerDisabled.Invoke ();
+
+        experienceMultiplierTextPanel.SetActive (false);
+    }
+
+    IEnumerator initializeComponent ()
+    {
+        yield return new WaitForSeconds (0.3f);
+
+        startInitialized = true;
+    }
+
+    public void enableOrDisableStatsMenuPanel (bool state)
+    {
+        if (statsMenuPanel.activeSelf != state) {
+            statsMenuPanel.SetActive (state);
+        }
+    }
+
+    public void setExperienceSystemEnabledState (bool state)
+    {
+        experienceSystemEnabled = state;
+    }
+
+    public void setHideExperienceSliderAfterTimeState (bool state)
+    {
+        hideExperienceSliderAfterTime = state;
+    }
+
+    void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+
+        GKC_Utils.updateDirtyScene ("Update Experience System ", gameObject);
+    }
+
+    [System.Serializable]
+    public class levelInfo
+    {
+        public string Name;
+        public int levelNumber;
+        public int experienceRequiredToNextLevel;
+
+        public int experiencePointsAmount;
+
+        public bool levelUnlocked;
+
+        public List<statInfo> statInfoList = new List<statInfo> ();
+
+        public UnityEvent eventsOnLevelReached;
+
+        public bool callEventOnLevelReachedOnLoad;
+    }
+
+    [System.Serializable]
+    public class statInfo
+    {
+        public string Name;
+
+        public bool statIsAmount = true;
+
+        public float statExtraValue;
+
+        public bool useRandomRange;
+        public Vector2 randomRange;
+
+        public bool newBoolState;
+
+        public bool unlockSkill;
+        public string skillNameToUnlock;
+    }
+
+    [System.Serializable]
+    public class experienceObtainedInfo
+    {
+        public RectTransform experienceObtainedRectTransform;
+
+        public Text experienceAmountText;
+
+        public int experienceAmount;
+
+        public Coroutine moveExperienceTextPanel;
+    }
+
+    [System.Serializable]
+    public class statUIInfo
+    {
+        public string Name;
+
+        public Text statAmountText;
+
+        public string extraTextAtStart;
+        public string extraTextAtEnd;
+
+        public bool statIsAmount = true;
+    }
+}