Part 19 – Level Up Screen not showing

[Boby]

Helpful?

Up

0

::

Hello,

When I levelup my player, I don’t have my levelup screen apear. Here is my codes :

Player Datas :

using System.Collections.Generic;
using UnityEngine;
using System;
using UnityEngine.UI;
using TMPro;
namespace PLAYER{
public class Player_Datas : MonoBehaviour
{
// V2
//OBJECTIF : 
// All the value used for the Player
    [Header("STATS")]
    Character_Data data; //Get the data for the player
    [Tooltip("Save the base stat of the player so we can return it if needed")]
    public Character_Data.Stats baseStats; //Assign the player's data as the base stat
    [Tooltip("The actual stat is the current stat running and modifying during the game")]
    [SerializeField] Character_Data.Stats actualStats;

    public Character_Data.Stats Stats {
        get {return actualStats; }
        set { actualStats = value; }
    }

    //Note : HP is hidding on the inspector
    float hp;
    public float currentHp{
        get {return hp;}
        //Apply the modification on the UI pannel
        set{
            if(hp != value){
                hp = value;
                UpdateHP();
            }
        }
    }

    [SerializeField] Collect_Item collector;
    public bool isMagnetize;
    public float magnetRadius;

    //Invicible-Frames
    [Header("Invicibles Frames")]
    public float invincibleDuration = 0.5f;
    public float invincibleTime;
    public bool isInvincible;

    [Header("UI")]
    public Image hpBar;
    public Image expBar;
    public TMP_Text levelText;

    [Space(5)]

    [Header("Damage Effect")]
    public ParticleSystem damageEffect;

    [Header("Armor Effect")]
    public ParticleSystem armorEffect; //If the player completly block an attack

    [Space(5)]

    [Header("INVENTORY SYSTEM")]
    Player_Inventory inventory;
    public int weapon_Index;
    public int passiveItem_Index;

    [Space(5)]

    //LEVEL / EXPERIENCES
    [Header("LEVELUP SYSTEM")]
    public int exp = 0;
    public int level = 1;
    public int expCap;

    [System.Serializable]
    public class LevelRange{
        public int startLevel;
        public int endLevel;
        public int expIncrease;
    }

    [Header("LevelUP Stats")]
    public List<LevelRange> lvlRanges;

    void Awake()
    {
        data = Character_Type_Selection.GetData();

        if(Character_Type_Selection.instance)
            Character_Type_Selection.instance.DestroySingleton();

        inventory = GetComponentInChildren<Player_Inventory>();
        collector = GetComponentInChildren<Collect_Item>();

        baseStats = actualStats = data.stats;
        collector.SetRadius(actualStats.magnetForce);
        hp = actualStats.maxHP;
    }

    void Start(){
        //Spawn the starting weapon
        inventory.Add(data.startWeapon);

        //set the cap for the next level as the default expIncrease amount
        expCap = lvlRanges[0].expIncrease;

        GameManager.instance.AssignCharacterUI(data);

        UpdateHP();
        UpdateExp();
        UpdateLvl();

    }

    void Update(){

        //Set an Invicible frames to prevent continous dammage
        if(invincibleTime > 0)
            invincibleTime -= Time.deltaTime;
        else if(isInvincible)
            isInvincible = false;

        //Recovery
        Recover();
    }

    public void RecalulateStats(){
        actualStats = baseStats;
        foreach(Player_Inventory.Slot s in inventory.passive_Slots){
            Passive p = s.item as Passive;
            if(p)
                actualStats += p.GetBoosts();
        }
        collector.SetRadius(actualStats.magnetForce);
    }

    public void Increase_EXP(int amount){
        exp += amount;
        LevelUp();
        UpdateExp();
    }

