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);
        }

        public SkillUIComponent skillUIComponent;
        private async void OnClickSkill()
        {
            skillUIComponent = await UIManager.Instance.CreateGComponent<SkillUIComponent>(null, poolName:"SkillUIComponent",
                root:transform);
            skillUIComponent.InitUI(heroInfo);
        }


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

            if (isOpenPre)
            {
                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
            {
                await UIManager.Instance.CreateGComponentForObject<HeroPowerUpPre>(objHeroPowerUpPre, Callback, root: rtBottom);    
            }
        }

        private async void Callback(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);
            }
        }

        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
            {
                UIManager.Instance.HideUIUIPanel(this);
                GObjectPool.Instance.Recycle(modelObj);
            }
        }

        private GameObjectPool modelObj;
        HeroPowerUpPre upPre;
        public async void InitHeroDetailPanel(HeroInfo heroInfo)
        {
            this.heroInfo = heroInfo;
            
            btns1.SetActive(true);
            objHeroPowerUpPre.SetActive(false);

            iconZhiYe.icon_name = heroInfo.iconZhiYe;
            heroName.text = LanguageManager.Instance.Text(heroInfo.modelConfig.name);
            // 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;

                    AnimancerComponent animancerComponent = pool.own.GetComponent<AnimancerComponent>();
                    
                    int max = animancerComponent.Transitions.Library.Count;
                    for (int i = 0; i < max; i++)
                    {
                        if (animancerComponent.Transitions.Library.TryGetTransition(i,
                                out TransitionModifierGroup transition))
                        {
                            TransitionAsset clipTransition2 = transition.Transition as TransitionAsset;
                            if (clipTransition2 != null && clipTransition2.name == "idle")
                            {
                                animancerComponent.Play(clipTransition2);
                                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);
            
            // if (txtHP.text != heroInfo.hp.Value.ToStringEx())
            // {
            //     long old = long.Parse(txtHP.text);
            //     txtHP.text = heroInfo.hp.Value.ToStringEx();
            //     if(!isInit)
            //         await UIManager.Instance.CreateGComponent<HeroUpTxtEft>(delegate(HeroUpTxtEft heroUpTxtEft)
            //             {
            //                 heroUpTxtEft.txtEft.text = "+" + (heroInfo.hp.Value - old).ToStringEx();
            //             }, 
            //             poolName: "HeroUpTxtEft", root: eftNumPos[0] as RectTransform);
            // }

            PlayEft(isInit, txtATK, heroInfo.attack.Value.ToStringEx(), 1);
            
            // if (txtATK.text != heroInfo.attack.Value.ToStringEx())
            // {
            //     long old = long.Parse(txtATK.text);
            //     txtATK.text = heroInfo.attack.Value.ToStringEx();
            //     if(!isInit)
            //         await UIManager.Instance.CreateGComponent<HeroUpTxtEft>(delegate(HeroUpTxtEft heroUpTxtEft)
            //             {
            //                 heroUpTxtEft.txtEft.text = "+" + (heroInfo.attack.Value - old).ToStringEx();
            //             },
            //             poolName: "HeroUpTxtEft", root: eftNumPos[1] as RectTransform);
            // }
            
            PlayEft(isInit, txtDEF, heroInfo.defense.Value.ToStringEx(), 2);
            // if (txtDEF.text != heroInfo.defense.Value.ToStringEx())
            // {
            //     long old = long.Parse(txtDEF.text);
            //     txtDEF.text = heroInfo.defense.Value.ToStringEx();
            //     if(!isInit)
            //         await UIManager.Instance.CreateGComponent<HeroUpTxtEft>(delegate(HeroUpTxtEft heroUpTxtEft)
            //             {
            //                 heroUpTxtEft.txtEft.text = "+" + (heroInfo.defense.Value - old).ToStringEx();
            //             },
            //             poolName: "HeroUpTxtEft", root: eftNumPos[2] as RectTransform);
            // }

            PlayEft(isInit, txtSHANBI, heroInfo.shanbi.Value.ToStringEx(), 3);
            // if (txtSHANBI.text != heroInfo.shanbi.Value.ToStringEx())
            // {
            //     txtSHANBI.text = heroInfo.shanbi.Value.ToStringEx();
            //     if(!isInit)
            //         await UIManager.Instance.CreateGComponent<HeroUpTxtEft>(null,
            //             poolName: "HeroUpTxtEft", root: eftNumPos[3] as RectTransform);
            // }
            
            
            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 = "";
            }
            
            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);
                }
                    
            }
        }

    }
}