XiuXianGame/Assets/Scripts/GameUI/UI/GongFaUpgradePanel/GongFaUpgradePanel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Core.Audio;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Combat.Buff;
using GameLogic.Hero;
using GameLogic.Player;
using UnityEngine;
using UnityEngine.UI;
using Utility;

namespace Fort23.Mono
{
    [UIBinding(prefab = "GongFaUpgradePanel")]
    public partial class GongFaUpgradePanel : UIPanel
    {
        private SkillInfo _skillInfo;
        private List<SkillConfig> configs;
        List<GongFaUpgradeInfoWidget> _gongFaUpgradeInfoWidgets = new List<GongFaUpgradeInfoWidget>();

        private List<SkillPowerupConfig> _skillPowerupConfigs;
        // private SkillConstant skillConstant;

        List<ItemWidgetType1> _itemWidgetType1 = new List<ItemWidgetType1>();
        private List<SkillInfo> _skillInfos = new List<SkillInfo>();

        // List<EnergyWidget> _energyWidgets = new List<EnergyWidget>();

        bool isUpStar = false;

        bool isUpGrad = false;

        private void Init()
        {
            isAddStack = true;
            IsShowAppBar = false;
        }

        public async override CTask GetFocus()
        {
            // await AppBarPanel.OpenPanel(this);
            base.GetFocus();
        }

        protected override void AddEvent()
        {
            Text_GongFaDesc.onClickCallBack = OnClickBuff;
        }

        protected override void DelEvent()
        {
        }

        public async override CTask<bool> AsyncInit(object[] uiData)
        {
            _skillInfo = uiData[0] as SkillInfo;
            List<SkillConfig> allSkillConfigs = ConfigComponent.Instance.GetAll<SkillConfig>().ToList();
            configs = allSkillConfigs.Where(s => s.IDGroup == _skillInfo.skillConfig.IDGroup).ToList();
            using (CTaskAwaitBuffer<GongFaUpgradeInfoWidget> cts = new CTaskAwaitBuffer<GongFaUpgradeInfoWidget>())
            {
                for (var i = 0; i < configs.Count; i++)
                {
                    if (configs[i].level == 1)
                        continue;
                    SkillInfo skillInfo1 =
                        new SkillInfo(configs[i].IDGroup, _skillInfo.SkillPowerupConfig.ID, configs[i].level);
                    _skillInfos.Add(skillInfo1);
                    cts.AddTask(UIManager.Instance.CreateGComponent<GongFaUpgradeInfoWidget>(null, Content));
                }

                _gongFaUpgradeInfoWidgets = await cts.WaitAll();
            }


            return await base.AsyncInit(uiData);
        }

        public override void AddButtonEvent()
        {
            Btn_Back.onClick.AddListener(() =>
            {
                if (isUpStar || isUpGrad)
                {
                    isUpStar = false;
                    isUpGrad = false;
                    UpdateStarBtn();
                    return;
                }

                UIManager.Instance.HideUIUIPanel<GongFaUpgradePanel>();
            });

            Btn_UpGradeOk.onClick.AddListener(() => { UpgradeClick(); });


            Btn_UpGrade.onClick.AddListener(() => { UpgradeClick(); });

            Btn_UpStar.onClick.AddListener(() => { UpStarClick(); });
            Btn_UpStarOk.onClick.AddListener(() => { UpStarClick(); });

            Btn_UpGradeOkLongPress.longPress = () => { UpgradeClick(); };

            Btn_Rest.onClick.AddListener(async () =>
            {
                bool relust = await TipsPanle.OpenPnael(10799);
                if (!relust)
                {
                    return;
                }

                Dictionary<int, ItemInfo> itemInfo = new Dictionary<int, ItemInfo>();

                for (int i = 1; i < _skillInfo.SkillPowerupConfig.ID; i++)
                {
                    SkillPowerupConfig skillPowerupConfig = ConfigComponent.Instance.Get<SkillPowerupConfig>(i);
                    for (var i1 = 0; i1 < skillPowerupConfig.LevelupItem.Length; i1++)
                    {
                        if (itemInfo.ContainsKey(skillPowerupConfig.LevelupItem[i1]))
                        {
                            itemInfo[skillPowerupConfig.LevelupItem[i1]].count += skillPowerupConfig.LevelupItemNum[i1];
                        }
                        else
                        {
                            itemInfo.Add(skillPowerupConfig.LevelupItem[i1], new ItemInfo(
                                skillPowerupConfig.LevelupItem[i1],
                                skillPowerupConfig.LevelupItemNum[i1]));
                        }
                    }
                }

                // ItemConfig itemConfig = ConfigComponent.Instance.Get<ItemConfig>(_skillInfo.skillConfig.PieceID);
                //
                // SkillConstant skillConstant = ConfigComponent.Instance.Get<SkillConstant>(itemConfig.quality);
                // int count = 0;
                // for (int i = 0; i < _skillInfo.skillConfig.level - 1; i++)
                // {
                //     count += skillConstant.SkillPromoteNeedPieceNum[i];
                // }
                //
                // if (count > 0)
                // {
                //     if (itemInfo.ContainsKey(_skillInfo.skillConfig.PieceID))
                //     {
                //         itemInfo[_skillInfo.skillConfig.PieceID].count += count;
                //     }
                //     else
                //     {
                //         itemInfo.Add(_skillInfo.skillConfig.PieceID, new ItemInfo(_skillInfo.skillConfig.PieceID,
                //             count));
                //     }
                // }


                // _skillInfo.SkillData.star = 1;
                _skillInfo.SkillData.level = 1;
                _skillInfo.CustomInt(_skillInfo.SkillData);
                PlayerManager.Instance.myHero.ComputeHeroInfo();
                CustomInit(_skillInfo);
                foreach (var keyValuePair in itemInfo)
                {
                    //TODO 功法重置
                    PlayerManager.Instance.BagController.AddItem(keyValuePair.Value);
                }

                RewardsPanel.OpenPanel(itemInfo);
            });
        }