    void LevelUp(){
        //Check if we level up
        if(exp >= expCap){
            level++; //ad 1 lvl
            exp -= expCap; //restart the exp to 0
            int expIncrease = 0;
            foreach(LevelRange range in lvlRanges ){
                if(level >= range.startLevel && level <= range.endLevel){
                    expIncrease = range.expIncrease;
                    break;
                }
            }
            expCap += expIncrease;

            UpdateLvl();

            GameManager.instance.StartLevelUp();

            //Verify if the next expCap is exceed after each levelup
            if(exp >= expCap) LevelUp();
        }
    }

    void UpdateExp(){
        //Update the ui of the exp bar
        expBar.fillAmount = (float)exp / expCap;
    }

    void UpdateLvl(){
        levelText.text = "LVL" + level.ToString();
    }

    public void TakeDamage(float damage){

        if(!isInvincible){

            //Take armor stat in acount before taking the damage
            //Deacrease the damage amount by the armor protection value
            damage -= actualStats.armor;

            if(damage > 0){
                //Deacrease the hp by the damage amount
                currentHp -= damage;

                //Play the damage effect if we have it
                if(damageEffect) Destroy(Instantiate(damageEffect, transform.position, Quaternion.identity), 5f);

                //Kill the Player if the hp is 0
                if(currentHp <= 0)
                    Kill();
            }
            //The damage is 0 = the armor completly block the damage
            else
                 //Play the damage effect if we have it
                if(armorEffect) Destroy(Instantiate(armorEffect, transform.position, Quaternion.identity), 5f);

            invincibleTime = invincibleDuration;
            isInvincible = true;
        }
    }

    void UpdateHP(){
        hpBar.fillAmount = currentHp / actualStats.maxHP;
    }

    public void RecoverHP(float amount){
        //Only heal the player if we have less than the max hp
        if(currentHp < actualStats.maxHP){
            currentHp += amount;

            //Limit the maximum hp
            if(currentHp > actualStats.maxHP)
                currentHp = actualStats.maxHP;

            UpdateHP();
        }
    }

    public void Kill(){
        if(!GameManager.instance.isGameOver){
            GameManager.instance.AssignLevelUP(level);
            GameManager.instance.GameOver();

            Debug.Log("Player dead");
        }
    }

    void Recover(){
        //Gradualy recover hp over time
        if(currentHp < actualStats.maxHP){
            //Increase each seconds
            currentHp += Stats.recovery * Time.deltaTime;

            //Limit the maximum amount by the max hp we can have
            if(currentHp > actualStats.maxHP)
                currentHp = actualStats.maxHP;

            UpdateHP();
        }
    }

    public void Restore_HP(int amount){
        //if we have less than the max hp, we can restore hp
        if(currentHp < actualStats.maxHP){
            currentHp += amount;
            //Limit the maximum amount by the max hp we can have
            if(currentHp > actualStats.maxHP)
                currentHp = actualStats.maxHP;
        }
    }

}
}


Player Inventory :

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
namespace PLAYER{
public class Player_Inventory : MonoBehaviour
{
[System.Serializable]
    //Manage the Slot
    public class Slot{
        public Item item;
        public Image image;

        //Assign a new item on the slot (Weapon or Passive Item)
        public void Assign(Item assignItem){
            item = assignItem;
            //Weapon Item
            if(item is Weapon){
                Weapon w = item as Weapon;
                image.enabled = true;
                image.sprite = w.data.icon;
            }
            //Passive item
            else{
                Passive w = item as Passive;
                image.enabled = true;
                image.sprite = w.data.icon;
            }
            Debug.Log($"Assigned : {item.name} to the player");
        }

        //Clear a slot where an item is assigned
        public void Clear(){
            item = null;
            image.enabled = false;
            image.sprite = null;
        }

        //Verify if the slot is empty
        public bool isEmpty() {return item == null;}
    }

    public List<Slot> weapon_Slots = new List<Slot>(6);
    public List<Slot> passive_Slots = new List<Slot>(6);

    [Header("UI Elements")]
    //List of all the upgrades options for : weapons, passive items and ui
    public List<Weapon_Data> available_Weapons = new List<Weapon_Data>();
    public List<Passive_Data> available_Passives = new List<Passive_Data>();
    public UI_UpgradeWindow upgradeWindow;

