XiuXianGame/Assets/Scripts/GameLogic/Combat/Buff/BuffBasic.cs

using System;
using System.Collections.Generic;
using CombatLibrary.CombatLibrary.CombatCore.CustomizeTimeLogic.FxLogic;
using Fort23.Core;
using Fort23.UTool;
using UnityEngine;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

namespace GameLogic.Combat.Buff
{
    public class BuffBasic : CObject
    {
        protected CombatHeroEntity combatHeroEntity;
        public BuffInfo buffInf;
        protected CombatHeroEntity source;

        protected TriggerData _triggerData;
        public float _currTime;
        protected float _jianGe;
        public System.Action buffFinish;

        private List<BuffStackInfo> _buffStackInfos = new List<BuffStackInfo>();

        public int buffCount
        {
            get { return _count; }
        }

        protected int _count;
        private float _time;

        public void Init(CombatHeroEntity combatHeroEntity, CombatHeroEntity source, BuffInfo buffInfo)
        {
            _triggerData.Source = this;
            this.combatHeroEntity = combatHeroEntity;
            this.buffInf = buffInfo;
            this.source = source;
            ProInit();
            AddBuffCount(source, buffInfo);
        }

        public void AddBuffCount(CombatHeroEntity source, BuffInfo buffInfo)
        {
            if (buffInfo.BuffConfig.timeType == 1)
            {
                _currTime = 0;
                int c = buffCount + buffInfo.count;
                if (c > buffInfo.BuffConfig.overlayCount)
                {
                    c = buffInfo.BuffConfig.overlayCount - buffCount;
                }
                else
                {
                    c = buffInfo.count;
                }

                if (c <= 0)
                {
                    return;
                }

                _count += c;
            }
            else
            {
                int c = buffCount + buffInfo.count;
                if (c > buffInfo.BuffConfig.overlayCount)
                {
                    c = buffInfo.BuffConfig.overlayCount - buffCount;
                }
                else
                {
                    c = buffInfo.count;
                }

                if (c <= 0)
                {
                    return;
                }

                buffInfo.count = c;
                _count += c;
                BuffStackInfo buffStackInfo = CObjectPool.Instance.Fetch<BuffStackInfo>();
                buffStackInfo.BuffBasic = this;
                buffStackInfo.BuffInfo = buffInfo;
                buffStackInfo.count = c;
                _buffStackInfos.Add(buffStackInfo);
            }


            UpdateEffect();
        }

        protected virtual void ProInit()
        {
        }

        public override void ActiveObj()
        {
        }

        public void UpdateEffect()
        {
            ProUpdateEffect();
        }

        protected virtual void ProUpdateEffect()
        {
        }


        public void ReduceCount(int count)
        {
            if (buffInf.BuffConfig.timeType == 1)
            {
                _count -= count;
                if (_count <= 0)
                {
                    combatHeroEntity.BuffControl.RemoveBuff(this);
                    return;
                }
            }
            else
            {
                while (count > 0)
                {
                    if (_buffStackInfos.Count <= 0)
                    {
                        combatHeroEntity.BuffControl.RemoveBuff(this);
                        return;
                    }

                    BuffStackInfo buffStackInfo = _buffStackInfos[0];
                    if (buffStackInfo.count >= count)
                    {
                        buffStackInfo.count -= count;
                        _count -= count;
                        count = 0;
                        if (buffStackInfo.count == 0)
                        {
                            RemoveBuffStackInfo(buffStackInfo);
                        }
                    }
                    else
                    {
                        int c = buffStackInfo.count;
                        count -= c;
                        _count -= c;
                        buffStackInfo.count = 0;
                        RemoveBuffStackInfo(buffStackInfo);
                    }
                }
            }

            UpdateEffect();
        }

        public TimeLineEventLogicGroupBasic ActivationTimeLineData(string groupName,
            BetterList<ILifetCycleHitPoint> currTarget = null,
            Vector3[] customizePos = null, System.Action finishCallBack = null, float startTime = default,
            object extraData = null, int indexCount = 0)
        {
            TimeLineEventLogicGroupBasic timeLineEventLogicGroup =
                source.combatHeroTimeLineControl
                    .GetTimeLineEventLogicGroup<TimeLineEventLogicGroupBasic>(groupName, null);
            try
            {
                if (timeLineEventLogicGroup != null)
                {
                    timeLineEventLogicGroup.extraData = extraData;
                    timeLineEventLogicGroup.SetCombatInfo(combatHeroEntity, null, 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;
        }

        public override void DormancyObj()
        {
            buffFinish?.Invoke();
            buffFinish = null;
            _currTime = 0;
            ProDormancyObj();
            CObjectPool.Instance.Recycle(buffInf);
            buffInf = null;
            combatHeroEntity = null;
        }

        protected virtual void ProDormancyObj()
        {
        }

        public void Update(float t)
        {
            if (buffInf.BuffConfig.timeType == 1)
            {
                _currTime += t;
                if (buffInf.buffTime > 0 && _currTime > buffInf.buffTime)
                {
                    combatHeroEntity.BuffControl.RemoveBuff(this);
                    return;
                }
            }
            else
            {
                for (int i = 0; i < _buffStackInfos.Count; i++)
                {
                    BuffStackInfo buffStackInfo = _buffStackInfos[i];
                    buffStackInfo.Update(t);
                }
            }

            if (_jianGe > 0)
            {
                _time += t;
                if (_time >= _jianGe)
                {
                    _time -= _jianGe;
                    UpdateJumping();
                }
            }

            ProUpdate(t);
        }

        public void RemoveBuffStackInfo(BuffStackInfo buffStackInfo)
        {
            _buffStackInfos.Remove(buffStackInfo);
            _count -= buffStackInfo.count;
            CObjectPool.Instance.Recycle(buffStackInfo);
            if (_buffStackInfos.Count <= 0)
            {
                combatHeroEntity.BuffControl.RemoveBuff(this);
                return;
            }

            UpdateEffect();
        }

        protected virtual void UpdateJumping()
        {
        }

        protected virtual void ProUpdate(float t)
        {
        }
    }
}