XiuXianGame/Assets/Scripts/GameUI/UI/Hero/HeroDetailPanel.cs

using System.Collections.Generic;
using Animancer;
using Animancer.TransitionLibraries;
using Common.Utility.CombatEvent;
using Core.Language;
using Core.Utility;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Hero;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.UI;
using Utility;

namespace Fort23.Mono
{
    [UIBinding(prefab = "HeroDetailPanel"  )]
    public partial class HeroDetailPanel : UIPanel
    {
        
        private HeroInfo heroInfo;
        
        private void Init()
        {
            // InitHeroDetailPanel();
        }
        protected override void AddEvent()
        {
        }
        protected override void DelEvent()
        {
        }
        public override void AddButtonEvent()
        {
            btnBack.onClick.AddListener(OnClickClose);
            btnUpgrade.onClick.AddListener(OnClickUpgrade);
            btnPromote.onClick.AddListener(OnClickPromote);
            btnSkill.onClick.AddListener(OnClickSkill);
            btnPrev.onClick.AddListener(OnclickPrevHero);
            btnNext.onClick.AddListener(OnclickNextHero);
            
            btnSpecailEquip.onClick.AddListener(delegate
            {
                // TipMessagePanel.OpenTipMessagePanel("专属装备（敬请期待）",
                //     new Vector2(btnSpecailEquip.transform.position.x, btnSpecailEquip.transform.position.y + 0.5f));
                
                TipMessagePanel.OpenTipMessagePanel(LanguageManager.Instance.Text(101),
                    new Vector2(btnSpecailEquip.transform.position.x, btnSpecailEquip.transform.position.y + 0.5f));
            });
            
            btnCommonEquip.onClick.AddListener(OnclickCommonEquip);
        }

        private void OnclickCommonEquip()
        {
            // throw new System.NotImplementedException();
            ModelPos.gameObject.SetActive(false);
            HeroUITools.OpenSpecificProfessionEquipmentPanel(heroInfo.modelConfig.profession, delegate
            {
                ModelPos.gameObject.SetActive(true);
                modelAnimComponent.Play(modelIdleClip);
            });
        }

        private void OnclickPrevHero()
        {
            SwitchHero(false);
        }

        private void OnclickNextHero()
        {
            SwitchHero(true);
        }

        public void SwitchHero(bool isNext)
        {
            if (sourcePanel == UIPanelName.None)
            {
                LogTool.Error("打开英雄界面的上个一个UIPanel未知");
                return;
            }
            
            if (isOpenPre)
            {
                ExitPowerUpPre(curPreTyp, upPre.Stars1);
            }
            
            GObjectPool.Instance.Recycle(modelObj);
            
            if (sourcePanel == UIPanelName.BagPanel)
            {
                HeroBagPanel heroBagPanel = UIManager.Instance.GetComponent<HeroBagPanel>();
                WidgetHero widgetHero = HeroUITools.
                    GetCloseHero(heroBagPanel.widgetHeroes, heroWidget, isNext);
                if (widgetHero != null)
                {
                    InitHeroDetailPanel(widgetHero, sourcePanel);
                }
            }

            if (sourcePanel == UIPanelName.MainPanel)
            {
                MainUIPanel mainUIPanel = UIManager.Instance.GetComponent<MainUIPanel>();
                WidgetHero widgetHero = HeroUITools.
                    GetCloseHero(mainUIPanel.widgetHeroes, heroWidget, isNext);
                if (widgetHero != null)
                {
                    InitHeroDetailPanel(widgetHero, sourcePanel);
                }
            }
        }

        private bool IsShowArrow(bool isNext)
        {
            if (sourcePanel == UIPanelName.None)
            {
                return false;
            }
            
            if (sourcePanel == UIPanelName.BagPanel)
            {
                HeroBagPanel heroBagPanel = UIManager.Instance.GetComponent<HeroBagPanel>();
                WidgetHero widgetHero = HeroUITools.
                    GetCloseHero(heroBagPanel.widgetHeroes, heroWidget, isNext);
                
                return widgetHero != null;
            }

            if (sourcePanel == UIPanelName.MainPanel)
            {
                MainUIPanel mainUIPanel = UIManager.Instance.GetComponent<MainUIPanel>();
                WidgetHero widgetHero = HeroUITools.
                    GetCloseHero(mainUIPanel.widgetHeroes, heroWidget, isNext);
                return widgetHero != null;
            }
            
            return false;
        }