        private void UpStarClick()
        {
            if (!isUpStar)
            {
                isUpStar = true;
                UpdateStarBtn();
                return;
            }

            if (_skillInfo.SkillData == null)
            {
                return;
            }

            if (_skillInfo.SkillData.star > _gongFaUpgradeInfoWidgets.Count)
            {
                AudioManager.Instance.PlayAudio("ui_chaozuoshibai.wav");
                TipMessagePanel.OpenTipMessagePanel(10850);
                return;
            }

            ItemConfig itemConfig = ConfigComponent.Instance.Get<ItemConfig>(_skillInfo.skillConfig.PieceID);

            SkillConstant skillConstant = ConfigComponent.Instance.Get<SkillConstant>(itemConfig.quality);

            int count = skillConstant.SkillPromoteNeedPieceNum[_skillInfo.skillConfig.level - 1];

            //TODO 消耗：功法升星
            if (!PlayerManager.Instance.BagController.DeductItem(_skillInfo.skillConfig.PieceID, count))
            {
                AudioManager.Instance.PlayAudio("ui_chaozuoshibai.wav");
                ItemSourcePanel.OpenPanel(_skillInfo.skillConfig.PieceID);

                return;
            }


            _skillInfo.SkillData.star++;
            _skillInfo.CustomInt(_skillInfo.SkillData);
            PlayerManager.Instance.myHero.ComputeHeroInfo();
            CustomInit(_skillInfo);

            foreach (var gongFaUpgradeInfoWidget in _gongFaUpgradeInfoWidgets)
            {
                if (gongFaUpgradeInfoWidget._skillInfo.skillConfig.level == _skillInfo.skillConfig.level)
                {
                    gongFaUpgradeInfoWidget.fx_ui_gongfa_tiaomu.gameObject.SetActive(true);
                    gongFaUpgradeInfoWidget.fx_ui_gongfa_tiaomu.Play();
                    break;
                }
            }

            AudioManager.Instance.PlayAudio("ui_tycg.wav");
            AccountFileInfo.Instance.SavePlayerData();
        }

