XiuXianGame/Assets/Scripts/GameLogic/Paritcle/GameTimeLineParticleFactory.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Common.Combat.FxAILogic;
using Fort23.Common;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using UnityEngine;
using UnityEngine.Rendering;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventLogic;

public class GameTimeLineParticleFactory : ITimeLineParticleFactory
{
    protected BetterList<CombatParticleSystemPool> allCombatParticleSystem =
        new BetterList<CombatParticleSystemPool>();

    protected BetterList<FxAILogicBasic> allFxAiLogicBasic = new BetterList<FxAILogicBasic>();


    protected bool _isUpdateState;
    private BetterList<FxAILogicBasic> _removeFxAiLogicBasic = new BetterList<FxAILogicBasic>();

    public void RemoveFxAILogicBasic(FxAILogicBasic fxAILogicBasic)
    {
        if (_isUpdateState)
        {
            _removeFxAiLogicBasic.Add(fxAILogicBasic);
        }
        else
        {
            allFxAiLogicBasic.Remove(fxAILogicBasic);
        }
    }

    public void CombatUpdate(float time)
    {
        _isUpdateState = true;
        for (int i = 0; i < allFxAiLogicBasic.Count; i++)
        {
            allFxAiLogicBasic[i].CombatUpdate(time);
        }

        _isUpdateState = false;
        for (int i = 0; i < _removeFxAiLogicBasic.Count; i++)
        {
            allFxAiLogicBasic.Remove(_removeFxAiLogicBasic[i]);
        }

        _removeFxAiLogicBasic.Clear();
        for (int i = 0; i < allCombatParticleSystem.Count; i++)
        {
            allCombatParticleSystem[i].CombatUpdate(time);
        }
    }

    public void Dispose()
    {
        allFxAiLogicBasic.Clear();
    }

    public void RecycleAllFxAiLogicBasic()
    {
        _isUpdateState = true;
        for (int i = 0; i < allFxAiLogicBasic.Count; i++)
        {
            allFxAiLogicBasic[i].Dispose();
        }

        allFxAiLogicBasic.Clear();
        _removeFxAiLogicBasic.Clear();
        _isUpdateState = false;
    }

    public List<FxAILogicBasic> GetFxAILogicBasic(bool isEnemy)
    {
        List<FxAILogicBasic> allFxAiLogicBasic = new List<FxAILogicBasic>();
        for (int i = 0; i < allFxAiLogicBasic.Count; i++)
        {
            FxAILogicBasic fxAILogicBasic = allFxAiLogicBasic[i];
            if (fxAILogicBasic.CombatHeroEntity.IsEnemy == isEnemy)
            {
                allFxAiLogicBasic.Add(fxAILogicBasic);
            }
        }

        return allFxAiLogicBasic;
    }

    public void RecycleFix()
    {
#if !COMBAT_SERVER


        CombatParticleSystemPool[] pools = allCombatParticleSystem.ToArray();
        if (pools != null)
        {
            List<CombatParticleSystemPool> romvePoll = new List<CombatParticleSystemPool>();
            romvePoll.AddRange(pools);
            for (int i = 0; i < romvePoll.Count; i++)
            {
                if (pools[i] == null)
                {
                    continue;
                }

                if (pools[i].gameObject != null)
                {
                    pools[i].gameObject.SetActive(false);
                    GObjectPool.Instance.Recycle(pools[i]);
                }
            }
        }


#endif
        allCombatParticleSystem.Clear();
    }

    public void RemoveCombatParticleSystemPool(CombatParticleSystemPool combatParticleSystemPool)
    {
        allCombatParticleSystem.Remove(combatParticleSystemPool);
    }

