XiuXianGame/Assets/Scripts/GameUI/UI/CombatPanel/CombatHPPanel.cs

using Common.Utility.CombatEvent;
using Fort23.Core;
using GameLogic.Combat.Hero;
using Utility;

namespace Fort23.Mono
{
    [UIBinding(prefab = "CombatHPPanel")]
    public partial class CombatHPPanel : UIPanel
    {
        private Map<IHero, int> currTargetHeroHp = new Map<IHero, int>();

        public static async CTask OpenCombatHPPanel()
        {
            await UIManager.Instance.LoadAndOpenPanel<CombatHPPanel>(null, UILayer.Bottom);
        }
        
        public static async CTask CloseCombatHPPanel()
        {
            UIManager.Instance.HideUIUIPanel<CombatHPPanel>();
        }


        private void Init()
        {
        }

        protected override void AddEvent()
        {
            EventManager.Instance.AddEventListener(CustomEventType.CreateHeroHp, CreateHeroHp);
            // CombatEventManager.Instance.AddEventListener(CombatEventType.TargetAlter, TargetAlter);
        }

        protected override void DelEvent()
        {
            // CombatEventManager.Instance.RemoveEventListener(CombatEventType.TargetAlter, TargetAlter);
            EventManager.Instance.RemoveEventListener(CustomEventType.CreateHeroHp, CreateHeroHp);
        }

        public override void AddButtonEvent()
        {
        }

        private async void TargetAlter(IEventData iEventData)
        {
            CombatHeroTargetAlterEventData combatHeroTargetAlterEventData =
                iEventData as CombatHeroTargetAlterEventData;
            if (combatHeroTargetAlterEventData.combatHeroEntity.IsEnemy)
            {
                return;
            }

            if (combatHeroTargetAlterEventData.targetCombatHeroEntity != null)
            {
                CombatHeroEntity t = combatHeroTargetAlterEventData.targetCombatHeroEntity as CombatHeroEntity;
                if (t != null)
                {
                    if (t.CurrCombatHeroInfo.heroType == 4||t.CurrCombatHeroInfo.heroType ==3)
                    {
                        return;
                    }

                    if (!currTargetHeroHp.TryGetValue(combatHeroTargetAlterEventData.targetCombatHeroEntity,
                            out int count))
                    {
                    }

                    if (count <= 0)
                    {
                        CreateHpUI(t);
                    }

                    count++;
                    currTargetHeroHp[t] = count;
                }
            }

            if (combatHeroTargetAlterEventData.lasetCombatHeroEntity != null)
            {
                CombatHeroEntity t = combatHeroTargetAlterEventData.lasetCombatHeroEntity as CombatHeroEntity;
              
                if (t != null)
                {
                    if (t.CurrCombatHeroInfo.heroType == 4||t.CurrCombatHeroInfo.heroType ==3)
                    {
                        return;
                    }
                    if (currTargetHeroHp.TryGetValue(combatHeroTargetAlterEventData.lasetCombatHeroEntity,
                            out int count))
                    {
                        count--;
                        if (count <= 0)
                        {
                            currTargetHeroHp.Remove(combatHeroTargetAlterEventData.lasetCombatHeroEntity);
                            HeroHpUpdateEventData heroHpUpdateEventData = HeroHpUpdateEventData.Create();
                            heroHpUpdateEventData.combatHeroEntity = t;
                            CombatEventManager.Instance.Dispatch(CombatEventType.ClearHeroHp, heroHpUpdateEventData);
                        }
                        else
                        {
                            currTargetHeroHp[t] = count;
                        }

                       
                    }
                }
            }
        }

        private async void CreateHpUI(CombatHeroEntity combatHeroEntity)
        {
            // CombatHeroEntity combatHeroEntity = createHeroHpEventData.combatHeroEntity;
            HeroHpWidget heroHpWidget =
                await UIManager.Instance.CreateGComponentForObject<HeroHpWidget>(HeroHpWidget, null, transform,
                    isInstance: true);
            heroHpWidget.Init(combatHeroEntity);
        }

        private async void CreateHeroHp(IEventData iEventData)
        {
            CreateHeroHpEventData createHeroHpEventData = iEventData as CreateHeroHpEventData;
            CombatHeroEntity combatHeroEntity = createHeroHpEventData.combatHeroEntity;
            CreateHpUI(combatHeroEntity);
        }

        public override void Close()
        {
            UIManager.Instance.DormancyAllGComponent<HeroHpWidget>();
            base.Close();
        }
    }
}