        private async void UpgradeClick()
        {
            if (_skillInfo.SkillData == null)
            {
                return;
            }

            if (!isUpGrad)
            {
                isUpGrad = true;
                UpdateStarBtn();
                return;
            }

            if (_skillInfo.SkillData.level >= _skillPowerupConfigs.Count)
            {
                TipMessagePanel.OpenTipMessagePanel(10851);
                AudioManager.Instance.PlayAudio("ui_chaozuoshibai.wav");
                return;
            }

            if (PlayerManager.Instance.myHero.level.Value < _skillInfo.SkillPowerupConfig.PlayerLevelLimit)
            {
                AudioManager.Instance.PlayAudio("ui_chaozuoshibai.wav");
                HeroPowerUpConfig heroPowerUpConfig =
                    ConfigComponent.Instance.Get<HeroPowerUpConfig>(_skillInfo.SkillPowerupConfig.PlayerLevelLimit);
                string jingjie = LanguageManager.Instance.Text(heroPowerUpConfig.jingjieLanIDs[0]) +
                                 LanguageManager.Instance.Text(heroPowerUpConfig.jingjieLanIDs[1]) +
                                 LanguageManager.Instance.Text(heroPowerUpConfig.jingjieLanIDs[2]);
                TipMessagePanel.OpenTipMessagePanel(LanguageManager.Instance.Text(10852, jingjie));
                return;
            }

            for (var i = 0; i < _skillInfo.SkillPowerupConfig.LevelupItem.Length; i++)
            {
                if (!PlayerManager.Instance.BagController.IsEnough(_skillInfo.SkillPowerupConfig.LevelupItem[i],
                        _skillInfo.SkillPowerupConfig.LevelupItemNum[i]))
                {
                    AudioManager.Instance.PlayAudio("ui_chaozuoshibai.wav");
                    ItemSourcePanel.OpenPanel(_skillInfo.SkillPowerupConfig.LevelupItem[i]);
                    return;
                }
            }

            //扣除道具
            for (var i = 0; i < _skillInfo.SkillPowerupConfig.LevelupItem.Length; i++)
            {
                //TODO 消耗：功法升级
                PlayerManager.Instance.BagController.DeductItem(_skillInfo.SkillPowerupConfig.LevelupItem[i],
                    _skillInfo.SkillPowerupConfig.LevelupItemNum[i]);
            }


            // fx_ui_gongfa_shengji.gameObject.SetActive(true);
            // fx_ui_gongfa_shengji.Play();
            AudioManager.Instance.PlayAudio("ui_fbgfsj.wav");


            _skillInfo.SkillData.level++;
            _skillInfo.CustomInt(_skillInfo.SkillData);
            PlayerManager.Instance.myHero.ComputeHeroInfo();
            CustomInit(_skillInfo);
            AccountFileInfo.Instance.SavePlayerData();
            ParticleSystemPool particleSystemPool =
                await GObjectPool.Instance.FetchAsync<ParticleSystemPool>("fx_ui_gongfa_shengji.prefab");
            particleSystemPool.own.transform.parent = fx_ui_gongfa_shengji.transform.parent;
            particleSystemPool.own.transform.position = fx_ui_gongfa_shengji.transform.position;
        }

        private int index = 0;

