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

using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Fort23.Core;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using GameLogic.Combat.Hero.Turntable;
using GameLogic.Combat.Skill;
using UnityEngine;

namespace Fort23.Mono
{
    [UIBinding(prefab = "BossHpWidget")]
    public partial class BossHpWidget : UIComponent
    {
        private CombatHeroEntity combatHeroEntity;

        private CombatHeroSkillControl combatHeroSkillControl;

        protected BetterList<EnemyGf_skill> currShowGfWidget = new BetterList<EnemyGf_skill>();

        private HeroHpWidget heroHpWidget;

        private void Init()
        {
        }

        public override void AddEvent()
        {
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, UseSkill);
            CombatEventManager.Instance.AddEventListener(CombatEventType.AddUseGongFa, AddUseGongFa);
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkillFinish, UseSkillFinish);
            StaticUpdater.Instance.AddRenderUpdateCallBack(Update);
        }

        public override void DelEvent()
        {
            StaticUpdater.Instance.RemoveRenderUpdateCallBack(Update);
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.AddUseGongFa, AddUseGongFa);
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, UseSkill);
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkillFinish, UseSkillFinish);
            UIManager.Instance.DormancyGComponent(heroHpWidget);
            heroHpWidget = null;
            UIManager.Instance.DormancyAllGComponent<gf_widget>("bossWidget");
        }


        public override void AddButtonEvent()
        {
        }

        private void AddUseGongFa(IEventData iEventData)
        {
            AddUseGongFaEventData addUseGongFaEventData = iEventData as AddUseGongFaEventData;
            if (addUseGongFaEventData.SkillBasic.CombatHeroEntity == combatHeroEntity)
            {
                ReshSkill();
            }
        }

        private void UseSkill(IEventData iEventData)
        {
            CombatUseSkillEventData combatUseSkillEventData = iEventData as CombatUseSkillEventData;
            if (combatUseSkillEventData.useSkill.CombatHeroEntity == combatHeroEntity)
            {
                currUseSkillIcon.icon_name = combatUseSkillEventData.useSkill.SelfSkillConfig.icon;
                currUseSkillQuan.color =
                    CombatCalculateTool.Instance.GetColor(combatUseSkillEventData.useSkill.wuXingType);
                currUseSkillIcon.gameObject.SetActive(true);
                ReshSkill();
            }
        }

        private void UseSkillFinish(IEventData iEventData)
        {
            UseSkillFinishEventData combatUseSkillEventData = iEventData as UseSkillFinishEventData;
            if (combatUseSkillEventData.SkillBasic.CombatHeroEntity == combatHeroEntity)
            {
                currUseSkillIcon.gameObject.SetActive(false);
                currUseSkillQuan.color = Color.white;
                ReshSkill();
            }
        }

        private async CTask ReshSkill()
        {
            currShowGfWidget.Clear();
            UIManager.Instance.DormancyAllGComponent<EnemyGf_skill>("bossWidget");

            int maxCount = 2;
            SkillBasic[] skillQueue = combatHeroSkillControl.GetSkillQueue();
            for (int i = 0; i < combatHeroSkillControl.useSkillCount; i++)
            {
                if (maxCount <= 0)
                {
                    break;
                }

                SkillBasic skillBasic=  skillQueue[i];
                maxCount--;
                EnemyGf_skill gfWidget = await UIManager.Instance.CreateGComponentForObject<EnemyGf_skill>(
                    this.gf_widget,
                    null,
                    SkillRoot, poolName: "bossWidget", isInstance: true);
                gfWidget.InitSkillWidget(skillBasic, combatHeroEntity);
                gfWidget.transform.SetAsLastSibling();
                currShowGfWidget.Add(gfWidget);
            }

            if (maxCount > 0)
            {
                float minA = float.MaxValue;
                SkillSlots minSlots = null;
                List<SkillSlots> showSkillSlots = new List<SkillSlots>();
                for (int j = 0; j < maxCount; j++)
                {
                    minSlots = null;
                    minA = float.MaxValue;
                    for (int i = 0; i < combatHeroSkillControl.SkillTurntable.allSkillSlots.Count; i++)
                    {
                        SkillSlots skillSlots = combatHeroSkillControl.SkillTurntable.allSkillSlots[i];
                        if (skillSlots.SkillBasic != null && skillSlots.SkillBasic.SelfSkillConfig.SkillType != 1)
                        {
                            continue;
                        }

                        float angle = skillSlots.GetFinishAngle();
                        if (angle < minA && !showSkillSlots.Contains(skillSlots))
                        {
                            minA = angle;
                            minSlots = skillSlots;
                        }
                    }

                    if (minSlots != null)
                    {
                        showSkillSlots.Add(minSlots);
                        EnemyGf_skill gfWidget = await UIManager.Instance.CreateGComponentForObject<EnemyGf_skill>(
                            this.gf_widget,
                            null,
                            SkillRoot, poolName: "bossWidget", isInstance: true);
                        gfWidget.InitWidget(minSlots, combatHeroEntity);
                        gfWidget.transform.SetAsLastSibling();
                        currShowGfWidget.Add(gfWidget);
                    }
                }
            }
        }

        public async CTask ShowWidget(CombatHeroEntity combatHeroEntity)
        {
            this.combatHeroEntity = combatHeroEntity;
            combatHeroSkillControl =
                combatHeroEntity.CombatHeroSkillControl as CombatHeroSkillControl;
            heroHpWidget =
                await UIManager.Instance.CreateGComponentForObject<HeroHpWidget>(HeroHpWidget, null);
            heroHpWidget.size = 250;
            heroHpWidget.shieldSize = 100;
            heroHpWidget.isFollowTarget = false;
            heroHpWidget.Init(combatHeroEntity);
            ReshSkill();
            InitMagicWeapon();
        }

        private async CTask InitMagicWeapon()
        {
            int c = combatHeroEntity.heroMagicWeaponControl.MagicWeaponCount;
            CombatMagicWeaponEntity[] combatMagicWeaponEntities =
                combatHeroEntity.heroMagicWeaponControl.AllMagicWeapon;
            for (int i = 0; i < c; i++)
            {
                CombatMagicWeaponEntity combatMagicWeaponEntity = combatMagicWeaponEntities[i];
                MagicWeaponWidget shengShiEventWidget =
                    await UIManager.Instance.CreateGComponentForObject<MagicWeaponWidget>(MagicWeaponWidget, null,
                        FaBaoRoot,
                        isInstance: true, poolName: "bossFaBao");
                shengShiEventWidget.InitWidget(combatMagicWeaponEntity);
            }
        }

        public void Update()
        {
            if (combatHeroEntity == null)
            {
                return;
            }


            for (int i = 0; i < currShowGfWidget.Count; i++)
            {
                currShowGfWidget[i].Update();
            }
        }
    }
}