XiuXianGame/Assets/Scripts/GameLogic/Combat/CombatTool/CombatSenceController.cs

using System;
using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Core.Utility;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.CombatScenesTool;
using UnityEngine;
using Random = UnityEngine.Random;

namespace GameLogic.Combat.CombatTool
{
    public class CombatSenceController : IDisposable
    {
        public CombatSencePath currBesselPath;

        public CombatSencePath NextBesselPath;

        private float moveTime;
        private Vector3 lasetPos;
        private float maxD = 100;
        private Vector3 lasetDir;

        public float currTime;
        public Transform moveRoot;

        private List<CombatSencePath> reclaimSence = new List<CombatSencePath>();

        protected GameObjectPool ShengShiQiuTi;

        private float shengShiStartSize=3;
        private float shengShiEndSize=300;
        private float _shengShiAddTime;
        private bool _isUpdateShengShi;

        public async CTask InitScenes()
        {
            GameObject gameObject = new GameObject("mvoeRoot");

            moveRoot = gameObject.transform;
            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();
            await GObjectPool.Instance.FetchAsync<GameObjectPool>("shan1", null, null, true, "shan1");
            ShengShiQiuTi =
                await GObjectPool.Instance.FetchAsync<GameObjectPool>("ShengShiQiuTi", null, null, false,
                    "ShengShiQiuTi");
            ShengShiQiuTi.SetActive(false);
            lasetDir = Vector3.forward;
            lasetPos = new Vector3(0, 5, 0);
            await cTaskAwaitBuffer.WaitAll();
            currBesselPath = InitBesselPath(lasetPos);
        }


        private CombatSencePath InitBesselPath(Vector3 satrtPos)
        {
            CombatSencePath besselPath = new CombatSencePath();

            Vector3 target = satrtPos + lasetDir.normalized * maxD;
            // if (offx == 0)
            {
                besselPath.SetPos(satrtPos, target);
            }
            Vector3 p = besselPath.GetValue(0.99f);
            lasetDir = (target - p).normalized;
            GameObject gameObject = new GameObject("path");
            gameObject.transform.position = satrtPos;
            CombatPathMono combatPathMono = gameObject.AddComponent<CombatPathMono>();
            combatPathMono.BesselPath = besselPath;
            InitZhuangSHi(besselPath);
            return besselPath;
        }

        private CombatSencePath InitBesselPath(Vector3 satrtPos, float offx)
        {
            CombatSencePath besselPath = new CombatSencePath();
            Vector3 dir = Quaternion.LookRotation(lasetDir) * new Vector3(offx, 0, 1);
            Vector3 target = satrtPos + dir.normalized * maxD;
            Vector3 dir2 = Quaternion.LookRotation(lasetDir) * new Vector3(offx * -1, 0, 1);
            Vector3 centre = satrtPos + dir2.normalized * maxD;
            // if (offx == 0)
            {
                besselPath.SetPos(satrtPos, centre, target);
            }
            Vector3 p = besselPath.GetValue(0.99f);
            lasetDir = (target - p).normalized;
            GameObject gameObject = new GameObject("path");
            gameObject.transform.position = satrtPos;
            CombatPathMono combatPathMono = gameObject.AddComponent<CombatPathMono>();
            combatPathMono.BesselPath = besselPath;
            InitZhuangSHi(besselPath);
            return besselPath;
        }