        public SkillUIComponent skillUIComponent;
        private async void OnClickSkill()
        {
            // skillUIComponent = await UIManager.Instance.CreateGCompo nent<SkillUIComponent>(null, poolName:"SkillUIComponent",
            //     root:transform);
            
            
            skillUIComponent = await UIManager.Instance.
                CreateGComponentForObject<SkillUIComponent>(skillUI, null, isInstance : false, root:transform);
            
            skillUIComponent.InitUI(heroInfo);

            skillUIComponent.transform.sizeDelta = transform.sizeDelta;
        }


        private async void OnClickPromote()
        {
            if (PlayerManager.Instance.gameConstantConfig.maxStar <= heroInfo.star.Value)
            {
                LogTool.Log("已到达最高星级:" + PlayerManager.Instance.gameConstantConfig.maxStar);
                return;
            }

            if (isOpenPre)
            {

                HeroUpResultType upResultType = PlayerManager.Instance.heroController.PromoteHeroLogic(heroInfo);

                if (upResultType == HeroUpResultType.Success)
                {
                    UpdateAttributeUI();
                    HeroUITools.SetStarShow(stars, heroInfo.star.Value);
                    ExitPowerUpPre(curPreTyp, upPre.Stars2);
                }
                else
                {
                    TipMessagePanel.OpenTipMessagePanel(LanguageManager.Instance.Text(103), Vector2.zero);
                }

                // if (PlayerManager.Instance.heroController.CanPromote(heroInfo) == HeroUpResultType.Success)
                // {
                //     heroInfo.Promote();
                //     PlayerManager.Instance.SaveHeroData(heroInfo);
                //     UpdateAttributeUI();
                //     HeroUITools.SetStarShow(stars, heroInfo.star.Value);
                //     PlayerManager.Instance.heroController.SendEvent(HeroUpType.Promote, heroInfo, HeroUpResultType.Success);
                //     ExitPowerUpPre(curPreTyp, upPre.Stars2);
                // }
                // else
                // {
                //     TipMessagePanel.OpenTipMessagePanel("资源不足", Vector2.zero);
                // }
            }
            else
            {
                await UIManager.Instance.CreateGComponentForObject<HeroPowerUpPre>(objHeroPowerUpPre, OpenPreUICallback, root: rtBottom);    
            }
        }

        private async void OpenPreUICallback(HeroPowerUpPre pre)
        {
            upPre = pre;
            pre.OpenPromotePre(heroInfo);
            EnterPowerUpPre(2);
        }

        /// <summary>
        /// 是否打开了升级/升星的预览界面
        /// </summary>
        public bool isOpenPre;

        private byte curPreTyp;
        private async void OnClickUpgrade()
        {
            HeroUpResultType resultType = PlayerManager.Instance.heroController.UpgradeHeroLogic(heroInfo, isOpenPre);

            if (resultType == HeroUpResultType.Success)
            {
                UpdateAttributeUI();
            }
            else if (resultType == HeroUpResultType.PlayUpgradeEftFirst)
            {
                //TODO 要播放特效.
                ExitPowerUpPre(1);
                UpdateAttributeUI();
            }
            else if(resultType == HeroUpResultType.NeedOpenPreUI)
            {
                upPre = await UIManager.Instance.CreateGComponentForObject<HeroPowerUpPre>(objHeroPowerUpPre,
                    delegate(HeroPowerUpPre pre)
                    {
                        EnterPowerUpPre(1);
                        pre.OpenUpgradePre(heroInfo);
                    }, root: rtBottom);

                btnUpgrade.enabled = false;
                await TimerComponent.Instance.WaitAsync(500);
                btnUpgrade.enabled = true;

            }
        }

        private List<SimpleMove> simpleMoves = new List<SimpleMove>();
        private async void FlyInEft()
        {
            simpleMoves.Clear();
            upPre.Stars1Obj.SetActive(false);
            upPre.Stars2Obj.SetActive(false);
            
            await TimerComponent.Instance.WaitAsync(200);
            for (int i = 0; i < stars.Count; i++)
            {
                GameObject targetGo = upPre.Stars1[i] as GameObject;
                GameObject startGo = stars[i] as GameObject;
                RectTransform targetRT = targetGo.GetComponent<RectTransform>();
                RectTransform startRT = startGo.GetComponent<RectTransform>();
                SimpleMove sm = new SimpleMove(targetRT, startRT.position, targetRT.position);
                simpleMoves.Add(sm);
            }
            //把现在的星星隐藏了.
            StarsObj.SetActive(false);
            
            upPre.Stars1Obj.SetActive(true);
            
            int j = 0;
            float delayTime = 0;
            foreach (SimpleMove move in simpleMoves)
            {
                delayTime = (j++ * 0.05f);
                move.Start(delayTime);
            }
            
            await TimerComponent.Instance.WaitAsync(Mathf.RoundToInt((delayTime + 0.3f) * 1000));
            upPre.Stars2Obj.SetActive(true);
            
        }

