XiuXianGame/Assets/Scripts/GameUI/UI/BoxPanel/OpenBoxScorePanel.cs

using System.Collections.Generic;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Player;

namespace Fort23.Mono
{
    [UIBinding(prefab = "OpenBoxScorePanel")]
    public partial class OpenBoxScorePanel : UIPanel
    {
        List<SummonScoreRuleWidget> summonScoreRuleWidgets = new List<SummonScoreRuleWidget>();
        List<SummonScoreAwardWidget> summonScoreAwardWidgets = new List<SummonScoreAwardWidget>();
        AccountFileInfo.SummonData summonData;
        private OpenBoxProgressReward[] openBoxProgressRewards;

        OpenBoxConfig openBoxConfig;

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

        protected override void AddEvent()
        {
        }

        protected override void DelEvent()
        {
        }

        public override CTask GetFocus()
        {
            TitlePanel.ClosePanel();
            return base.GetFocus();
        }

        public override void AddButtonEvent()
        {
            Btn_Ok.onClick.AddListener(() =>
            {
                summonData.isSummonSocre = true;
                AccountFileInfo.Instance.SavePlayerData();
                Btn_Ok.gameObject.SetActive(!summonData.isSummonSocre);
                StartRoot.gameObject.SetActive(summonData.isSummonSocre);
                if (summonData.isSummonSocre)
                {
                    Text_JingDu.text = LanguageManager.Instance.Text(10836, summonData.drawHistory.Count * 10,
                        openBoxConfig.ProgressRewardChoukaCount);
                     
                    Text_Score.text = LanguageManager.Instance.Text(10261,summonData.score);
                }
            });
        }

        public async override CTask<bool> AsyncInit(object[] uiData)
        {
            summonData = PlayerManager.Instance.SummonManager.summonDataMap[2];
            openBoxConfig = ConfigComponent.Instance.Get<OpenBoxConfig>(summonData.id);
            openBoxProgressRewards = ConfigComponent.Instance.GetAll<OpenBoxProgressReward>();
            Btn_Ok.gameObject.SetActive(!summonData.isSummonSocre);
            StartRoot.gameObject.SetActive(summonData.isSummonSocre);
            if (summonData.isSummonSocre)
            {
                Text_JingDu.text =
                    LanguageManager.Instance.Text(10836, summonData.drawHistory.Count * 10,
                        openBoxConfig.ProgressRewardChoukaCount);
                Text_Score.text =  LanguageManager.Instance.Text(10261,summonData.score);
            }

            using (CTaskAwaitBuffer cts =
                   new CTaskAwaitBuffer())
            {
                cts.AddTask(CreatSummonScoreRuleWidget());
                cts.AddTask(CreatSummonScoreAwardWidget());
                await cts.WaitAll();
            }

            for (var i = summonScoreAwardWidgets.Count - 1; i >= 0; i--)
            {
                if (summonData.score >= summonScoreAwardWidgets[i]._openBoxProgressReward.TotalScore)
                {
                    summonScoreAwardWidgets[i].Icon_Select.gameObject.SetActive(true);

                    if (summonData.drawHistory.Count * 10 >= openBoxConfig.ProgressRewardChoukaCount)
                    {
                        summonScoreAwardWidgets[i].Btn_LingQu.gameObject.SetActive(true);
                    }

                    break;
                }
            }

            return await base.AsyncInit(uiData);
        }

        private async CTask CreatSummonScoreRuleWidget()
        {
            List<OpenBoxScoreRule> openBoxScoreRules = PlayerManager.Instance.SummonManager.openBoxScoreRuleMap[2];
            using (CTaskAwaitBuffer<SummonScoreRuleWidget> ctb =
                   new CTaskAwaitBuffer<SummonScoreRuleWidget>())
            {
                for (var i = 0; i < openBoxScoreRules.Count; i++)
                {
                    ctb.AddTask(
                        UIManager.Instance.CreateGComponent<SummonScoreRuleWidget>(null, Content1));
                }

                summonScoreRuleWidgets = await ctb.WaitAll();
            }

            for (var i = 0; i < openBoxScoreRules.Count; i++)
            {
                summonScoreRuleWidgets[i].CustomInit(openBoxScoreRules[i], i);
            }
        }


        private async CTask CreatSummonScoreAwardWidget()
        {
            using (CTaskAwaitBuffer<SummonScoreAwardWidget> ctb =
                   new CTaskAwaitBuffer<SummonScoreAwardWidget>())
            {
                for (var i = 0; i < openBoxProgressRewards.Length; i++)
                {
                    ctb.AddTask(
                        UIManager.Instance.CreateGComponent<SummonScoreAwardWidget>(null, Content2));
                }

                summonScoreAwardWidgets = await ctb.WaitAll();
            }

            for (var i = 0; i < openBoxProgressRewards.Length; i++)
            {
                summonScoreAwardWidgets[i].CustomInit(openBoxProgressRewards[i], AwardSummonScore);
            }
        }

        private void AwardSummonScore()
        {
            List<ItemInfo> itemInfos = new List<ItemInfo>();
            //到达进度自动领取奖励
            if (openBoxConfig.ProgressRewardChoukaCount != -1 &&
                summonData.drawHistory.Count * 10 >= openBoxConfig.ProgressRewardChoukaCount)
            {
                for (var i = openBoxProgressRewards.Length - 1; i >= 0; i--)
                {
                    if (summonData.score >= openBoxProgressRewards[i].TotalScore)
                    {
                        for (var i1 = 0; i1 < openBoxProgressRewards[i].PrizeID.Length; i1++)
                        {
                            itemInfos.Add(new ItemInfo(openBoxProgressRewards[i].PrizeID[i1],
                                openBoxProgressRewards[i].PrizeCount[i1]));
                        }

                        break;
                    }
                }


                summonData.isSummonSocre = false;
                summonData.score = 0;
                summonData.drawHistory.Clear();
                foreach (var summonSocreData in summonData.summonSocreData)
                {
                    summonSocreData.currentCount = 0;
                }
                //TODO 200抽挑战后
                PlayerManager.Instance.BagController.AddItem(itemInfos);
                AccountFileInfo.Instance.SavePlayerData();
                RewardsPanel.OpenPanel(itemInfos);
            }
            else
            {
                LogTool.Error("领取失败！");
            }
        }


        public async static CTask OpenPanel()
        {
            await UIManager.Instance.LoadAndOpenPanel<OpenBoxScorePanel>(null, isShowBG: true);
        }

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

            summonScoreRuleWidgets.Clear();

            foreach (var summonScoreRuleWidget in summonScoreAwardWidgets)
            {
                UIManager.Instance.DormancyGComponent(summonScoreRuleWidget);
            }

            summonScoreAwardWidgets.Clear();

            AwardSummonScore();

            await base.Close();
        }
    }
}