        public async void CustomInit(SkillInfo skillInfo)
        {
            index = 0;
            for (var i = 0; i < configs.Count; i++)
            {
                if (configs[i].level == 1)
                    continue;

                _gongFaUpgradeInfoWidgets[index].CustomInit(_skillInfo, _skillInfos[index], false);
                index++;
            }

            Btn_Rest.gameObject.SetActive(_skillInfo.SkillPowerupConfig.ID > 1);
            RedDotComType02.CustomInit(13, _skillInfo);
            RedDotComType01.CustomInit(12, _skillInfo);
            _skillPowerupConfigs = ConfigComponent.Instance.GetAll<SkillPowerupConfig>().ToList();
            SkillConfig skillConfig = _skillInfo.skillConfig;
            Icon_GongFaIcon.icon_name = skillConfig.icon;
            Text_Level1.text = LanguageManager.Instance.Text(10222, _skillInfo.SkillPowerupConfig.ID.ToString());
            Text_Level.text = LanguageManager.Instance.Text(10222, _skillInfo.SkillPowerupConfig.ID.ToString());

            Text_SkillCd.text = LanguageManager.Instance.Text(10208, skillConfig.addcd);

            ItemConfig itemConfig = ConfigComponent.Instance.Get<ItemConfig>(skillConfig.PieceID);

            if (itemConfig.quality == 3)
            {
                QualityCsc.ChangeState(0);
                Text_Quality.text = LanguageManager.Instance.Text(10797);
            }
            else if (itemConfig.quality == 4)
            {
                QualityCsc.ChangeState(1);
                Text_Quality.text = LanguageManager.Instance.Text(10796);
            }
            else if (itemConfig.quality == 5)
            {
                QualityCsc.ChangeState(2);
                Text_Quality.text = LanguageManager.Instance.Text(10795);
            }

            // skillConstant = ConfigComponent.Instance.Get<SkillConstant>(1);


            UpdateStarBtn();

            // Text_GongFaDesc.text =
            //     UtilTools.GetString(LanguageManager.Instance.Text(skillConfig.dec), _skillInfo.effectValue);
            Text_GongFaName.text = LanguageManager.Instance.Text(skillConfig.name) + " ";
            LayoutRebuilder.ForceRebuildLayoutImmediate(Text_GongFaName.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(Text_Level.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(Text_GongFaName.transform.parent.GetComponent<RectTransform>());

            switch (skillConfig.attribute)
            {
                case 1:
                    csc.ChangeState(0);
                    Icon_Attribute.icon_name = "dec_jin2";
                    break;
                case 4:
                    csc.ChangeState(1);
                    Icon_Attribute.icon_name = "dec_mu2";
                    break;
                case 2:
                    csc.ChangeState(2);
                    Icon_Attribute.icon_name = "dec_shui2";
                    break;
                case 8:
                    csc.ChangeState(3);
                    Icon_Attribute.icon_name = "dec_huo2";
                    break;
                case 16:
                    csc.ChangeState(4);
                    Icon_Attribute.icon_name = "dec_tu2";
                    break;

                case 0:
                    csc.ChangeState(5);
                    Icon_Attribute.icon_name = "dec_fuzhu2";
                    break;
            }

            for (var i = 0; i < StarRoot.Count; i++)
            {
                MyImage icon = StarRoot[i] as MyImage;
                if (i < skillInfo.skillConfig.level - 1)
                {
                    icon.gameObject.SetActive(true);
                }
                else
                {
                    icon.gameObject.SetActive(false);
                }
            }
        }

        private async CTask UpdateStarBtn()
        {
            foreach (var itemWidgetType1 in _itemWidgetType1)
            {
                UIManager.Instance.DormancyGComponent(itemWidgetType1);
            }

            _itemWidgetType1.Clear();

            // foreach (var energyWidget in _energyWidgets)
            // {
            //     UIManager.Instance.DormancyGComponent(energyWidget);
            // }
            //
            // _energyWidgets.Clear();


            if (isUpGrad)
            {
                Btn_UpStar.gameObject.SetActive(false);
                Btn_UpGrade.gameObject.SetActive(false);
                Btn_UpStarOk.gameObject.SetActive(false);
                Btn_UpGradeOk.gameObject.SetActive(true);
                if (_skillInfo.SkillData.level < _skillPowerupConfigs.Count)
                {
                    AccountFileInfo.SkillData skillData = new AccountFileInfo.SkillData();
                    skillData.id = _skillInfo.SkillData.id;
                    skillData.level = _skillInfo.SkillData.level + 1;
                    skillData.star = _skillInfo.SkillData.star;

                    SkillInfo nextSkillInfo = new SkillInfo(skillData);

                    string[] effs = new string[_skillInfo.effectValue.Length];
                    for (var i = 0; i < _skillInfo.effectValue.Length; i++)
                    {
                        if (_skillInfo.effectValue[i] == nextSkillInfo.effectValue[i])
                        {
                            effs[i] = FormatNumber(_skillInfo.effectValue[i]);
                        }
                        else
                        {
                            effs[i] =
                                $"{FormatNumber(_skillInfo.effectValue[i])}<color=green>→({FormatNumber(nextSkillInfo.effectValue[i])})</color>";
                        }
                    }


                    Text_NextLevel.transform.parent.gameObject.SetActive(true);
                    Text_NextLevel.text = LanguageManager.Instance.Text(10221, _skillInfo.SkillPowerupConfig.ID,
                        nextSkillInfo.SkillPowerupConfig.ID);

                    LayoutRebuilder.ForceRebuildLayoutImmediate(Text_NextLevel.GetComponent<RectTransform>());
                    LayoutRebuilder.ForceRebuildLayoutImmediate(Text_NextLevel.transform.parent
                        .GetComponent<RectTransform>());
                    Text_GongFaDesc.text =
                        UtilTools.GetString(LanguageManager.Instance.Text(_skillInfo.skillConfig.dec), effs);
                    Text_GongFaDesc.onClickCallBack = OnClickBuff;
                    // Btn_UpGrade.GetComponent<RectTransform>().sizeDelta = new Vector2(481, 80);
                    if (PlayerManager.Instance.myHero.level.Value < _skillInfo.SkillPowerupConfig.PlayerLevelLimit)
                    {
                        HeroPowerUpConfig heroPowerUpConfig =
                            ConfigComponent.Instance.Get<HeroPowerUpConfig>(_skillInfo.SkillPowerupConfig
                                .PlayerLevelLimit);
                        string jingjie = LanguageManager.Instance.Text(heroPowerUpConfig.jingjieLanIDs[0]) +
                                         LanguageManager.Instance.Text(heroPowerUpConfig.jingjieLanIDs[1]) +
                                         LanguageManager.Instance.Text(heroPowerUpConfig.jingjieLanIDs[2]);
                        Text_UpGrade.text =LanguageManager.Instance.Text(10852,jingjie);
                        Btn_UpGradeOk.gameObject.transform.Gray(true);
                        UpGradeItemRoot.SetActive(false);
                    }
                    else
                    {
                        Btn_UpGradeOk.gameObject.transform.RecoverColor();
                        Text_UpGrade.text = LanguageManager.Instance.Text(10220);
                        UpGradeItemRoot.SetActive(true);
                        for (var i = 0; i < _skillInfo.SkillPowerupConfig.LevelupItem.Length; i++)
                        {
                            ItemWidgetType1 itemWidgetType1 =
                                await UIManager.Instance.CreateGComponentForObject<ItemWidgetType1>(ItemWidgetType1Gam,
                                    null, UpGradeItemRoot.GetComponent<RectTransform>(), isInstance: true);
                            itemWidgetType1.CustomInit(_skillInfo.SkillPowerupConfig.LevelupItem[i],
                                _skillInfo.SkillPowerupConfig.LevelupItemNum[i]);
                            _itemWidgetType1.Add(itemWidgetType1);

                            // EnergyWidget energyWidget =
                            //     await UIManager.Instance.CreateGComponent<EnergyWidget>(null, EnergyRoot);
                            // energyWidget.CustomInit(_skillInfo.SkillPowerupConfig.LevelupItem[i]);
                            // _energyWidgets.Add(energyWidget);
                        }

                        // Text_GongFaDesc.text = UtilTools.GetString(LanguageManager.Instance.Text(_skillInfo.skillConfig.dec), _skillInfo.effectValue);
                    }
                }
                else
                {
                    Text_NextLevel.transform.parent.gameObject.SetActive(true);

                    Text_NextLevel.text = LanguageManager.Instance.Text(10221, _skillInfo.skillConfig.level,
                        "Max");
                    Text_UpGrade.text = LanguageManager.Instance.Text(10264);
                    // Btn_UpStarOk.gameObject.SetActive(false);
                    UpGradeItemRoot.SetActive(false);
                }
            }


            if (isUpStar)
            {
                foreach (var gongFaUpgradeInfoWidget in _gongFaUpgradeInfoWidgets)
                {
                    gongFaUpgradeInfoWidget.SelectWidget(true);
                }

                Btn_UpStar.gameObject.SetActive(false);
                Btn_UpGrade.gameObject.SetActive(false);
                Btn_UpGradeOk.gameObject.SetActive(false);
                Btn_UpStarOk.gameObject.SetActive(true);
                if (_skillInfo.skillConfig.level < 6)
                {
                    Btn_UpStarOk.gameObject.transform.RecoverColor();
                    Text_UpStar.text = LanguageManager.Instance.Text(10219);

                    UpStarItemRoot.SetActive(true);
                    ItemConfig itemConfig = ConfigComponent.Instance.Get<ItemConfig>(_skillInfo.skillConfig.PieceID);

                    SkillConstant skillConstant = ConfigComponent.Instance.Get<SkillConstant>(itemConfig.quality);

                    int count = skillConstant.SkillPromoteNeedPieceNum[_skillInfo.skillConfig.level - 1];
                    ItemWidgetType1 itemWidgetType1 =
                        await UIManager.Instance.CreateGComponentForObject<ItemWidgetType1>(ItemWidgetType1Gam, null,
                            UpStarItemRoot.GetComponent<RectTransform>(), isInstance: true);
                    itemWidgetType1.CustomInit(_skillInfo.skillConfig.PieceID, count);
                    _itemWidgetType1.Add(itemWidgetType1);
                }
                else
                {
                    Btn_UpStarOk.transform.Gray(true);
                    Text_UpStar.text = LanguageManager.Instance.Text(10265);
                    // Btn_UpStarOk.gameObject.SetActive(false);
                    UpStarItemRoot.SetActive(false);
                }
            }


            if (!isUpGrad && !isUpStar)
            {
                Btn_UpGrade.gameObject.SetActive(true);
                Btn_UpStar.gameObject.SetActive(true);
                Btn_UpGradeOk.gameObject.SetActive(false);
                Btn_UpStarOk.gameObject.SetActive(false);
                UpStarItemRoot.SetActive(false);
                UpGradeItemRoot.SetActive(false);
                Text_UpStar.text = LanguageManager.Instance.Text(10219);
                Text_UpGrade.text = LanguageManager.Instance.Text(10220);
                Btn_UpGradeOk.gameObject.transform.RecoverColor();
                foreach (var gongFaUpgradeInfoWidget in _gongFaUpgradeInfoWidgets)
                {
                    gongFaUpgradeInfoWidget.SelectWidget(false);
                }

                Text_NextLevel.transform.parent.gameObject.SetActive(false);
                string[] effs = new string[_skillInfo.effectValue.Length];
                for (var i = 0; i < _skillInfo.effectValue.Length; i++)
                {
                    effs[i] = FormatNumber(_skillInfo.effectValue[i]);
                }

                Text_GongFaDesc.text = UtilTools.GetString(LanguageManager.Instance.Text(_skillInfo.skillConfig.dec),
                    effs);
            }

            LayoutRebuilder.ForceRebuildLayoutImmediate(UpStarItemRoot.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(UpGradeItemRoot.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(Text_UpStar.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(Text_UpGrade.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(UpGradeItemRoot.transform.parent.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(UpStarItemRoot.transform.parent.GetComponent<RectTransform>());
            LayoutRebuilder.ForceRebuildLayoutImmediate(Btn_UpGrade.GetComponent<RectTransform>());
        }

        public async static CTask<GongFaUpgradePanel> Open(SkillInfo skillInfo)
        {
            GongFaUpgradePanel gongFaUpgradePanel =
                await UIManager.Instance.LoadAndOpenPanel<GongFaUpgradePanel>(null, uiData: new object[] { skillInfo });
            gongFaUpgradePanel.CustomInit(skillInfo);
            return gongFaUpgradePanel;
        }

        private void OnClickBuff(string info)
        {
            int buffId = 0;
            if (int.TryParse(info, out buffId))
            {
                BuffInfo buffInfo = BuffInfo.GetBuffInfo(buffId, 1, null);
                SkillInfopanel.OpenPanle(buffInfo);
            }
        }

        public async override CTask Close()
        {
            foreach (var gongFaUpgradeInfoWidget in _gongFaUpgradeInfoWidgets)
            {
                UIManager.Instance.DormancyGComponent(gongFaUpgradeInfoWidget);
            }

            foreach (var itemWidgetType1 in _itemWidgetType1)
            {
                UIManager.Instance.DormancyGComponent(itemWidgetType1);
            }

            _skillInfos.Clear();
            //
            // foreach (var energyWidget in _energyWidgets)
            // {
            //     UIManager.Instance.DormancyGComponent(energyWidget);
            // }
            //
            // _energyWidgets.Clear();
            fx_ui_gongfa_shengji.gameObject.SetActive(false);
            _itemWidgetType1.Clear();
            _gongFaUpgradeInfoWidgets.Clear();
            isUpStar = false;
            isUpGrad = false;
            _skillInfo = null;
            await base.Close();
        }

        public static string FormatNumber(double number)
        {
            const double tolerance = 1e-10;

            // 判断是否接近整数
            if (Math.Abs(number - Math.Round(number)) < tolerance)
            {
                return Math.Round(number).ToString();
            }

            double integerPart = Math.Truncate(number);
            double fraction = number - integerPart;

            // 检查小数部分是否超过一位
            double firstDigit = Math.Truncate(fraction * 10);
            double remainder = fraction * 10 - firstDigit;

            if (Math.Abs(remainder) > tolerance)
            {
                return Math.Round(number, 1).ToString("0.0");
            }
            else
            {
                return integerPart.ToString();
            }
        }
    }
}