    Player_Datas player;

    void Awake(){
        player = GetComponent<Player_Datas>();
    }

    //Verify if the item has an item of a certain type
    public bool Has(Item_Data type) { return Get(type); }

    //ITEM TYPE
    public Item Get(Item_Data type){
        //Weapon type
        if(type is Weapon_Data) return Get(type as Weapon_Data);
        //Passive type
        if(type is Passive_Data) return Get(type as Passive_Data);
        //No type
        return null;
    }

    //FIND PASSIVE TYPE
    public Passive Get(Passive_Data type){
        foreach(Slot s in passive_Slots){
            Passive p = s.item as Passive;
            if(p.data && p.data == type) return p;
        }
        return null;
    }

    //FIND WEAPON TYPR
    public Weapon Get(Weapon_Data type){
        foreach(Slot s in weapon_Slots){
            Weapon w = s.item as Weapon;
            if(w.data && w.data == type) return w;
        }
        return null;
    }

    //Remove a Weapon of particular type
    public bool Remove(Weapon_Data data, bool canRemoveUpgrade = false){
        //Remove this weapon from the upgrading pool
        if(canRemoveUpgrade) available_Weapons.Remove(data);

        for(int i = 0; i < weapon_Slots.Count; i++){
            Weapon w = weapon_Slots[i].item as Weapon;
            if(w.data == data){
                weapon_Slots[i].Clear();
                w.UnEquip();
                Destroy(w.gameObject);
                return true;
            }
        }
        return false;
    }

    //Remove a Passive Item of particular type
    public bool Remove(Passive_Data data, bool canRemoveUpgrade = false){
        //Remove this weapon from the upgrading pool
        if(canRemoveUpgrade) available_Passives.Remove(data);

        for(int i = 0; i < available_Passives.Count; i++){
            Passive p = passive_Slots[i].item as Passive;
            if(p.data == data){
                passive_Slots[i].Clear();
                p.UnEquip();
                Destroy(p.gameObject);
                return true;
            }
        }
        return false;
    }

    public bool Remove(Item_Data data, bool canRemoveUpgrade = false){
        if(data is Passive_Data) return Remove(data as Passive_Data, canRemoveUpgrade);
        else if(data is Weapon_Data) return Remove(data as Weapon_Data, canRemoveUpgrade);
        return false;
    }

    //Find an empty slot, add the weapon of the certain type and return the slot index
    public int Add(Weapon_Data data){

        int slotNum = -1; //= = the first so -1 is outside

        //Search an empty slot
        for(int i = 0; i < weapon_Slots.Capacity; i++){
            if(weapon_Slots[i].isEmpty()){
                slotNum = i;
                break;
            }
        }

        //No Empty Slot exist
        if(slotNum < 0) return slotNum;

        //Create the weapon in the slot
        Type weaponType = Type.GetType(data.behaviour);

        if(weaponType != null){
            //Spawn the Weapon on the scene
            GameObject go = new GameObject(data.baseStats.name + "Weapon Controller");
            Weapon weaponSpawn = (Weapon)go.AddComponent(weaponType);
            weaponSpawn.transform.SetParent(transform);
            weaponSpawn.transform.localPosition = Vector2.zero;
            weaponSpawn.Initialize(data);
            weaponSpawn.OnEquip();

            //Assign it on the slot
            weapon_Slots[slotNum].Assign(weaponSpawn);

            //Close the LevelUP UI
            if(GameManager.instance != null && GameManager.instance.isLevelUP)
                GameManager.instance.EndLevelUp();

            return slotNum;
        }
        else
            Debug.LogWarning($"Invalid Weapon type for {data.name}");

        return -1;
    }

