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

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

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

        private CombatHeroEntity heroFocusEnemy;

        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()
        {
            isAddStack = false;
        }

        protected override void AddEvent()
        {
            CombatEventManager.Instance.AddEventListener(CombatEventType.TargetAlter, AlaterTargetFocus);
            EventManager.Instance.AddEventListener(CustomEventType.CreateHeroHp, CreateHeroHp);
            StaticUpdater.Instance.AddRenderUpdateCallBack(Update);
            TargetFocus.gameObject.SetActive(false);
            // CombatEventManager.Instance.AddEventListener(CombatEventType.TargetAlter, TargetAlter);
        }

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

        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 void AlaterTargetFocus(IEventData iEventData)
        {
            CombatHeroTargetAlterEventData combatHeroTargetAlterEventData = iEventData as CombatHeroTargetAlterEventData;
            CombatHeroEntity combatHeroEntity=  combatHeroTargetAlterEventData.combatHeroEntity as CombatHeroEntity;
            if (!combatHeroEntity.isPlayer||combatHeroTargetAlterEventData.targetCombatHeroEntity == heroFocusEnemy)
            {
                return;
            }

            heroFocusEnemy = combatHeroTargetAlterEventData.targetCombatHeroEntity as CombatHeroEntity;
            TargetFocus.gameObject.SetActive(heroFocusEnemy!=null);
            UpdateFocusUI();
        }

        private async void CreateHeroHp(IEventData iEventData)
        {
            CreateHeroHpEventData createHeroHpEventData = iEventData as CreateHeroHpEventData;
            CombatHeroEntity combatHeroEntity = createHeroHpEventData.combatHeroEntity;
            if (!combatHeroEntity.isCreateHeroHp)
            {
                return;
            }

            CreateHpUI(combatHeroEntity);
        }

        private void UpdateFocusUI()
        {
            if (heroFocusEnemy == null)
            {
                return;
            }
            Vector3 worldPos = heroFocusEnemy.combatHeroGameObject.hpTransform.position;
            Vector3 p = UIManager.Instance.CurrCustomCameraStack.camera.WorldToScreenPoint(worldPos);
            Vector3 p2 = UIManager.Instance.UICamera.ScreenToWorldPoint(p);
            Vector3 pos = Vector3.zero;
            if (heroFocusEnemy.isCreateHeroHp)
            {
                pos = new Vector3(0, 0.1f, 0);
            }

            TargetFocus.position = p2+pos;
        }

        public void Update()
        {
            UpdateFocusUI();
        }

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