XiuXianGame/Assets/Scripts/GameLogic/Combat/Skill/SkillBasic.cs

using System;
using System.Collections.Generic;
using CombatCore.SerializationTimeLine;
using CombatLibrary.CombatLibrary.CombatCore;
using CombatLibrary.CombatLibrary.CombatCore.CustomizeTimeLogic.FxLogic;
using Common.Combat.FxAILogic;
using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Common;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using GameLogic.Combat.Hero.Turntable;
using GameLogic.Combat.Skill.IntensifierEffect;
using GameLogic.CombatScenesTool;
using GameLogic.Hero;
using GameLogic.Player;
using UnityEngine;
using Utility;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventLogic;
using Random = UnityEngine.Random;

namespace GameLogic.Combat.Skill
{
    public abstract class SkillBasic : CObject, ITimeLineTriggerEntity, ITimeLineEndSing, ITimeLineTargetEntity,
        ITimeLineTriggerEvent, ITimeLineAlertTargetEnter
    {
        public int skillGuid;


        public int UseCount;


        /// <summary>
        /// 是否被激活
        /// </summary>
        public bool isActive = true;

        /// <summary>
        /// 是否使用中
        /// </summary>
        private bool isUse;

        public float[] effectValue;

        public CombatHeroEntity CombatHeroEntity
        {
            get { return _combatHeroEntity; }
        }

        /// <summary>
        /// 转盘中的下表
        /// </summary>
        public int index;

        private bool _isDis;

        // public float angle = 180;
        // public float useAngle;
        // public float lasetAngle = 360;
        public int useCount;

        /// <summary>
        /// 当前激活技能的TimeLine数据
        /// </summary>
        protected List<TimeLineEventLogicGroupBasic> currUseAllTimeLineLogic = new List<TimeLineEventLogicGroupBasic>();

        private CombatHeroEntity _combatHeroEntity;

        private Map<string, System.Action<string, CombatHeroHitPoint, ITimelineFxLogic, TriggerData>>
            _triggerCallBack =
                new Map<string, Action<string, CombatHeroHitPoint, ITimelineFxLogic, TriggerData>>();

        public SkillConfig SelfSkillConfig;


        // public SkillIntensifierData SkillIntensifierData;

        /// <summary>
        /// 释放技能的时候当前焦点的目标
        /// </summary>
        public CombatHeroEntity currFocusTarget;

        private SkillFeaturesData SkillFeaturesData;

        /// <summary>
        /// 激活的timelinegoup名字
        /// </summary>
        public string ActiveTimeLineGroupName;

        private System.Action<SkillBasic> finishCallBack;

        /// <summary>
        /// 完成时 是否是要完成的timeGroupName
        /// </summary>
        protected string _finishTimeLineGroupName;

        protected BetterList<CombatHeroEntity> _enterAlertTarget = new BetterList<CombatHeroEntity>();
        protected BetterList<ILifetCycleHitPoint> _currUseSkillTarget = new BetterList<ILifetCycleHitPoint>();
        protected bool _isEarlyWarning;

        /// <summary>
        /// 是否使用技能目标里的缓存池子
        /// </summary>
        protected bool _useSkillTargetPool = true;

        public WuXingType wuXingType;

        public TriggerData triggerData
        {
            get
            {
                _triggerData.Source = this;
                return _triggerData;
            }
        }

        private TriggerData _triggerData;
        // public float[] skillEffectValue;
        // private float[] defaultEffectValue;

        /// <summary>
        /// 技能cd
        /// </summary>
        public float SkillCd
        {
            get { return _skillCd; }
            set { _skillCd = value; }
        }

        private float _skillCd;

        public float SkillMaxCd;

        private CombatParticleSystemPool _earlyWarningFx;
        private CombatHeroEntity _earlyWarningFristHero;

        protected SkillInfo skillInfo;

        public T This<T>()
        {
            return (T)(object)this;
        }


        // public void 
        public void IntensifyingEffect(float bl)
        {
            if (SelfSkillConfig.intensifierIndex == null)
            {
                return;
            }

            float[] basic = skillInfo.effectValue;
            // float[] newEffectValue = new float[effectValue.Length];
            for (int i = 0; i < SelfSkillConfig.intensifierIndex.Length; i++)
            {
                int index = SelfSkillConfig.intensifierIndex[i];
                if (index >= basic.Length)
                {
                    continue;
                }

                effectValue[index] = basic[index] * ((bl * 0.01f));
            }
        }

        public SkillFeaturesData GetSkillFeaturesData()
        {
            SkillFeaturesData skillFeaturesData = SkillFeaturesData.CapyFeaturesData();
            skillFeaturesData.hp =
                (long)(skillFeaturesData.hp * CombatHeroEntity.CurrCombatHeroInfo.GetWuXingShuXing(wuXingType));
            skillFeaturesData.maxHp = skillFeaturesData.hp;
            return skillFeaturesData;
        }

        public override void ActiveObj()
        {
        }

        public void AddToSkillSlots()
        {
            Array.Copy(skillInfo.effectValue, effectValue, skillInfo.effectValue.Length);
        }

        /// <summary>
        /// 激活技能，准备使用技能
        /// </summary>
        public void ActiveSkill()
        {
            ProActiveSkill();
        }

        protected virtual void ProActiveSkill()
        {
        }

        public void Replace()
        {
            ProReplace();
        }

        protected virtual void ProReplace()
        {
        }

        /// <summary>
        /// 轮询的初始化
        /// </summary>
        public void PollingInit(BetterList<SkillBasic> skillQueue)
        {
            ProPollingnInit(skillQueue);
        }

        protected virtual void ProPollingnInit(BetterList<SkillBasic> skillQueue)
        {
        }

        /// <summary>
        /// 休眠
        /// </summary>
        public override void DormancyObj()
        {
            Dispose();
            _enterAlertTarget.Clear();
            _currUseSkillTarget.Clear();

            _triggerCallBack.Clear();
            _earlyWarningFx = null;
            _earlyWarningFristHero = null;
            _finishTimeLineGroupName = null;
            _earlyWarningFx = null;
            _isEarlyWarning = false;
            _triggerData = new TriggerData();
            _useSkillTargetPool = true;
            isUse = false;
            _combatHeroEntity = null;
            SkillMaxCd = 0;
            currUseAllTimeLineLogic.Clear();
            finishCallBack = null;
            _isDis = false;
        }

        public virtual void ActiveLimitSkill()
        {
            isActive = true;
        }

        /// <summary>
        /// 开始游戏
        /// </summary>
        public void StartGame()
        {
            //  InitSpecialWeapon();
            // if (SelfSkillConfig.SkillType == 4 || SelfSkillConfig.SkillType == 5)
            // {
            //     UseSkill();
            // }


            ProStartGame();
        }

        public void InitSkillConfig(CombatHeroEntity combatHeroEntity, SkillInfo skillInfo)
        {
            this.skillInfo = skillInfo;
            _combatHeroEntity = combatHeroEntity;
            SelfSkillConfig = skillInfo.skillConfig;
            SkillMaxCd = SelfSkillConfig.cd;
            _skillCd = SkillMaxCd;

            wuXingType = (WuXingType)SelfSkillConfig.attribute;
            SkillFeaturesData = new SkillFeaturesData();
            SkillFeaturesData.isEnemy = combatHeroEntity.IsEnemy;

            SkillFeaturesData.WuXingType = wuXingType;
            SkillFeaturesData.SkillBasic = this;
            SkillFeaturesData.hp = skillInfo.qiangDu;

            UseCount = SelfSkillConfig.SkillType * 100000;
            skillGuid = SelfSkillConfig.ID;
            effectValue = new float[skillInfo.effectValue.Length];
            Array.Copy(skillInfo.effectValue, effectValue, skillInfo.effectValue.Length);

            // if (SkillIntensifierData == null)
            // {
            //     SkillIntensifierData = new SkillIntensifierData();
            // }


            ProInitSkillConfig();

            ProInitSkill();
            // LogTool.Log("初始化技能"+skillConfig.scriptName);
        }

        protected virtual void ProInitSkillConfig()
        {
        }

        /// <summary>
        /// 设置激活的TimeLine名字
        /// </summary>
        public void SetActiveTimeLineGroupName(string groupName)
        {
            ActiveTimeLineGroupName = groupName;
        }

        public virtual bool IsCanUse()
        {
            return true;
        }


        public HarmReturnInfo Harm(CombatHeroEntity source, CombatHeroHitPoint target, long att, AttType attType,
            TriggerData triggerData, HarmType harmType = HarmType.Null)
        {
            if (target == null || target.combatHeroEntity == null)
            {
                return null;
            }

            return CombatCalculateTool.Instance.Harm(source, target, att, attType, triggerData, wuXingType,
                harmType);
        }

        public HarmReturnInfo Recover(CombatHeroEntity source, CombatHeroHitPoint target, long att,
            AttType attType, HarmType harmType)
        {
            return CombatCalculateTool.Instance.Recover(source, target, att, attType, harmType, triggerData);
        }


        public void SetSkillFinishCallBack(System.Action<SkillBasic> finishCallBack)
        {
            this.finishCallBack = finishCallBack;
        }


        /// <summary>
        /// 开始使用技能
        /// </summary>
        public void UseSkill()
        {
            // BetterList<IntensifierEffectBasic> currIntensifierEffectBasicList =
            //     SkillIntensifierData.currIntensifierEffectBasicList;
            // for (int i = 0; i < currIntensifierEffectBasicList.Count; i++)
            // {
            //     currIntensifierEffectBasicList[i].IntensifierSkillUseBefore(this);
            // }

            SkillCd = SkillMaxCd;
            _enterAlertTarget.Clear();
            UseCount++;
            _triggerData = new TriggerData();
            isUse = true;
            _triggerData.TriggerGuid = UseCount;

            _currUseSkillTarget.Clear();
            currUseAllTimeLineLogic.Clear();
            // CombatEventManager.Instance.Dispatch(CombatEventType.HeroUseSkill, new HeroUseSkillEventData()
            // {
            //     CombatHeroEntity = CombatHeroEntity,
            //     SkillBasic = this
            // });
            ProUseSkill();
        }


        public override void Dispose()
        {
            if (_isDis)
            {
                return;
            }

            _isDis = true;
            currUseAllTimeLineLogic.Clear();
            ProDispose();
            _combatHeroEntity = null;
        }

        public void ReduceCd(float time)
        {
            if (!isActive || !IsCanReduceCd())
            {
                return;
            }

            _skillCd -= time;
        }

        protected virtual bool IsCanReduceCd()
        {
            return true;
        }

        public SpecialDotInfo GetSpecialDotInfo(string specialDotName)
        {
            return _combatHeroEntity.GetSpecialDotInfo(specialDotName);
        }

        public T GetILifetCycleHitPoint<T>(string hitPoinName, bool isStandType, bool isIgnoreHind)
            where T : ILifetCycleHitPoint
        {
            return _combatHeroEntity.GetILifetCycleHitPoint<T>(hitPoinName, isStandType, isIgnoreHind);
        }

        public T GetMainHotPoin<T>(bool isIgnoreHind) where T : ILifetCycleHitPoint
        {
            throw new NotImplementedException();
        }


        public void CloseLoopFx(IGObjectPoolInterface objectPoolInterface)
        {
        }

        /// <summary>
        /// 添加trigger监听事件
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="callBack"></param>
        protected void AddTriggerCallBack(string groupName,
            System.Action<string, CombatHeroHitPoint, ITimelineFxLogic, TriggerData> callBack)
        {
            if (!_triggerCallBack.ContainsKey(groupName))
            {
                _triggerCallBack.Add(groupName, callBack);
            }
        }

        /// <summary>
        /// 移除trigger添加事件
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="callBack"></param>
        protected void RemoveTriggerCallBack(string groupName,
            System.Action<string, TimeLineTriggerType, object, ITimelineFxLogic, object> callBack)
        {
            if (_triggerCallBack.ContainsKey(groupName))
            {
                _triggerCallBack.Remove(groupName);
            }
        }

        /// <summary>
        /// 激活timeLine数据
        /// </summary>
        /// <param name="groupName">组</param>
        /// <param name="currTarget">传递给timeLine的目标</param>
        /// <param name="extraData">透传消息</param>
        /// <param name="customizePos">自定义坐标</param>
        /// <param name="finishCallBack">timeLine完成回调</param>
        public TimeLineEventLogicGroupBasic ActivationTimeLineData(string groupName, string timeLineName = null,
            BetterList<ILifetCycleHitPoint> currTarget = null,
            Vector3[] customizePos = null, System.Action finishCallBack = null, float startTime = default,
            object extraData = null, int indexCount = 0)
        {
            bool isNoAnim = false;
            if (groupName.Contains("noAnim"))
            {
                groupName = groupName.Replace("noAnim", "");
                isNoAnim = true;
            }

            TimeLineEventLogicGroupBasic timeLineEventLogicGroup =
                _combatHeroEntity.combatHeroTimeLineControl
                    .GetTimeLineEventLogicGroup<TimeLineEventLogicGroupBasic>(timeLineName, groupName);
            try
            {
                if (timeLineEventLogicGroup != null)
                {
                    timeLineEventLogicGroup.extraData = extraData;
                    timeLineEventLogicGroup.SetCombatInfo(_combatHeroEntity, this, currTarget, triggerData,
                        customizePos, indexCount);
                    timeLineEventLogicGroup.TimeLineUpdateEnd = finishCallBack;
                    timeLineEventLogicGroup.timeLineTime = startTime;
                    _combatHeroEntity.combatHeroTimeLineControl.AddEventLogicGroup(timeLineEventLogicGroup);
                    currUseAllTimeLineLogic.Add(timeLineEventLogicGroup);
                }
            }
            catch (Exception e)
            {
                LogTool.Error(e);
            }

            return timeLineEventLogicGroup;
        }

        /// <summary>
        /// 打断技能
        /// </summary>
        public void BreakSkill()
        {
            // CombatEventManager.Instance.Dispatch(CombatEventType.BreakSkill, new CombatEventDefaultData()
            // {
            //     datas = new object[2] { _combatHeroEntity, this }
            // });
            for (int i = 0; i < currUseAllTimeLineLogic.Count; i++)
            {
                if (currUseAllTimeLineLogic[i] != null && currUseAllTimeLineLogic[i].CastEntity != CombatHeroEntity)
                {
                    LogTool.Log("对象以移交");
                }
                else
                {
                    currUseAllTimeLineLogic[i].BreakTimeLine(CombatHeroEntity);
                    _combatHeroEntity.combatHeroTimeLineControl.RemoveEventLogicGroup(currUseAllTimeLineLogic[i]);
                }
            }

            currUseAllTimeLineLogic.Clear();
            SkillPlayFinish();
            ProBreakSkill();
        }

        /// <summary>
        /// 技能timeLine的完成标志。表示当前TimeLine播放完成
        /// </summary>
        /// <param name="groupName">那一个组的完成了</param>
        public void TimeLineEndSing(string groupName)
        {
            ProTimeLineEndSing(groupName);
        }

        /// <summary>
        /// 技能更新
        /// </summary>
        /// <param name="time"></param>
        public void CombatUpdate(float time)
        {
            ProCombatUpdate(time);
        }


        /// <summary>
        /// 技能播放完成
        /// </summary>
        public void SkillPlayFinish()
        {
            if (!isUse)
            {
                return;
            }

            isUse = false;
            finishCallBack?.Invoke(this);
            ProSkillPlayFinish();
            finishCallBack = null;
            _isEarlyWarning = false;
            _earlyWarningFristHero = null;
            if (_earlyWarningFx != null)
            {
                GObjectPool.Instance.Recycle(_earlyWarningFx);
                _earlyWarningFx = null;
            }

            // BetterList<IntensifierEffectBasic> currIntensifierEffectBasicList =
            //     SkillIntensifierData.currIntensifierEffectBasicList;
            // for (int i = 0; i < currIntensifierEffectBasicList.Count; i++)
            // {
            //     currIntensifierEffectBasicList[i].IntensifierSkillTimelineFxLogicUseFinish(this);
            // }
        }

        /// <summary>
        /// timeLine和子弹碰撞后会调用
        /// </summary>
        /// <param name="timeLineTriggerType">触发类型，默认没用</param>
        /// <param name="timeLineData">时间线上配置的数据（默认null）</param>
        /// <param name="targetEntity">目标对象（敌人）</param>
        /// <param name="triggerData">触发的额外数据——透传数据</param>
        public void TimeLineTrigger(string groupName, ILifetCycleHitPoint targetEntity,
            ITimelineFxLogic timelineFxLogic, TriggerData triggerData)
        {
            if (targetEntity == null || _isDis)
            {
                return;
            }

            if (_triggerCallBack.ContainsKey(groupName))
            {
                _triggerCallBack[groupName]?.Invoke(groupName,
                    targetEntity != null ? targetEntity.This<CombatHeroHitPoint>() : null, timelineFxLogic,
                    triggerData);
            }
            else
            {
                ProDefaultTimeLineTrigger(groupName,
                    targetEntity != null ? targetEntity.This<CombatHeroHitPoint>() : null, timelineFxLogic,
                    triggerData);
            }
        }


        public ILifetCycleHitPoint[] GetTineLineTargetEntity(TimeLineEventLogicBasic timeLineEventLogicBasic)
        {
            // BetterList<ILifetCycleHitPoint> point = CombatListPool<ILifetCycleHitPoint>.Instance.Get();
            if (_useSkillTargetPool)
            {
                if (_currUseSkillTarget != null && _currUseSkillTarget.Count > 0)
                {
                    return _currUseSkillTarget.ToArray();
                }
            }

            _currUseSkillTarget.Clear();
            ILifetCycleHitPoint[] allHit = ProGetTineLineTargetEntity(timeLineEventLogicBasic);
            _currUseSkillTarget.AddRange(allHit);
            return _currUseSkillTarget.ToArray();
        }


        public ILifetCycleHitPoint[] FilterTarget(TimeLineEventLogicBasic timeLineEventLogicBasic,
            FXTargetType fixtarget, ILifetCycleHitPoint[] target)
        {
            if ((int)fixtarget == 1)
            {
                return target;
            }

            // BetterList<ILifetCycleHitPoint> point = CombatListPool<ILifetCycleHitPoint>.Instance.Get();
            // bool myEnemy = _combatHeroEntity.CombatHeroDataComponent.CurrCombatHeroInfo.IsEnemy;
            // for (int i = 0; i < target.Count; i++)
            // {
            //     bool targetEnemy = target[i].This<CombatHeroEntityHitPoint>().CombatHeroEntity.CombatHeroDataComponent
            //         .CurrCombatHeroInfo.IsEnemy;
            //     if (fixtarget.HasFlag(FXTargetType.Enemy) && targetEnemy != myEnemy)
            //     {
            //         point.Add(target[i]);
            //     }
            //
            //     if (fixtarget.HasFlag(FXTargetType.Teammate) && targetEnemy == myEnemy)
            //     {
            //         point.Add(target[i]);
            //     }
            //
            //     if (fixtarget.HasFlag(FXTargetType.Oneself) &&
            //         target[i].This<CombatHeroEntityHitPoint>().CombatHeroEntity == _combatHeroEntity)
            //     {
            //         point.Add(target[i]);
            //     }
            // }

            return target;
        }


        public ILifetCycleHitPoint[] FilterTargetForCombat(TimeLineEventLogicBasic timeLineEventLogicBasic,
            FXTargetType fixtarget,
            ILifetCycleHitPoint[] target)
        {
            return target;
        }


        protected virtual void ProInitSkill()
        {
        }

        protected abstract void ProUseSkill();

        protected virtual ILifetCycleHitPoint[] ProGetTineLineTargetEntity(
            TimeLineEventLogicBasic timeLineEventLogicBasic)
        {
            if (CombatHeroEntity.CombatAIBasic.currFocusTarget == null)
            {
                return null;
            }

            if (CombatHeroEntity.CombatAIBasic.currFocusTarget is BannerHero)
            {
                return null;
            }

            ILifetCycleHitPoint lifetCycleHitPoint = CombatHeroEntity.CombatAIBasic.currFocusTarget
                .GetThis<CombatHeroEntity>()
                .GetMainHotPoin<ILifetCycleHitPoint>();
            if (lifetCycleHitPoint == null)
            {
                return null;
            }

            return new[] { lifetCycleHitPoint };
        }

        /// <summary>
        /// 默认的触发器
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="timeLineTriggerType"></param>
        /// <param name="timeLineData"></param>
        /// <param name="targetEntity"></param>
        /// <param name="triggerData"></param>
        protected virtual void ProDefaultTimeLineTrigger(string groupName, CombatHeroHitPoint targetEntity,
            ITimelineFxLogic timelineFxLogic, TriggerData triggerData)
        {
        }

        protected virtual void ProSkillPlayFinish()
        {
        }

        protected virtual void ProDispose()
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="groupName"></param>
        protected virtual void ProTimeLineEndSing(string groupName)
        {
            if (string.IsNullOrEmpty(_finishTimeLineGroupName))
            {
                SkillPlayFinish();
            }
            else if (_finishTimeLineGroupName == groupName)
            {
                SkillPlayFinish();
            }
        }

        protected virtual void ProCombatUpdate(float time)
        {
        }

        /// <summary>
        /// 技能被打断
        /// </summary>
        protected virtual void ProBreakSkill()
        {
        }

        protected virtual void ProStartGame()
        {
        }


        public void TimelineFxLogicInit(string groupName, ITimelineFxLogic timelineFxLogic, TriggerData triggerData)
        {
            ProTimelineFxLogicInit(groupName, timelineFxLogic, triggerData);
            TimelineFxLogicInitEventData eventData = TimelineFxLogicInitEventData.Create();
            eventData.SkillBasic = this;
            eventData.timelineFxLogic = timelineFxLogic as FxAILogicBasic;
            CombatEventManager.Instance.Dispatch(CombatEventType.TimelineFxLogicInit, eventData);
        }

        /// <summary>
        /// 实例化出的特效逻辑初始化
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="timelineFxLogic"></param>
        protected virtual void ProTimelineFxLogicInit(string groupName, ITimelineFxLogic timelineFxLogic,
            TriggerData triggerData)
        {
        }

        public void TimeLineTriggerGround(string groupName, ITimelineFxLogic timelineFxLogic, TriggerData triggerData)
        {
            ProTimeLineTriggerGround(groupName, timelineFxLogic, triggerData);
        }

        /// <summary>
        /// 触碰地面
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="timelineFxLogic"></param>
        protected virtual void ProTimeLineTriggerGround(string groupName, ITimelineFxLogic timelineFxLogic,
            TriggerData triggerData)
        {
        }

        public void InitAlert(TimeLineAlertSeriailztion timeLineAlertSeriailztion, GameObject gameObject)
        {
            CombatAlertManager.Instance.AddAlert(gameObject, _combatHeroEntity);
        }

        public void LeaveAlert(TimeLineAlertSeriailztion timeLineAlertSeriailztion, GameObject gameObject)
        {
            _enterAlertTarget.Clear();
            CombatAlertManager.Instance.RemoveAlert(gameObject);
        }

        public void Enter(TimeLineAlertSeriailztion timeLineAlertSeriailztion, Collider collider, GameObject gameObject)
        {
            HeroEntityMono heroEntityMono = collider.gameObject.GetComponent<HeroEntityMono>();
            if (heroEntityMono == null)
            {
                return;
            }

            CombatHeroEntity target = heroEntityMono.combatHeroEntity;
            if (timeLineAlertSeriailztion.isFindEnemy && target.IsEnemy == _combatHeroEntity.IsEnemy ||
                timeLineAlertSeriailztion.isFindMyHero && target.IsEnemy != _combatHeroEntity.IsEnemy)
            {
                return;
            }

            if (_enterAlertTarget.Contains(target))
            {
                return;
            }

            _enterAlertTarget.Add(target);
            if (timeLineAlertSeriailztion.alertType == TimeLineAlertSeriailztion.TimeLineAlertType.Dangerous)
            {
                AlertTriggerEventData alertTriggerEventData = AlertTriggerEventData.Create();
                alertTriggerEventData.combatHeroEntity = target;
                alertTriggerEventData.attackEntity = _combatHeroEntity;
                alertTriggerEventData.collider = collider;
                alertTriggerEventData.triggerObject = gameObject;
                alertTriggerEventData.isTrigger = true;
                CombatEventManager.Instance.Dispatch(CombatEventType.AlertTrigger, alertTriggerEventData);
            }

            ProHeroEnter(timeLineAlertSeriailztion, target);
        }

        protected virtual void ProHeroEnter(TimeLineAlertSeriailztion timeLineAlertSeriailztion,
            CombatHeroEntity target)
        {
        }

        public void Leave(TimeLineAlertSeriailztion timeLineAlertSeriailztion, Collider collider, GameObject gameObject)
        {
            HeroEntityMono heroEntityMono = collider.gameObject.GetComponent<HeroEntityMono>();
            if (heroEntityMono == null || CombatHeroEntity == null)
            {
                return;
            }

            CombatHeroEntity target = heroEntityMono.combatHeroEntity;
            if (target.IsEnemy == CombatHeroEntity.IsEnemy)
            {
                return;
            }

            if (!_enterAlertTarget.Contains(target))
            {
                return;
            }

            _enterAlertTarget.Remove(target);
            if (timeLineAlertSeriailztion.alertType == TimeLineAlertSeriailztion.TimeLineAlertType.Dangerous)
            {
                AlertTriggerEventData alertTriggerEventData = AlertTriggerEventData.Create();
                alertTriggerEventData.combatHeroEntity = target;
                alertTriggerEventData.attackEntity = _combatHeroEntity;
                alertTriggerEventData.collider = collider;
                alertTriggerEventData.isTrigger = false;
                alertTriggerEventData.triggerObject = gameObject;
                CombatEventManager.Instance.Dispatch(CombatEventType.AlertTrigger, alertTriggerEventData);
            }

            ProHeroLeave(timeLineAlertSeriailztion, target);
        }

        protected virtual void ProHeroLeave(TimeLineAlertSeriailztion timeLineAlertSeriailztion,
            CombatHeroEntity target)
        {
        }
    }
}