    //Find an empty slot, add the passive item of the certain type and return the slot index
    public int Add(Passive_Data data){

        int slotNum = -1; //= = the first so -1 is outside

        //Search an empty slot
        for(int i = 0; i < passive_Slots.Capacity; i++){
            if(passive_Slots[i].isEmpty()){
                slotNum = i;
                break;
            }
        }

        //No Empty Slot exist
        if(slotNum < 0) return slotNum;

        //Spawn the Weapon on the scene
        GameObject go = new GameObject(data.baseStats.name + "Passive Controller");
        Passive p = go.AddComponent<Passive>();
        p.Initialize(data);
        p.transform.SetParent(transform);
        p.transform.localPosition = Vector2.zero;

        //Assign it on the slot
        passive_Slots[slotNum].Assign(p);

        //Close the LevelUP UI
        if(GameManager.instance != null && GameManager.instance.isLevelUP)
            GameManager.instance.EndLevelUp();

        player.RecalulateStats();

        return slotNum;
    }

    //Determine the type if we don't know
    public int Add(Item_Data data){
        if(data is Weapon_Data) return Add(data as Weapon_Data);
        else if(data is Passive_Data) return Add(data as Passive_Data);
        return -1;
    }

    //Check for empty slot (if empty, we can add one item)
    int GetSlotsLeft(List<Slot> slots){
        int count = 0;
        foreach(Slot s in slots){ if(s.isEmpty()) count++; }
        return count;
    }

    //Levelup an item
    public bool LevelUP(Item item){
        if(!item.DoLevelUp()){
            Debug.LogWarning($"Failed to levelup {item.name}");
            return false;
        }
        if(GameManager.instance != null && GameManager.instance.isLevelUP){
            GameManager.instance.EndLevelUp();
        }
        if(item is Passive) player.RecalulateStats();
        return true;
    }
    public bool LevelUP(Item_Data data){
        Item item = Get(data);
        if(item) return LevelUP(item);
        return false;
    }

    //Determine the upgrade options to appear
    void ApplyUpgradeOptions(){
        //Available Upgrades in an empty list used for filtering
        List<Item_Data> available_Upgrades = new List<Item_Data>();
        //All the Upgrades
        List<Item_Data> all_Upgrades = new List<Item_Data>(available_Upgrades);
        all_Upgrades.AddRange(available_Upgrades);

        //Set how many slot upgrades left (default 6)
        int weapon_Slots_Left = GetSlotsLeft(weapon_Slots);
        int passive_Slots_Left = GetSlotsLeft(passive_Slots);

        //Loop inside the availables weapons and passive and find the possible updates
        foreach(Item_Data data in all_Upgrades){

            // 1 - Check if we already have a weapon/passive and if it is, check if our level is not the maximum
            Item obj = Get(data);
            if(obj)
                if(obj.level < data.maxLevel) available_Upgrades.Add(data);
            // 2 - We don't found this weapon/passive in our slot so check if we have enough space to add it
            else{
                if(data is Weapon_Data && weapon_Slots_Left > 0) available_Upgrades.Add(data);
                else if(data is Passive_Data && passive_Slots_Left > 0) available_Upgrades.Add(data);
            }
        }

        //Display the UI Windows Uograde
        int dispo_Upgrades_Count = available_Upgrades.Count;
        if(dispo_Upgrades_Count > 0){
            Debug.Log("dispo upgrades");
            bool getExtraItem = 1f - 1f / player.Stats.luck > UnityEngine.Random.value;
            if(getExtraItem || dispo_Upgrades_Count < upgradeWindow.maxOptions) upgradeWindow.SetUpgrades(this, available_Upgrades, upgradeWindow.maxOptions);
            else upgradeWindow.SetUpgrades(this, available_Upgrades, (upgradeWindow.maxOptions - 1), $"Increase your LUCK to get {upgradeWindow.maxOptions} Items !");
        }
        else if(GameManager.instance != null && GameManager.instance.isLevelUP)
            GameManager.instance.EndLevelUp();
    }

    public void RemoveAndApplyUpgrades(){
        ApplyUpgradeOptions();
    }
}
}