        private async void FlyOutEft(List<object> startList)
        {
            int i = 0;
            
            // LayoutRebuilder.MarkLayoutForRebuild(StarsLayout.GetComponent<RectTransform>());
            // LayoutUtility.Layout(stars, LayoutType.Horizontal);
            simpleMoves.Clear();
            foreach (var star in stars)
            {
                GameObject targetGo = star as GameObject;
                GameObject startGo = startList[i++] as GameObject;
                //目标
                RectTransform targetRT = targetGo.GetComponent<RectTransform>();
                //起始
                RectTransform startRT = startGo.GetComponent<RectTransform>();
                
                SimpleMove sm = new SimpleMove(targetRT, startRT.position, targetRT.position);
                simpleMoves.Add(sm);
            }
            StarsObj.SetActive(true);
            
            int j = 0;
            float delayTime = 0f;
            foreach (SimpleMove move in simpleMoves)
            {
                delayTime = (j++ * 0.05f);
                move.Start(delayTime);
            }

            await TimerComponent.Instance.WaitAsync(Mathf.RoundToInt((delayTime + 0.3f) * 1000));
            // upPre.Stars2Layout.gameObject.SetActive(false);
            
        }
        
        /// <summary>
        /// 进入 升级/升星预览界面
        /// </summary>
        /// <param name="preTyp">1升级;2 升星</param>
        private void EnterPowerUpPre(byte preTyp)
        {
            isOpenPre = true;
            curPreTyp = preTyp;
            btns1.SetActive(false);
            
            if (preTyp == 1)
            {
                btnPromote.gameObject.SetActive(false);
                RectTransform rt = btnUpgrade.GetComponent<RectTransform>();
                rt.sizeDelta = new Vector2(510, rt.sizeDelta.y);
                rt.localPosition = new Vector3(47, rt.localPosition.y, rt.localPosition.z);
            }
            else
            {
                btnUpgrade.gameObject.SetActive(false);
                RectTransform rt = btnPromote.GetComponent<RectTransform>();
                rt.sizeDelta = new Vector2(510, rt.sizeDelta.y);
                rt.localPosition = new Vector3(47, rt.localPosition.y, rt.localPosition.z);

                FlyInEft();
                
                if (costHeroCount > curHeroCount)
                {
                    btnPromote.GetComponent<MyImage>().icon_name = "btn_l_Gray";
                    
                }
                else
                {
                    btnPromote.GetComponent<MyImage>().icon_name = "btn_l_Green";
                }
                
            }
        }
        
        /// <summary>
        /// 离开 升级/升星预览界面
        /// </summary>
        /// <param name="preTyp">1升级;2 升星</param>
        private void ExitPowerUpPre(byte preTyp, List<object> list = null)
        {
            isOpenPre = false;
            btns1.SetActive(true);
            
            // upPre.Stars1Layout.enabled = true;
            // upPre.Stars2Layout.enabled = true;

            if (preTyp == 1)
            {
                btnPromote.gameObject.SetActive(true);
                RectTransform rt = btnUpgrade.GetComponent<RectTransform>();
                rt.sizeDelta = new Vector2(400, rt.sizeDelta.y);
                rt.localPosition = new Vector3(163f, rt.localPosition.y, rt.localPosition.z);
            }
            else
            {
                FlyOutEft(list);
                
                btnUpgrade.gameObject.SetActive(true);
                RectTransform rt = btnPromote.GetComponent<RectTransform>();
                rt.sizeDelta = new Vector2(180, rt.sizeDelta.y);
                rt.localPosition = new Vector3(-135f, rt.localPosition.y, rt.localPosition.z);
                
                btnPromote.GetComponent<MyImage>().icon_name = "btn_l_Green";
            }
            
            objHeroPowerUpPre.SetActive(false);
        }
        
        private void OnClickClose()
        {
            if (isOpenPre)
            {
                ExitPowerUpPre(curPreTyp, upPre.Stars1);
            }
            else
            {
                GObjectPool.Instance.Recycle(modelObj);
                UIManager.Instance.HideUIUIPanel(this);
                
                EventManager.Instance.Dispatch(CustomEventType.OnCloseHeroPanel, new SimpleEventData(){ intData = heroInfo.modelID});
            }
        }
        