    public Clock CreateParticle(TimeLineEventParticleLogicBasic timeLineEventParticleLogicBasic,
        ILifetCycleHitPoint effectTarget,
        ILifetCycleHitPoint fxTarget, Vector3 startPos, SpecialDotInfo targetSpecialDotInfo,
        Action<IGObjectPoolInterface> callBack)
    {
        Clock clock = CreateParticle(timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.fxName, startPos,
            fxTarget,
            false, targetSpecialDotInfo, delegate(ParticleSystemPool combatParticleSystemPool)
            {
                CombatParticleSystemPool pool = combatParticleSystemPool as CombatParticleSystemPool;
                if (pool == null)
                {
                    callBack?.Invoke(null);
                    return;
                }
#if !COMBAT_SERVER
                pool.InitCombatParticleSystem();
#endif

                CombatHeroEntity combatHeroEntity = null;
                if (targetSpecialDotInfo != null)
                {
                    combatHeroEntity = targetSpecialDotInfo.heroEntity as CombatHeroEntity;

                    // if (!timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.isActivityCustomTargetPos)
                    // {
                    //     startPos = targetSpecialDotInfo.GetWorlPos();
                    // }

                    if (!timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.isNotRotate)
                    {
                        pool.transform.eulerAngles = targetSpecialDotInfo.GetEulerAngles();
                        pool.isNotRotion = false;
                    }
                    else
                    {
                        pool.isNotRotion = true;
                    }


                    // if (heroEntity != null)
                    // {
                    //     pool.transform.SetParent(heroEntity.CombatHeroTransform.iGObjectPoolInterface.own.transform);
                    // }
                    // else
                    // {
                    //     pool.transform.SetParent(targetSpecialDotInfo.targetTran);
                    // }
                }
                else if (fxTarget != null)
                {
                    if (!timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.isNotRotate)
                    {
                        pool.transform.eulerAngles = fxTarget.GetSpecialDotInfo("").GetEulerAngles();
                        pool.isNotRotion = false;
                    }
                    else
                    {
                        pool.isNotRotion = true;
                    }
                }

                if (combatHeroEntity != null && timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.isLoop)
                {
                    combatHeroEntity.heroLoopParticle.Add(pool);
                    pool.HeroEntity = combatHeroEntity;
                }


                pool.gameObject.SetActive(false);
                pool.transform.position = startPos;
                if (timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.isFollowRootTarget &&
                    timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.locationType !=
                    FXLocationType.SceneZero)
                {
                    if (combatHeroEntity != null)
                    {
                        pool.transform.SetParent(combatHeroEntity.GetMainHotPoin<CombatHeroHitPoint>()
                            .GetSpecialDotInfo("").targetTran);
                    }
                    else if (fxTarget != null)
                    {
                        pool.transform.SetParent(fxTarget
                            .GetSpecialDotInfo("").targetTran);
                    }

                    pool.transform.localEulerAngles = Vector3.zero;
                }
                else if (timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.isFollowTarget &&
                         timeLineEventParticleLogicBasic.timeLinePlayFxSerializtion.locationType !=
                         FXLocationType.SceneZero)
                {
                    pool.transform.SetParent(targetSpecialDotInfo.targetTran);
                    pool.transform.localEulerAngles = Vector3.zero;
                    pool.transform.localPosition = Vector3.zero;
                    // pool.targetSpecialDotInfo = targetSpecialDotInfo;
                }
                else
                {
                    // pool.transform.SetParent(null);
                    pool.targetSpecialDotInfo = null;
                }

                FxAILogicBasic fxAILogicBasic = pool.own.GetComponent<FxAILogicBasic>();

                if (fxAILogicBasic != null)
                {
                    if (!allFxAiLogicBasic.Contains(fxAILogicBasic))
                    {
                        allFxAiLogicBasic.Add(fxAILogicBasic);
                    }

                    fxAILogicBasic.SetAIMonoObj(combatParticleSystemPool);
                    fxAILogicBasic.Init(startPos, timeLineEventParticleLogicBasic, effectTarget,
                        targetSpecialDotInfo);
                }
#if !COMBAT_SERVER
                pool.gameObject.SetActive(true);
#endif
                callBack?.Invoke(combatParticleSystemPool);
            });
        return clock;
    }

    public Clock CreateParticle(string fxName, Vector3 startPos, ILifetCycleHitPoint fxTarget, bool isRotate,
        SpecialDotInfo targetSpecialDotInfo, Action<ParticleSystemPool> callBack)
    {
#if !COMBAT_SERVER
        Clock clock = ClockPool.GetClock();


        CTask<CombatParticleSystemPool> task = GObjectPool.Instance.FetchAsync(fxName + ".prefab",
            delegate(CombatParticleSystemPool pool)
            {
                if (pool == null)
                {
                    callBack?.Invoke(null);
                    return;
                }


                if (isRotate && fxTarget != null)
                {
                    SpecialDotInfo specialDotInfo = fxTarget.GetSpecialDotInfo(null);

                    if (specialDotInfo != null)
                    {
                        pool.transform.eulerAngles = specialDotInfo.GetEulerAngles();
                    }
                }

                float size = 1;


                pool.SetSize(size);
                pool.own.transform.position = startPos;

                pool.ClearTrail();
                callBack?.Invoke(pool);
            }, clock);
        return clock;
#else
            callBack?.Invoke(new CombatParticleSystemPool());
            return null;
#endif
    }
}