Game Manager :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.InputSystem;
using TMPro;
using PLAYER;
public class GameManager : MonoBehaviour
{
public static GameManager instance;
//Define the state of the game
public enum Game_State : byte{
    Gameplay,
    Paused,
    GameOver,
    LevelUp
}

//Store the current state of the game
[Tooltip("Track and apply the current state of the game")]
public Game_State state;
//Store the previous state
[Tooltip("Track the previous state of the game so we can go back if we change the state")]
public Game_State state_Previous;

[Header("Damage Text Settings")]
[Tooltip("Set a special canvas to show the damage effect on it")]
public Canvas damageTextCanvas;
[Tooltip("Set the font size of the damage text")]
public float textTypoSize = 20;
[Tooltip("Add a special font asset for the damage effect")]
public TMP_FontAsset textTypo;
[Tooltip("Set the camera of the game so we can track correctly the enemy and show the canvas")]
public Camera mainCamera;

[Header("Screens")]
public GameObject pause_Screen, highsore_Screen, levelUp_Screen;
int stackedLevels = 0;

[Header("Display Stats")]
//Pannel where all the stats are showing, the player can see them
public TMP_Text hp_Display;
public TMP_Text recovery_Display;
public TMP_Text moveSpeed_Display;
public TMP_Text might_Display;
public TMP_Text projectileSpeed_Display;
public TMP_Text magnetForce_Display;

[Header("Results Display")]
//A pannel resuming the final stats of the player after he died
public Image characterImage;
public TMP_Text characterName;
public TMP_Text levelReached;
public TMP_Text timeSurviveDisplay;

[Header("StopWatched")]
[Tooltip("Limit the maxium time limit of all the game.")]
public float timeLimit; //Limite of the time in seconds
float stopTime; //Current time elapsed since the time started
[Tooltip("Set the timer to display")]
public TMP_Text timerDisplay;

//Get the player
public GameObject playerObj;

[Tooltip("If the game state is Game Over, return the Pause Screen")]
public bool isGameOver {get {return state == Game_State.Paused; }}

[Tooltip("If the game state is Level UP, return the LevelUP Screen")]
public bool isLevelUP {get {return state == Game_State.LevelUp; }}

public float GetElapsedTime(){return stopTime; }

void Awake(){
    //Set only one instance of game manager or destroy the extras
    if(instance == null)
        instance = this;
    else
        Destroy(gameObject);

    DisableScreens();
}

void Update(){
    //Define the logic for each states
    switch(state){
        case Game_State.Gameplay:
            CheckForPauseAndResume();
            UpdateStopWatch();
            break;
        case Game_State.Paused:
            CheckForPauseAndResume();
            break;
        case Game_State.GameOver:
        case Game_State.LevelUp:
            break;
        default:
            Debug.Log("State not defined");
            break;
    }
}

public void ChangeState(Game_State newState){
    state_Previous = state; //Save the previous state to back easly
    state = newState; //Set the new state as the current state
}

public void PauseGame(){
    if(state != Game_State.Paused){
        ChangeState(Game_State.Paused);
        Time.timeScale = 0; //Stop the complete game time
        pause_Screen.SetActive(true);
    }
}

public void ResumeGame(){
    if(state == Game_State.Paused){
        ChangeState(state_Previous);
        Time.timeScale = 1; //Reset the complete game
        pause_Screen.SetActive(false);
    }
}

void CheckForPauseAndResume(){
    if(Input.GetKeyDown(KeyCode.Escape)){
        if(state == Game_State.Paused)
            ResumeGame();
        else
            PauseGame();
    }
}

void DisableScreens(){
    pause_Screen.SetActive(false);
    highsore_Screen.SetActive(false);
    levelUp_Screen.SetActive(false);
}

public void GameOver(){
    timeSurviveDisplay.text = timerDisplay.text;
    ChangeState(Game_State.GameOver);
    Time.timeScale = 0f;
    DisplayResults();
}

void DisplayResults(){
    highsore_Screen.SetActive(true);
}

public void AssignCharacterUI(Character_Data characterData){
    characterImage.sprite = characterData.icon;
    characterName.text = characterData.name;
}

public void StartLevelUp(){
    ChangeState(Game_State.LevelUp);
    if(levelUp_Screen.activeSelf) stackedLevels++;
    else{
        Time.timeScale = 0f;
        levelUp_Screen.SetActive(true);
        playerObj.SendMessage("RemoveAndApplyUpgrades");
    }

}

public void EndLevelUp(){
    Time.timeScale = 1f;
    levelUp_Screen.SetActive(false);
    ChangeState(Game_State.Gameplay);

    if(stackedLevels > 0){
        stackedLevels--;
        StartLevelUp();
    }
}

public void AssignLevelUP(int levelData){
    levelReached.text = levelData.ToString();
}

public void UpdateStopWatch(){
    stopTime += Time.deltaTime;
    UpdateStopWatchDisplay();

    if(stopTime >= timeLimit){
        playerObj.SendMessage("Kill");
    }

}

void UpdateStopWatchDisplay(){
    int minutes = Mathf.FloorToInt(stopTime/60);
    int seconds = Mathf.FloorToInt(stopTime % 60);

    timerDisplay.text = string.Format("{0:00}:{1:00}", minutes, seconds);
}

//note for me : not working too
IEnumerator GenerateFloatingText(string text, Transform target, float duration = 1f, float speed = 50f){
    //Start generating the floating text
    GameObject textObj = new GameObject("Damage Floating");
    RectTransform rect = textObj.AddComponent<RectTransform>();
    TextMeshProUGUI tmpro = textObj.AddComponent<TextMeshProUGUI>();
    tmpro.text = text;
    tmpro.horizontalAlignment = HorizontalAlignmentOptions.Center;
    tmpro.verticalAlignment = VerticalAlignmentOptions.Middle;
    tmpro.fontSize = textTypoSize;
    if(textTypo) tmpro.font = textTypo;
    rect.position = mainCamera.WorldToScreenPoint(target.position);

    //Destroy after the duration time
    Destroy(textObj, duration);

    //Parent to the canvas
    textObj.transform.SetParent(instance.damageTextCanvas.transform);
    textObj.transform.SetSiblingIndex(0);

    //Move and fade out the text
    WaitForEndOfFrame w = new WaitForEndOfFrame();
    float t = 0;
    float yOffset = 0;
    Vector3 lastPos = target.position;
    while(t < duration){

        //Break the loop if we don't have the rect transform
        if(!rect) break;

        //Fade out the text
        tmpro.color = new Color(tmpro.color.r, tmpro.color.g, tmpro.color.b, 1- t / duration);

        if(target) lastPos = target.position;

        //Move the text
        yOffset += speed * Time.deltaTime;
        rect.position = mainCamera.WorldToScreenPoint(lastPos + new Vector3(0, yOffset));

        //Wait a frame and update
        yield return w;
        t += Time.deltaTime;
    }
}

public static void FloatingText(string text, Transform target, float duration = 1f, float speed = 50f){

    //Prevent any error to oblige the canvas to be set, if not, do nothing
    if(!instance.damageTextCanvas) return;

    //If we have a canvas but the camera is not correctly set, set the main camera by default
    if(!instance.mainCamera) instance.mainCamera = Camera.main;

    //Start the effect
    instance.StartCoroutine(instance.GenerateFloatingText(text, target, duration, speed));
}
}