        public WidgetHero heroWidget;
        public UIPanelName sourcePanel;
        
        private GameObjectPool modelObj;
        private AnimancerComponent modelAnimComponent;
        private TransitionAsset modelIdleClip;
        HeroPowerUpPre upPre;
        public async void InitHeroDetailPanel(WidgetHero heroWidget, UIPanelName sourcePanel = UIPanelName.None)
        {
            this.heroInfo = heroWidget.heroInfo;
            this.heroWidget = heroWidget;
            this.sourcePanel = sourcePanel;
            
            // TxtGuildPanel.CloseTxtGuildPanel();
            // if (HeroUITools.IsLvUpShowGuild(heroInfo))
            // {
            //     TxtGuildPanel.OpenTxtGuildPanel("点击这里, 升级", new Vector2(btnUpgrade.transform.position.x ,
            //         btnUpgrade.transform.position.y + .2f));
            // }


            skillUI.SetActive(false);
            
            btns1.SetActive(true);
            objHeroPowerUpPre.SetActive(false);
            
            //是否显示左右切换按钮
            btnNext.gameObject.SetActive(IsShowArrow(true));
            btnPrev.gameObject.SetActive(IsShowArrow(false));

            iconZhiYe.icon_name = heroInfo.GetZyIconName();
            iconCommonEquip.icon_name = heroInfo.GetZyIconName();
            heroName.text = LanguageManager.Instance.Text(heroInfo.modelConfig.name);
            heroShards.icon_name = heroInfo.modelConfig.headicon;
            // LayoutRebuilder.MarkLayoutForRebuild(StarsLayout.transform.GetComponent<RectTransform>());
            // StarsLayout.gameObject.SetActive(true);
            
            HeroUITools.SetStarShow(stars, heroInfo.star.Value);
            // StarsLayout.enabled = true;
            // StarsLayout.SetLayoutHorizontal();
            // await TimerComponent.Instance.WaitAsync(1);
            // StarsLayout.enabled = false;
            
            // await TimerComponent.Instance.WaitAsync(50);
            // StarsLayout.GetComponent<LayoutGroup>().s
            // StarsLayout.GetComponent<LayoutGroup>().SetDirty();
            // LayoutRebuilder.ForceRebuildLayoutImmediate(StarsLayout.GetComponent<RectTransform>());
            
            // GameObjectPool poolInterface =
            //     await GObjectPool.Instance.FetchAsync<GameObjectPool>(heroInfo.modelConfig.model + ".prefab", null);
            
            modelObj = await GObjectPool.Instance.FetchAsync<GameObjectPool>(heroInfo.modelConfig.model + ".prefab",
                delegate(GameObjectPool pool)
                {
                    pool.own.GetComponent<NavMeshAgent>().enabled = false;
                    pool.own.transform.parent = ModelPos;
                    pool.own.transform.localEulerAngles = new Vector3(0, 180, 0);
                    pool.own.transform.localPosition = new Vector3(0, 0.2f, 0);
                    pool.own.transform.localScale = Vector3.one;

                    modelAnimComponent = pool.own.GetComponent<AnimancerComponent>();
                    
                    int max = modelAnimComponent.Transitions.Library.Count;
                    for (int i = 0; i < max; i++)
                    {
                        if (modelAnimComponent.Transitions.Library.TryGetTransition(i,
                                out TransitionModifierGroup transition))
                        {
                            modelIdleClip = transition.Transition as TransitionAsset;
                            if (modelIdleClip != null && modelIdleClip.name == "idle")
                            {
                                modelAnimComponent.Play(modelIdleClip);
                                break;
                            }
                        }
                    }
                    HeroUITools.ChangeLayerRecursively(pool.own, LayerMask.NameToLayer("UI"));
                    
                });

            switch (heroInfo.modelConfig.rarity)
            {
                case 1:
                    heroRarity.text = LanguageManager.Instance.Text(32);
                    break;
                case 2:
                    heroRarity.text = LanguageManager.Instance.Text(31);
                    break;
                case 3:
                    heroRarity.text = LanguageManager.Instance.Text(30);
                    break;
                default:
                    LogTool.Error("找不到hero的稀有度:" + heroInfo.modelConfig.ID);
                    break;
            }

            AnimateNumber animTxtHp = new AnimateNumber(targetTextPro:txtHP);
            AnimateNumber animTxtAtk = new AnimateNumber(targetTextPro:txtATK);
            AnimateNumber animTxtDef = new AnimateNumber(targetTextPro:txtDEF);
            AnimateNumber animTxtShanBi = new AnimateNumber(targetTextPro:txtSHANBI);
            
            animateNumberList = new List<AnimateNumber>();
            animateNumberList.Add(animTxtHp);
            animateNumberList.Add(animTxtAtk);
            animateNumberList.Add(animTxtDef);
            animateNumberList.Add(animTxtShanBi);
            
            UpdateAttributeUI(true);
        }

