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

using System.Collections.Generic;
using System.Linq;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat;
using GameLogic.Combat.CombatTool;
using UnityEngine;

namespace Fort23.Mono
{
    [UIBinding(prefab = "TowerPanel")]
    public partial class TowerPanel : UIPanel, IScrollListContent
    {
        public AccountFileInfo.TowerData _towerData;

        public List<TowerInfoConfig> towerInfoConfigps;

        public TowerLevelWidget currentLevelWidget;

        private TowerConfig towerConfig;

        public int ulockId;

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

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

        protected override void AddEvent()
        {
        }

        protected override void DelEvent()
        {
        }

        public override void AddButtonEvent()
        {
            Btn_Start.onClick.AddListener(async () =>
            {
                TowerInfoConfig towerInfoConfig = ConfigComponent.Instance.Get<TowerInfoConfig>(ulockId);
                if (towerInfoConfig.ID == 0)
                    return;

                var currentTowerLevelData = _towerData.towerLevelDatas.FirstOrDefault(t => t.id == ulockId);

                var lastTowerLevelData = _towerData.towerLevelDatas.FirstOrDefault(t => t.id == ulockId - 1);


                if ((lastTowerLevelData == null ||
                     !lastTowerLevelData.finish) &&
                    ulockId != 1)
                {
                    TipMessagePanel.OpenTipMessagePanel("上一关还没有解锁！");
                    return;
                }


                if (currentTowerLevelData == null)
                {
                    currentTowerLevelData = new AccountFileInfo.TowerLevelData();
                    currentTowerLevelData.id = towerInfoConfig.ID;
                    _towerData.towerLevelDatas.Add(currentTowerLevelData);
                    // currentLevelWidget.towerLevelData = towerLevelData;
                    AccountFileInfo.Instance.SavePlayerData();
                }

                CombatDrive.Instance.LoadLevelBattleCombat(towerInfoConfig.typeValue[0], true, -1,
                    delegate(bool isWin)
                    {
                        LogTool.Log("战斗完成" + isWin);
                        if (isWin)
                        {
                            currentTowerLevelData.finish = true;
                            AccountFileInfo.Instance.SavePlayerData();

                            CustomInit();
                        }

                        CombatController.currActiveCombat.ChangeState(CombatController.update);
                    });
            });

            Btn_Back.onClick.AddListener(() => { UIManager.Instance.HideUIUIPanel(this); });
        }

        public override CTask<bool> AsyncInit(object[] uiData)
        {
            int towerId = (int)uiData[0];
            towerConfig = ConfigComponent.Instance.Get<TowerConfig>(towerId);
            _towerData = AccountFileInfo.Instance.playerData.TowerDatas.FirstOrDefault(td => td.id == towerId);
            if (_towerData == null)
            {
                _towerData = new AccountFileInfo.TowerData();
                _towerData.id = towerId;
                AccountFileInfo.Instance.playerData.TowerDatas.Add(_towerData);
                AccountFileInfo.Instance.SavePlayerData();
            }

            CustomInit();


            return base.AsyncInit(uiData);
        }

        public void CustomInit()
        {
            UIManager.Instance.DormancyAllGComponent<TowerLevelWidget>();
            var configs = ConfigComponent.Instance.GetAll<TowerInfoConfig>();
            towerInfoConfigps = configs.Where(t => t.groupId == towerConfig.towerinfoIdGroup).ToList();


            Vector2 size = Slider_Stage.GetComponent<RectTransform>().sizeDelta;
            size.y = (141.2778f + 40) * (towerInfoConfigps.Count - 1);

            ulockId = _towerData.GetMaxUlockid();
            TowerInfoConfig ulockTowerInfoConfig = default;
            if (ulockId == 0)
            {
                ulockTowerInfoConfig = towerInfoConfigps[0];
                ulockId = ulockTowerInfoConfig.ID;
            }
            else
            {
                ulockTowerInfoConfig = ConfigComponent.Instance.Get<TowerInfoConfig>(ulockId);
            }

            Slider_Stage.GetComponent<RectTransform>().sizeDelta = size;

            Slider_Stage.value = (float)(ulockTowerInfoConfig.level - 1) /
                                 (towerInfoConfigps.Count - 1);

            Content.Init(this, towerInfoConfigps.Count, towerInfoConfigps.Count - 1 - ulockTowerInfoConfig.level, true);
        }

        public static async CTask OpenPanel(int id)
        {
            TowerPanel towerPanel =
                await UIManager.Instance.LoadAndOpenPanel<TowerPanel>(null, uiData: new object[] { id });
        }

        public async CTask<IScorllListWidget> GetIScorllListWidget(int index, RectTransform root)
        {
            int currInsex = index;
            if (currInsex < 0 || currInsex >= towerInfoConfigps.Count)
            {
                return null;
            }

            TowerLevelWidget woc1 =
                await UIManager.Instance.CreateGComponent<TowerLevelWidget>(null, ContentRoot);
            // woc1.OnClick = OnClick;
            woc1.CustomInit(_towerData, towerInfoConfigps[towerInfoConfigps.Count - 1 - currInsex]);
            // if (towerInfoConfigps[towerInfoConfigps.Count - 1 - currInsex].ID == ulockId)
            // {
            //     OnClick(woc1);
            //     // woc1.OnPointerClick();
            // }

            return woc1;
        }

        private void OnClick(ItemWidgetBasic obj)
        {
            TowerLevelWidget woc = obj as TowerLevelWidget;

            currentLevelWidget = woc;
            ulockId = currentLevelWidget._towerInfoConfig.ID;
            // SelectBigsecretArea(woc);
        }

        public void SelectBigsecretArea(TowerLevelWidget towerLevelWidget, bool isSelect = true)
        {
            if (isSelect)
            {
                Icon_Select.gameObject.SetActive(true);
                Icon_Select.transform.SetParent(towerLevelWidget.transform);
                Icon_Select.transform.GetComponent<RectTransform>().anchoredPosition = new Vector2(24.75f, 0);
                Icon_Select.transform.SetAsFirstSibling();
            }
            else
            {
                Icon_Select.gameObject.SetActive(false);
                Icon_Select.transform.SetParent(transform);
                Icon_Select.transform.SetAsFirstSibling();
            }
        }

        public void HindIScorllListWidget(IScorllListWidget widget)
        {
            TowerLevelWidget towerLevelWidget = widget as TowerLevelWidget;
            if (towerLevelWidget._towerInfoConfig.ID == ulockId)
            {
                // SelectBigsecretArea(towerLevelWidget, false);
            }

            UIManager.Instance.DormancyGComponent(widget as UIComponent);
        }

        public async override CTask Close()
        {
            _towerData = null;
            ulockId = 0;
            currentLevelWidget = null;
            CombatController.currActiveCombat.ChangeState(CombatController.update);
            await base.Close();
        }
    }
}