UI Upgrade Windows :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using PLAYER;
using TMPro;
[RequireComponent(typeof(VerticalLayoutGroup))]
public class UI_UpgradeWindow : MonoBehaviour
{
//Access to the padding / spacing on the layout
VerticalLayoutGroup verticalLayout;
//Main Upgrade pannel template
public RectTransform upgrade_Option_Template;
public TextMeshProUGUI tooltip_Template;

[Header("Settings")]
//Set the maximum number of options to display on screen
public int maxOptions = 4;
//The text to show when a new upgrade is availible
public string newText = "New";
//Color of the new text
public Color newText_Color = Color.red;
//Color of the level text
public Color levelText_Color = Color.black;

[Header("Paths Elements")]
//Set all the name inside the inspector
public string iconPath = "Icon Holder/Icon", namePath = "Info Holder/Name", descriptionPath = "Info Holder/Description", buttonPath = "Button", levelPath = "Icon Holder/Level";

//Private variables to track the comportement
//Rect Transform of the element
RectTransform rectTransform; 
//Default heign of the upgdrade ui
float option_Height;
//Track the number of options currently active on the pannel (new, level, etc)
int activeOptions;
//List of all the upgrades options (buttons)
List<RectTransform> upgradeOptions = new List<RectTransform>();
//Track the screen size each frame to be able to modify the size
Vector2 lastScreen;

public void SetUpgrades(Player_Inventory inventory, List<Item_Data> possible_Upgrades, int pick = 3, string tooltip = ""){

    //Define the number to show on screen
    pick = Mathf.Min(maxOptions, pick);

    //Create an upgrade if we don't have enough (the max options set is more than the real number of options )
    if(maxOptions > upgradeOptions.Count){
        for(int i = upgradeOptions.Count; i < pick; i++){
            GameObject go = Instantiate(upgrade_Option_Template.gameObject, transform);
            upgradeOptions.Add((RectTransform)go.transform);
        }
    }

    //Tooltip is provided, active the tooltip
    tooltip_Template.text = tooltip;
    tooltip_Template.gameObject.SetActive(tooltip.Trim() != ""); //Verify if it's not empty

    //Activate only the number of upgrades options we need.
    activeOptions = 0;
    int totalOptions = possible_Upgrades.Count;
    foreach(RectTransform r in upgradeOptions){
        if(activeOptions < pick && activeOptions < totalOptions){
            //Show the upgrade
            r.gameObject.SetActive(true);

            //Select randomly one upgrade possible and remove it from the list of availables (prevent duplicatas)
            Item_Data upgrade_Selected = possible_Upgrades[Random.Range(0, possible_Upgrades.Count)];
            possible_Upgrades.Remove(upgrade_Selected);
            Item item = inventory.Get(upgrade_Selected);

            // ----------------------------- NAME ------------------------------------ //
            //Select the name text in the UI
            TextMeshProUGUI name = r.Find(namePath).GetComponent<TextMeshProUGUI>();
            //Apply the name of the selected upgrade on the UI
            if(name) name.text = upgrade_Selected.name;
            // ------------------------------------------------------------------------ //


            // ----------------------------- LEVEL ------------------------------------ //
            //Add the level or the "New" text if it's a new item
            //Select the name text in the UI
            TextMeshProUGUI level = r.Find(levelPath).GetComponent<TextMeshProUGUI>();
            //Level found
            if(level){

                //The Player has this item so we update the level to match
                if(item){
                    //The item is on his max level
                    if(item.level >= item.maxLevel){
                        level.text = "Maximum !";
                        level.color = newText_Color;
                    }
                    //Update the level (adding +1 lvl provide the next level of the item)
                    else{
                        level.text = upgrade_Selected.GetLevelData(item.level + 1).name;
                        level.color = levelText_Color;
                    }
                }
                //The Player don't have this item, add the NEW text
                else{
                    level.text = newText;
                    level.color = newText_Color;
                }
            }//level
            // ----------------------------------------------------------------------- //

            // --------------------------- DESCRIPTION ------------------------------- //
            //Select the description text in the UI
            TextMeshProUGUI description = r.Find(descriptionPath).GetComponent<TextMeshProUGUI>();

            //Description found
            if(description){
                //The Player has this item so we levelup it to promote the next level of this item
                if(item)
                    description.text = upgrade_Selected.GetLevelData(item.level + 1).description;
                //The Player don't have this item so we display the level 1
                else
                    description.text = upgrade_Selected.GetLevelData(1).description;
            }
            // ----------------------------------------------------------------------- //

            // ------------------------------  ICON  --------------------------------- //
            //Select the icon image in the UI
            Image icon = r.Find(iconPath).GetComponent<Image>();

            //Icon founnd
            if(icon) icon.sprite = upgrade_Selected.icon;
            // ----------------------------------------------------------------------- //

            //Get the button 
            Button btn = r.Find(buttonPath).GetComponent<Button>();
            //Button found
            if(btn){
                //Clear
                btn.onClick.RemoveAllListeners();
                //Player has this item so levelup the current item on the inventory
                if(item)
                    btn.onClick.AddListener(() => inventory.LevelUP(item));
                //Player don't have this item, add it to the inventory
                else
                    btn.onClick.AddListener(() => inventory.Add(upgrade_Selected));
            }

            activeOptions++;
        }//if activeOptions
        //Don't find any options, disable the pannel
        else r.gameObject.SetActive(false);
    }//foreach loop

    //Sizes all the elemtnto fit correctly
    RecalulateLayout();
}

//Called when the size of the windows change.
void RecalulateLayout(){
    // Calculate the total available height for all options, 
    // then divides it by the number of options to perfectly fit 
    // all the upgrades inside the layout.
    option_Height = (rectTransform.rect.height - verticalLayout.padding.top - verticalLayout.padding.bottom - (maxOptions - 1) * verticalLayout.spacing);

    // Maximum options display
    if(activeOptions == maxOptions && tooltip_Template.gameObject.activeSelf)
        option_Height /= maxOptions + 1;
    //Les than maximum
    else
        option_Height /= maxOptions;

    //Recalculates the height of the tooltip if it's currently active
    if(tooltip_Template.gameObject.activeSelf){
        RectTransform tooltipRect = (RectTransform)tooltip_Template.transform;
        tooltip_Template.gameObject.SetActive(true);
        tooltipRect.sizeDelta = new Vector2(tooltipRect.sizeDelta.x, option_Height);
        tooltip_Template.transform.SetAsLastSibling();
    }

    //Set the height of every active Upgrades Option
    foreach(RectTransform r in upgradeOptions){
        if(!r.gameObject.activeSelf) continue;
        r.sizeDelta = new Vector2(r.sizeDelta.x, option_Height);
    }
}

//Track and apply modifications every frames
void Update(){
    if(lastScreen.x != Screen.width || lastScreen.y != Screen.height){
        RecalulateLayout();
        lastScreen = new Vector2(Screen.width, Screen.height);
    }
}

void Awake(){
    verticalLayout = GetComponentInChildren<VerticalLayoutGroup>();
    if(tooltip_Template) tooltip_Template.gameObject.SetActive(false);
    if(upgrade_Option_Template) upgradeOptions.Add(upgrade_Option_Template);
    rectTransform = (RectTransform)transform;
}

void Reset(){
    //Automaticaly find a game object named "Upgrade Options" and set it as the upgrade_Option_Template
    upgrade_Option_Template = (RectTransform)transform.Find("Upgrade Option");

    //Automaticaly find a game object named "Tooltip" and set it as the tooltip_Template
    tooltip_Template = transform.Find("Tooltip").GetComponentInChildren<TextMeshProUGUI>();
}
}


My SetUpgrades is not calling from my ApplyUpgradeOptions that is not calling from my RemoveAndApplyUpgrades that is not calling from the Game Manager but the levelUp of my player data is calling and my LevelUp from my Game Manager as well.
Thank you for your help

[Terence]

Helpful?

Up

0

::

Sorry for missing your message Boby. You posted it in the wrong forum and I missed it.

Can you add the following into the GameManager? Then let me know if the “Level up screen activated” message prints when you level up.

    public void StartLevelUp(){
        ChangeState(Game_State.LevelUp);
        if(levelUp_Screen.activeSelf) stackedLevels++;
        else{
            Time.timeScale = 0f;
            print("Level up screen activated");
            levelUp_Screen.SetActive(true);
            playerObj.SendMessage("RemoveAndApplyUpgrades");
        }

}</pre>

[Author]

Posts