        private async CTask InitZhuangSHi(CombatSencePath besselPath)
        {
            int count = Random.Range(30, 40);
            for (int i = 0; i < count; i++)
            {
                float md = Random.Range(0.1f, 0.9f);
                Vector3 p = besselPath.GetValue(md);
                Vector3 p2 = besselPath.GetValue(md - 0.01f);
                Vector3 dir = (p - p2);
                Vector3 cross = Vector3.Cross(dir, Vector3.up);
                cross = cross.normalized;
                int odds = Random.Range(0, 100);
                p += cross * Random.Range(8, 25) * (odds < 50 ? 1 : -1);
                GameObjectPool gameObjectPool =
                    await GObjectPool.Instance.FetchAsync<GameObjectPool>("shan1", null, poolName: "shan1");
                GameObject g = gameObjectPool.own;
                g.SetActive(true);
                besselPath.allPool.Add(gameObjectPool);
                g.transform.position = new Vector3(p.x, 0, p.z) + new Vector3(0, Random.Range(-4, -1), 0);
                g.transform.eulerAngles = new Vector3(-90, 0, Random.Range(0, 360));
            }
        }

        public Vector3 GetTarget(float time)
        {
            if (time > 1)
            {
                if (NextBesselPath == null)
                {
                    NextBesselPath = InitBesselPath(currBesselPath.b, 0);
                }

                time = time % 1;
                return NextBesselPath.GetValue(time);
            }
            else
            {
                return currBesselPath.GetValue(time);
            }
        }

        public Vector3 GetNextPoint(float time)
        {
            if (NextBesselPath == null)
            {
                NextBesselPath = InitBesselPath(currBesselPath.b, 0);
            }

            return NextBesselPath.GetValue(time);
        }

        public Vector3 Move(float dis)
        {
            float t = dis / currBesselPath.len;
            currTime += t;
            // Debug.Log("移动速度" + t + "/" + currBesselPath.len);

            Vector3 targetPos = Vector3.zero;
            if (currTime > 0.2f)
            {
                if (NextBesselPath == null)
                {
                    int odds = Random.Range(0, 100);
                    if (odds < 50)
                    {
                        NextBesselPath = InitBesselPath(currBesselPath.b, Random.Range(0, 100) < 50 ? -1 : 1);
                    }
                    else
                    {
                        NextBesselPath = InitBesselPath(currBesselPath.b);
                    }
                }
            }

            if (currTime > 1)
            {
                if (NextBesselPath == null)
                {
                    NextBesselPath = InitBesselPath(currBesselPath.b, Random.Range(0, 100) < 50 ? -1 : 1);
                }

                currTime = currTime % 1;
                // targetPos = NextBesselPath.GetValue(currTime);
                currBesselPath.reclaimTime = 3;
                reclaimSence.Add(currBesselPath);
                currBesselPath = NextBesselPath;
                NextBesselPath = null;
                CombatEventManager.Instance.Dispatch(CombatEventType.SencenBesselPathAlter, null);
            }
            else
            {
            }

            targetPos = currBesselPath.GetValue(currTime);
            moveRoot.transform.position = targetPos;
            return targetPos;
        }

        public void StartPayShengShi(Transform root)
        {
            ShengShiQiuTi.own.transform.SetParent(root);
            ShengShiQiuTi.own.transform.localPosition=Vector3.zero;
            ShengShiQiuTi.SetActive(true);
            _isUpdateShengShi = true;
            ShengShiQiuTi.own.transform.localScale = Vector3.one * shengShiStartSize;
            _shengShiAddTime = 0;
        }

        public void Update(float t)
        {
            if (_isUpdateShengShi)
            {
                _shengShiAddTime += t * 1f;
                float v = Mathf.Lerp(shengShiStartSize, shengShiEndSize, _shengShiAddTime);
                ShengShiQiuTi.own.transform.localScale = Vector3.one * v;
                if (_shengShiAddTime >= 1)
                {
                    ShengShiQiuTi.SetActive(false);
                    _isUpdateShengShi = false;
                }
            }

            for (int i = 0; i < reclaimSence.Count; i++)
            {
                CombatSencePath sencePath = reclaimSence[i];
                sencePath.reclaimTime -= t;
                if (sencePath.reclaimTime < 0)
                {
                    sencePath.DormancyObj();
                    reclaimSence.RemoveAt(i);
                }
            }
        }


        public void Dispose()
        {
            // GObjectPool.Instance.
        }
    }
}