        private List<AnimateNumber> animateNumberList;
        
        private long curHeroCount;
        private long costHeroCount;
        public async void UpdateAttributeUI(bool isInit = false)
        {
            StarsObj.SetActive(true);
            
            PlayEft(isInit, txtHP, heroInfo.hp.Value.ToStringEx(), 0);
            
            PlayEft(isInit, txtATK, heroInfo.attack.Value.ToStringEx(), 1);
         
            PlayEft(isInit, txtDEF, heroInfo.defense.Value.ToStringEx(), 2);

            PlayEft(isInit, txtSHANBI, heroInfo.shanbi.Value.ToStringEx(), 3);

            txtLv.text = heroInfo.level.Value.ToStringEx();
            txtExpGain.text = heroInfo.expGain.Value.ToStringEx();

            string redColorStar = "";
            string redColorEnd = "";
            
            long curExp = BagController.Instance.GetItemInfo(GlobalParam.Item_HeroExp_ID).count.Value;
            long costExp = heroInfo.powerUpConfig.levelUpExp;
            
            if (costExp > curExp)
            {
                redColorStar = "<color=#FF4C4C>";
                redColorEnd = "</color>";
                
                btnUpgrade.GetComponent<MyImage>().icon_name = "btn_l_Gray";
            }
            else
            {
                redColorStar = "";
                redColorEnd = "";
                btnUpgrade.GetComponent<MyImage>().icon_name = "btn_l_Green";
            }

            txtUpgrade.text = redColorStar + curExp.ToStringEx() + redColorEnd + "/" + costExp.ToStringEx();
            
            
            curHeroCount = BagController.Instance.GetItemInfo(heroInfo.modelConfig.itemID).count.Value;
            costHeroCount = heroInfo.promoteConfig.costCount;
            
            if (costHeroCount > curHeroCount)
            {
                redColorStar = "<color=#FF4C4C>";
                redColorEnd = "</color>";
            }
            else
            {
                redColorStar = "";
                redColorEnd = "";
            }

            if (PlayerManager.Instance.gameConstantConfig.maxStar <= heroInfo.star.Value)
            {
                txtPromote.text = "MAX";
            }
            else
            {
                txtPromote.text = redColorStar + curHeroCount + redColorEnd + "/" + costHeroCount;    
            }
            

            // LogTool.Log(PlayerManager.Instance.heroController.CanUpgrade(heroInfo));
            // LogTool.Log(go1.activeSelf);
            if (PlayerManager.Instance.heroController.CanUpgrade(heroInfo) == HeroUpResultType.MainLevelNotEnough)
            {
                go1.SetActive(false);
                txtUpLimit.gameObject.SetActive(true);
                txtUpLimit.text = LanguageManager.Instance.Text(63);
                btnUpgrade.GetComponent<MyImage>().icon_name = "btn_l_Gray";
            }
            else
            {
                go1.SetActive(true);
                txtUpLimit.gameObject.SetActive(false);
                // btnUpgrade.GetComponent<MyImage>().icon_name = "btn_l_Green";
            }
        }

        /// <summary>
        /// 当基础属性改变时，做一些表现
        /// </summary>
        /// <param name="isInit">是否为首次(初始), 首次不做动画处理</param>
        /// <param name="txtOld">当前(旧的)</param>
        /// <param name="txtNew"></param>
        /// <param name="eftRoot"></param>
        private async void PlayEft(bool isInit, TextMeshProUGUI txtOld, string txtNew, int idx)
        {
            if (txtOld.text != txtNew)
            {
                long old = long.Parse(txtOld.text);
                long newV = long.Parse(txtNew);
                txtOld.text = txtNew;
                if (!isInit)
                {
                    animateNumberList[idx].Start(old, newV);
                    
                    await UIManager.Instance.CreateGComponent(delegate(HeroUpTxtEft heroUpTxtEft)
                        {
                            heroUpTxtEft.txtEft.text = "+" + (newV - old).ToStringEx();
                        }, 
                        poolName: "HeroUpTxtEft", root: eftNumPos[idx] as RectTransform);
                }
                    
            }
        }

    }
}