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


            
            // heroInfo.modelConfig.itemID

            if (BagController.Instance.DeductItem(heroInfo.modelConfig.itemID, heroInfo.promoteConfig.costCount))
            {
                heroInfo.Promote();
                PlayerManager.Instance.SaveHeroData(heroInfo);
                UpdateAttributeUI();
                HeroUITools.SetStarShow(stars, heroInfo.star.Value);
                LayoutRebuilder.MarkLayoutForRebuild(StarsLayout.GetComponent<RectTransform>());
                SendEvent(HeroUpType.Promote);
            }
        }

        private async void Callback(HeroPowerUpPre pre)
        {
            upPre = pre;
            pre.OpenPromotePre(heroInfo);
            
            // upPre.Stars1Layout.enabled = true;
            // upPre.Stars2Layout.enabled = true;
            await TimerComponent.Instance.WaitAsync(1);
            upPre.Stars1Layout.enabled = false;
            upPre.Stars2Layout.enabled = false;
            
            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);
            }
            
            // if (PlayerManager.Instance.gameConstantConfig.maxLv <= heroInfo.level.Value)
            // {
            //     LogTool.Log("已到达最高等级:" + PlayerManager.Instance.gameConstantConfig.maxLv);
            //     return;
            // }
            // if (BagController.Instance.DuctHeroExp(heroInfo.powerUpConfig.levelUpExp))
            // {
            //     heroInfo.Upgrade();
            //     UpdateAttributeUI();
            //     SendEvent(HeroUpType.Level);
            // }
        }

        private List<SimpleMove> simpleMoves = new List<SimpleMove>();
        private async void FlyInEft()
        {
            simpleMoves.Clear();
            upPre.Stars1Layout.gameObject.SetActive(false);
            upPre.Stars2Layout.gameObject.SetActive(false);
            
            LayoutRebuilder.MarkLayoutForRebuild (upPre.Stars1Layout.GetComponent<RectTransform>());
            
            await TimerComponent.Instance.WaitAsync(200);
            for (int i = 0; i < heroInfo.star; 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);
            }
            //把现在的星星隐藏了.
            StarsLayout.gameObject.SetActive(false);
            upPre.Stars1Layout.gameObject.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.Stars2Layout.gameObject.SetActive(true);
            
        }

        private async void FlyOutEft()
        {
            int i = 0;
            
            LayoutRebuilder.MarkLayoutForRebuild(StarsLayout.GetComponent<RectTransform>());
            
            simpleMoves.Clear();
            foreach (var star in stars)
            {
                GameObject targetGo = star as GameObject;
                GameObject startGo = upPre.Stars1[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);
            }
            StarsLayout.gameObject.SetActive(true);
            
            int j = 0;
            foreach (SimpleMove move in simpleMoves)
            {
                var 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)
        {
            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();
                
                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);
        }

        /// <summary>
        /// 发送英雄提升的事件
        /// </summary>
        /// <param name="upType">提升类型：升级、升星等.</param>
        private void SendEvent(HeroUpType upType)
        {
            HeroPowerUpEventData data = new HeroPowerUpEventData();
            data.heroModelID = heroInfo.modelID;
            data.upType = upType;
            
            PlayerManager.Instance.lastHeroInfo = heroInfo;
            EventManager.Instance.Dispatch(CustomEventType.HeroPowerUp, data);
            if (upType == HeroUpType.Level)
            {
                EventManager.Instance.Dispatch(CustomEventType.HeroLvUp, data);
            }
            else if (upType == HeroUpType.Promote)
            {
                EventManager.Instance.Dispatch(CustomEventType.HeroPromote, data);
            }
            
        }
        
        private void OnClickClose()
        {
            if (isOpenPre)
            {
                ExitPowerUpPre(curPreTyp);
            }
            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);

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

            UpdateAttributeUI(true);
        }

        private long curHeroCount;
        private long costHeroCount;
        public async void UpdateAttributeUI(bool isInit = false)
        {
            StarsLayout.gameObject.SetActive(true);
            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);
            }

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

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

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

    }
}