5.24BuYu/Assets/MyGame/Scripts/Characters/Monster/MonsterMoveLine.cs

#region AI优化
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using System;
using System.Globalization;
[Serializable]
public class MonsterMoveLine
{
    public static Dictionary<string, BezierCurveData> dic_BezierCurveDatas = new Dictionary<string, BezierCurveData>();
    public static List<BezierCurveData> curves = new List<BezierCurveData>();

    // ----------------------------------------------------------------
    // ⭐ 性能优化：曲线点数组静态缓存
    //   每条曲线的 [start, controlPoints..., end] 预组装成 Vector2[]，
    //   所有鱼共享同一份数组，避免每帧每鱼 new List + ToArray 的 GC 分配。
    //   加载时构建，卸载时清理。
    // ----------------------------------------------------------------
    private static readonly Dictionary<string, Vector2[]> _curvePointsArrays
        = new Dictionary<string, Vector2[]>();

    /// <summary>⭐ B样条节点向量缓存（曲线名 → 节点数组，与点数组同步构建/清理）</summary>
    private static readonly Dictionary<string, float[]> _curveKnotArrays
        = new Dictionary<string, float[]>();
    [Serializable]
    public class BezierCurveData
    {
        public string name;
        public Vector2 start;
        public List<Vector2> controlPoints = new List<Vector2>();
        public Vector2 end;
    }

    /// <summary>加载当前玩法路线。onProgress：0~1 进度回调（供进房进度条；路线文本可能和鱼资源在同一个大包里，
    /// 包的解压耗时会体现在这里，避免大包场景进度条失真）</summary>
    public static async Task LoadBezier(Action<float> onProgress = null)
    {
        await LoadBezierTxtAsync("MoveLine", onProgress);
    }
    public static async Task UnLoadBezier()
    {
        await UnLoadBezierTxtAsync("MoveLine");
    }

    public static async Task LoadSingleBezierTxtAsync(string path)
    {
        AsyncOperationHandle<TextAsset> handle = Addressables.LoadAssetAsync<TextAsset>(path);
        await handle.Task;
        var lines = handle.Result.text.Split('\n');

        foreach (var line in lines)
        {
            if (string.IsNullOrWhiteSpace(line)) continue;

            var parts = line.Split(';');
            BezierCurveData curve = new BezierCurveData();
            curve.name = parts[0];

            List<Vector2> points = new List<Vector2>();
            for (int i = 1; i < parts.Length; i++)
            {
                if (string.IsNullOrWhiteSpace(parts[i]))
                    continue;
                // ⭐ 单点格式错误只跳过该点并告警，不能让整条路线（乃至进房加载流程）中断
                if (TryParseVector(parts[i], out var p))
                    points.Add(p);
                else
                    Debug.LogWarning($"[MonsterMoveLine] 坐标格式非法已跳过: '{parts[i]}'（{handle.Result.name} 曲线 {curve.name}）");
            }

            if (points.Count == 0) continue;

            curve.start = points[0];
            if (points.Count > 1)
                curve.end = points[points.Count - 1];

            for (int i = 1; i < points.Count - 1; i++)
                curve.controlPoints.Add(points[i]);

            // ⭐ 座位镜像：本端在上方座位时路线整条上下翻转（写入字典/建缓存前，只翻一次）
            FlipCurveYForMirror(curve);

            curves.Add(curve);
            dic_BezierCurveDatas.Add(curve.name, curve);
            // ⭐ 同步构建点数组缓存（单条加载路径）
            BuildCurvePointsArray(curve);
        }
    }

    /// <summary>
    /// ⭐ 座位镜像：路线整条上下翻转（所有点 y 关于画布中心取反，画布坐标以中心为原点）。
    /// B样条求值(de Boor)是逐点线性插值，对控制点 y 取反后求样条 ≡ 原样条求值后 y 取反，
    /// 曲线形状严格镜像不形变。必须在写入 dic_BezierCurveDatas / BuildCurvePointsArray
    /// 之前调用（curves 列表与字典引用同一实例，只翻一次）。
    /// 下游自动适应：取点/移动/朝向切线/鱼阵 700 起点/翻面/分布角全部基于翻转后数据；
    /// 仅 701 环形阵写死的"固定向上"需在 MonsterContral 里随镜像取反。
    /// </summary>
    private static void FlipCurveYForMirror(BezierCurveData curve)
    {
        if (!SeatMirror.IsMirrored) return;

        curve.start.y = -curve.start.y;
        curve.end.y = -curve.end.y;
        for (int i = 0; i < curve.controlPoints.Count; i++)
        {
            Vector2 p = curve.controlPoints[i];
            p.y = -p.y;
            curve.controlPoints[i] = p;
        }
    }

    /// <summary>
    /// ⭐ 将曲线的 [start, controlPoints..., end] 组装成 Vector2[] 并缓存。
    ///   所有引用此曲线的鱼共享同一份数组，避免每帧每鱼 new List + ToArray 的 GC。
    /// </summary>
    private static void BuildCurvePointsArray(BezierCurveData curve)
    {
        // ⭐ 无条件覆盖重建：同名曲线被覆盖时，点数组/节点缓存必须同步重建，
        //   否则字典指向新曲线、缓存还是旧曲线的点 → 路线错乱
        int total = 2 + curve.controlPoints.Count; // start + controls + end
        Vector2[] arr = new Vector2[total];
        arr[0] = curve.start;
        for (int i = 0; i < curve.controlPoints.Count; i++)
            arr[1 + i] = curve.controlPoints[i];
        arr[total - 1] = curve.end;

        _curvePointsArrays[curve.name] = arr;

        // ⭐ 同步构建 B样条节点向量缓存
        _curveKnotArrays[curve.name] = BuildKnotVector(total);
    }

    /// <summary>
    /// ⭐ 构建钳位(clamped)均匀 B样条节点向量。
    ///   首尾各重复 p+1 个 0/1 → 曲线严格过首末控制点(start/end)，鱼的出入屏位置与路线数据一致；
    ///   内部节点在 (0,1) 均匀分布。度数 p = min(3, 控制点数-1)，点不足时自动降阶。
    /// </summary>
    private static float[] BuildKnotVector(int controlPointCount)
    {
        int p = Mathf.Min(3, controlPointCount - 1);
        int knotCount = controlPointCount + p + 1;
        float[] knots = new float[knotCount];

        // 首尾钳位：前 p+1 个 0，后 p+1 个 1
        for (int i = 0; i <= p; i++) knots[i] = 0f;
        for (int i = controlPointCount; i < knotCount; i++) knots[i] = 1f;

        // 内部节点：i = p+1 .. N-1，均匀分布在 (0,1)
        float denom = controlPointCount - p;
        for (int i = p + 1; i < controlPointCount; i++)
            knots[i] = (i - p) / denom;

        return knots;
    }

    /// <summary>
    /// ⭐ 路线加载句柄（保留到离房才释放）：
    ///   路线文本常和鱼资源打在同一个大包里。旧实现"读完文本立即 Release"，
    ///   单一大包场景下引用归零 → 大包立即卸载 → LoadFishAssetsData 又重新加载同一个包
    ///   （同一个 LZMA 大包解压两次 + 内存暴涨→回落→再暴涨的过山车）。
    ///   现在句柄保留，与鱼包句柄共存，离房 UnLoadBezierTxtAsync 统一释放。
    /// </summary>
    private static AsyncOperationHandle<IList<TextAsset>> _bezierHandles;

    public static async Task LoadBezierTxtAsync(string path, Action<float> onProgress = null)
    {
        // ⭐ 资源加载超过 0.1 秒才显示"加载中"界面（引用计数，快速加载不显示）
        UIManager.BeginLoading();
        try { await LoadBezierTxtAsyncCore(path, onProgress); }
        finally { UIManager.EndLoading(); }
    }

    /// <summary>LoadBezierTxtAsync 的实际逻辑（外层负责"加载中"界面）</summary>
    private static async Task LoadBezierTxtAsyncCore(string path, Action<float> onProgress)
    {
        // ⭐ 加载前先全量清空上一场的路线缓存：
        //   各玩法普通路线/鱼阵曲线名完全重名（曲线1~N、鱼阵N）但坐标不同，
        //   不清场会把上一玩法的同名坐标带进本场 → 路线错乱（如 HHWK 残留导致 FLZY 鱼按旧路线游）；
        //   旧玩法独有的 Boss 路线也会残留越积越多。进游戏只需要当前玩法的路线。
        ClearAllBezierCache();

        List<string> keys = new List<string>();
        keys.Add(path);
        keys.Add(GameManager.Instance.gameData.currGameType.ToString());

        // ⭐ 防御：上一轮句柄未释放（如离房流程被跳过）时先释放，避免引用计数累加
        if (_bezierHandles.IsValid())
            Addressables.Release(_bezierHandles);

        _bezierHandles = Addressables.LoadAssetsAsync<TextAsset>(
            keys, null, Addressables.MergeMode.Intersection);

        // ⭐ 轮询上报进度（0~85% 为加载段）：路线文本常和鱼资源打在同一个大包里，
        //   大包的解压耗时发生在这里，必须反映到进度条（否则单一大包场景进度失真：
        //   卡在路线段不动，后面的"鱼包段"反而秒过）。无回调时直接等完成。
        if (onProgress != null)
        {
            while (!_bezierHandles.IsDone)
            {
                onProgress(0.85f * _bezierHandles.PercentComplete);
                await Task.Delay(50);
            }
        }
        else
        {
            await _bezierHandles.Task;
        }

        // ⭐ 没有资源 → 直接跳出，不报错（缓存已清空，保持干净状态）
        //   句柄保留（离房统一释放），防止路线与鱼同包时提前卸掉大包
        if (_bezierHandles.Result == null || _bezierHandles.Result.Count == 0)
        {
            Debug.LogWarning($"Bezier 曲线加载跳过：未找到标签 {path} + {GameManager.Instance.gameData.currGameType}");
            onProgress?.Invoke(1f);
            return;
        }

        // ⭐ 主线程只做 Unity API 访问：把每个 TextAsset 的 name/text 读成纯托管字符串。
        //   .text 返回托管 string 拷贝，句柄保留期间数据稳定，后台线程可安全使用。
        //   （句柄不再立即 Release —— 路线与鱼同包时提前释放会把整个大包卸掉）
        int fileCount = _bezierHandles.Result.Count;
        string[] fileNames = new string[fileCount];
        string[] fileTexts = new string[fileCount];
        for (int i = 0; i < fileCount; i++)
        {
            fileNames[i] = _bezierHandles.Result[i].name;
            fileTexts[i] = _bezierHandles.Result[i].text;
        }
        onProgress?.Invoke(0.88f);

        // ⭐ 座位镜像状态主线程读一次传入后台（后台线程不访问任何 Unity/游戏静态状态）
        bool mirrored = SeatMirror.IsMirrored;
        var warnings = new List<string>();

        // ⭐ 重活挪到后台线程：全部路线文件的 Split + 逐坐标点 float 解析是纯托管计算，
        //   文件大时主线程同步解析会卡死数秒（进度条停在20%冻结的根源）。
        //   await 完成后自动切回 Unity 主线程再写共享缓存。
        var parsedCurves = await Task.Run(() => ParseBezierFiles(fileNames, fileTexts, mirrored, warnings));

        // 后台收集的告警回主线程输出（Debug API 只能在主线程调用），只打前 20 条防刷屏
        for (int i = 0; i < warnings.Count && i < 20; i++)
            Debug.LogWarning(warnings[i]);

        // ⭐ 回到主线程写共享缓存 + 构建点数组/节点向量缓存
        //   （同名直接覆盖，清场后理论上无重复，防御性覆盖确保永远用当前玩法数据）
        foreach (var curve in parsedCurves)
        {
            curves.Add(curve);
            dic_BezierCurveDatas[curve.name] = curve;
            BuildCurvePointsArray(curve);
        }
        onProgress?.Invoke(1f);

        // ⭐ 座位镜像状态提示：镜像未初始化(-1)时按不镜像处理，排查进房时序问题用
        if (SeatMirror.LocalServerPos < 0)
            Debug.LogWarning("[MonsterMoveLine] 加载路线时 SeatMirror 未初始化(未收到 RoomJoinNotice)，本次按不镜像处理");
        Debug.Log($"曲线读取完成共{dic_BezierCurveDatas.Count}条 镜像={SeatMirror.IsMirrored}(本地服务端座位={SeatMirror.LocalServerPos})");
    }

    /// <summary>
    /// ⭐ 后台线程解析全部路线文本（纯托管计算，禁止访问任何 Unity API）：
    ///   逐行 Split + InvariantCulture float 解析 + 曲线组装 + 镜像翻转（镜像标志由主线程传入）。
    ///   解析告警收集到 warnings 列表，由调用方回主线程统一输出。
    /// </summary>
    private static List<BezierCurveData> ParseBezierFiles(string[] fileNames, string[] fileTexts, bool mirrored, List<string> warnings)
    {
        var result = new List<BezierCurveData>();
        for (int f = 0; f < fileTexts.Length; f++)
        {
            var lines = fileTexts[f].Split('\n');
            foreach (var line in lines)
            {
                if (string.IsNullOrWhiteSpace(line))
                    continue;

                var parts = line.Split(';');
                if (parts.Length < 2)
                    continue;

                BezierCurveData curve = new BezierCurveData();
                curve.name = parts[0];

                List<Vector2> points = new List<Vector2>();
                for (int i = 1; i < parts.Length; i++)
                {
                    if (!string.IsNullOrWhiteSpace(parts[i]))
                    {
                        // ⭐ 单点格式错误只跳过该点并告警，不能让整条路线（乃至进房加载流程）中断
                        if (TryParseVector(parts[i], out var p))
                        {
                            points.Add(p);
                        }
                        else
                        {
                            warnings.Add($"[MonsterMoveLine] 坐标格式非法已跳过: '{parts[i]}'（{fileNames[f]} 曲线 {curve.name}）");
                        }
                    }
                }

                if (points.Count == 0)
                    continue;

                curve.start = points[0];
                if (points.Count > 1)
                    curve.end = points[points.Count - 1];

                for (int i = 1; i < points.Count - 1; i++)
                    curve.controlPoints.Add(points[i]);

                // ⭐ 座位镜像：本端在上方座位时路线整条上下翻转（与 FlipCurveYForMirror 同逻辑）。
                //   B样条求值(de Boor)是逐点线性插值，对控制点 y 取反后求样条 ≡ 原样条求值后 y 取反，
                //   曲线形状严格镜像不形变。
                if (mirrored)
                {
                    curve.start.y = -curve.start.y;
                    curve.end.y = -curve.end.y;
                    for (int i = 0; i < curve.controlPoints.Count; i++)
                    {
                        Vector2 p = curve.controlPoints[i];
                        p.y = -p.y;
                        curve.controlPoints[i] = p;
                    }
                }

                result.Add(curve);
            }
        }
        return result;
    }

    public static async Task UnLoadBezierTxtAsync(string path)
    {
        // ⭐ 释放路线加载句柄（与鱼包句柄共同归零后，路线/鱼共用的大包才真正卸载）
        if (_bezierHandles.IsValid())
        {
            Addressables.Release(_bezierHandles);
        }

        // ⭐ 全量同步清空，不再按 currGameType 重查 Addressables 删除：
        //   1. 卸载依赖 currGameType 有时序风险 —— 选房面板在玩家点选新玩法时就改了全局类型，
        //      延迟执行的卸载（OnHide 补卸载/异常重跑）会按新玩法 txt 去删 → 旧玩法 Boss 路线全部残留；
        //      甚至可能把新玩法刚加载的路线误删。
        //   2. 原实现标签查询为空时静默 return，什么都清不掉。
        //   卸载只发生在离房时，场上只有当前玩法的路线，直接全清最干净且无竞态。
        ClearAllBezierCache();

        Debug.Log("曲线卸载完成，剩余曲线数量：" + dic_BezierCurveDatas.Count);
        await Task.CompletedTask;
    }

    /// <summary>全量清空路线缓存（曲线字典/列表 + 点数组缓存 + B样条节点缓存）</summary>
    private static void ClearAllBezierCache()
    {
        dic_BezierCurveDatas.Clear();
        curves.Clear();
        _curvePointsArrays.Clear();
        _curveKnotArrays.Clear();
    }

    private static bool TryParseVector(string s, out Vector2 v)
    {
        v = default;
        var xy = s.Split(',');
        if (xy.Length < 2) return false;
        // ⭐ 固定用 InvariantCulture：曲线文件是 "x,y" 机器格式，不能受设备区域的小数点符号影响
        if (!float.TryParse(xy[0], NumberStyles.Float, CultureInfo.InvariantCulture, out float x)) return false;
        if (!float.TryParse(xy[1], NumberStyles.Float, CultureInfo.InvariantCulture, out float y)) return false;
        v = new Vector2(x, y);
        return true;
    }

    public BezierCurveData bezierCurveData;
    public float moveTime;
    public float moveSpeed;

    // ⭐ 缓存相机和 UI 根 RectTransform，避免每帧每鱼调用
    //   UIManager.Instance.uiRoot.GetComponent<RectTransform>() 和 Camera.main
    //   由 MonsterContral.OnEnable 同步赋值
    public Camera cachedCamera;
    public RectTransform cachedUirootRect;

    public void Init(BezierCurveData bezierCurveData, float Time)
    {
        this.bezierCurveData = bezierCurveData;
        this.moveTime = Time;
        Debug.Log($"初始化曲线 {this.bezierCurveData.name} ,移动时间 {moveTime}");
    }

    /// <summary>
    /// 主线程零分配计算曲线点（⭐ B样条 de Boor 算法；原贝塞尔 De Casteljau 已注释保留备查，方法名保留兼容调用处）。
    /// ⭐ 钳位(clamped)均匀三次 B样条：
    ///   - 节点向量首尾各重复 p+1 个 0/1 → 曲线严格过首控制点(start)和末控制点(end)，
    ///     鱼的出入屏位置与路线数据一致
    ///   - 中间控制点只被逼近不再穿过（与贝塞尔的本质区别）
    ///   - 控制点总数 ≤ 4 时钳位B样条数学上退化为同阶贝塞尔，短路线行为天然兼容
    ///   - 度数 p = min(3, N-1)：仅 start+end 两点时退化为直线段
    /// ⭐ 优化说明（原 Job 方案的负优化问题）：
    ///   1. 原 GetBezierPointJob 每次调用 new List + 2 个 NativeArray(TempJob) + ToArray，
    ///      每条鱼每帧产生 3 次堆分配，N 条鱼 = 3N 次 GC 分配/帧
    ///   2. 原 Job.Schedule() 后立即 Complete()，Job 实际单线程执行，
    ///      调度开销 > 计算收益（4-7 个控制点的计算量极小）
    ///   3. 现方案：曲线点数组+节点向量静态缓存（共享），主线程直接计算，零 GC 分配
    ///   4. Camera/RectTransform 由调用方缓存，避免每帧每鱼重复获取
    /// </summary>
    public Vector2 GetBezierPointJob(float t)
    {
        // ⭐ 防止除零:moveTime<=0 时直接返回起点,避免 NaN
        if (moveTime <= 0f)
            return bezierCurveData.start;

        if (t > moveTime)
            t = moveTime;
        t = t / moveTime;

        // ⭐ 取静态缓存的曲线点数组（所有鱼共享，零分配）
        if (!_curvePointsArrays.TryGetValue(bezierCurveData.name, out var pts))
        {
            // 兜底：缓存未命中时实时构建（理论上不应发生，加载时已构建）
            BuildCurvePointsArray(bezierCurveData);
            pts = _curvePointsArrays[bezierCurveData.name];
        }

        // ⭐ 取静态缓存的 B样条节点向量（加载时与点数组同步构建）
        if (!_curveKnotArrays.TryGetValue(bezierCurveData.name, out var knots))
        {
            // 兜底：缓存未命中时实时构建
            knots = BuildKnotVector(pts.Length);
            _curveKnotArrays[bezierCurveData.name] = knots;
        }

        // ⭐ 复用线程静态缓冲区（主线程单线程执行，安全复用）
        if (_tempPoints == null || _tempPoints.Length < pts.Length)
            _tempPoints = new Vector2[pts.Length];
        Array.Copy(pts, _tempPoints, pts.Length);

        int count = pts.Length;          // 控制点总数 N = start + 控制点 + end
        int p = Mathf.Min(3, count - 1); // ⭐ B样条度数：默认三次，控制点不足时自动降阶

        Vector2 canvasPos;

        // ⭐ 钳位B样条端点：曲线严格过首末控制点；de Boor 在端点节点区间退化，直接取端点等价且更稳
        if (t <= 0f)
        {
            canvasPos = pts[0];
        }
        else if (t >= 1f)
        {
            canvasPos = pts[count - 1];
        }
        else
        {
            // ================= 贝塞尔(De Casteljau)已停用，注释保留备查 =================
            // int c = pts.Length;
            // while (c > 1)
            // {
            //     for (int i = 0; i < c - 1; i++)
            //         _tempPoints[i] = Vector2.Lerp(_tempPoints[i], _tempPoints[i + 1], t);
            //     c--;
            // }
            // canvasPos = _tempPoints[0];
            // ==========================================================================

            // ================= ⭐ B样条求值(de Boor 递推) =================
            // 找节点区间 k: knots[k] <= u < knots[k+1]，k ∈ [p, N-1]
            int k = p;
            while (k < count - 1 && t >= knots[k + 1])
                k++;

            // d[j] = pts[j + k - p]，j = 0..p（取当前区间涉及的 p+1 个控制点）
            for (int j = 0; j <= p; j++)
                _tempPoints[j] = pts[j + k - p];

            // de Boor 逐层递推（结构同 De Casteljau，alpha 改由节点向量决定）
            for (int r = 1; r <= p; r++)
            {
                for (int j = p; j >= r; j--)
                {
                    // 分母区间 [j+k-p, j+1+k-r] ⊇ 当前节点区间 [k, k+1]，恒非退化，无除零风险
                    float alpha = (t - knots[j + k - p]) / (knots[j + 1 + k - r] - knots[j + k - p]);
                    _tempPoints[j] = Vector2.Lerp(_tempPoints[j - 1], _tempPoints[j], alpha);
                }
            }
            canvasPos = _tempPoints[p];
            // ====================================================================
        }

        // ⭐ 用缓存的 Camera/RectTransform，避免每帧每鱼查询
        var cam = cachedCamera != null ? cachedCamera : Camera.main;
        var rect = cachedUirootRect != null
            ? cachedUirootRect
            : UIManager.Instance.uiRoot.GetComponent<RectTransform>();

        return CoordinateTransformation.CanvasToWorld(canvasPos, rect, cam);
    }

    /// <summary>主线程复用的临时计算缓冲（避免每帧每鱼 new 数组）</summary>
    [ThreadStatic]
    private static Vector2[] _tempPoints;
}
#endregion


#region zijixie

//using System.Collections;
//using System.Collections.Generic;
//using System.IO;
//using System.Threading.Tasks;
//using UnityEngine;
//using UnityEngine.AddressableAssets;
//using UnityEngine.ResourceManagement.AsyncOperations;

//public class MonsterMoveLine
//{
//    public static Dictionary<string, BezierCurveData> dic_BezierCurveDatas = new Dictionary<string, BezierCurveData>();
//    public static List<BezierCurveData> curves = new List<BezierCurveData>();
//    public class BezierCurveData
//    {
//        public string name;
//        public Vector2 start;
//        public List<Vector2> controlPoints = new List<Vector2>();
//        public Vector2 end;
//    }

//    public static async void LoadBezier()
//    {
//        await LoadBezierTxtAsync("MoveLine");
//    }
//    /// <summary>
//    /// 读取曲线数据 读取单个
//    /// </summary>
//    /// <param name="path"></param>
//    /// <returns></returns>
//    public static async Task LoadSingleBezierTxtAsync(string path)
//    {
//        AsyncOperationHandle<TextAsset> handle = Addressables.LoadAssetAsync<TextAsset>(path);
//        await handle.Task;
//        var lines = handle.Result.text.Split('\n');


//        foreach (var line in lines)
//        {
//            if (string.IsNullOrWhiteSpace(line)) continue;

//            var parts = line.Split(';');
//            BezierCurveData curve = new BezierCurveData();

//            // 第一个是曲线名
//            curve.name = parts[0];

//            // 后面所有都是点
//            List<Vector2> points = new List<Vector2>();
//            for (int i = 1; i < parts.Length; i++)
//            {
//                points.Add(ParseVector(parts[i]));
//            }

//            // 第一个点是 start
//            curve.start = points[0];
//            if (points.Count > 1)
//            {
//                // 最后一个点是 end
//                curve.end = points[points.Count - 1];
//            }


//            // 中间的都是 controlPoints
//            for (int i = 1; i < points.Count - 1; i++)
//            {
//                curve.controlPoints.Add(points[i]);
//            }

//            curves.Add(curve);
//            dic_BezierCurveDatas.Add(curve.name, curve);

//        }
//    }
//    /// <summary>
//    /// 读取曲线数据 游戏开始时在awake调用aa包
//    /// </summary>
//    /// <param name="path"></param>
//    /// <returns></returns>
//    public static async Task LoadBezierTxtAsync(string path)
//    {
//        List<string> keys = new List<string>();
//        keys.Add(path);
//        keys.Add(GameManager.Instance.gameData.currGameType.ToString());
//        AsyncOperationHandle<IList<TextAsset>> handles = Addressables.LoadAssetsAsync<TextAsset>(keys, null, Addressables.MergeMode.Intersection);
//        await handles.Task;
//        foreach (var text in handles.Result)
//        {
//            var lines = text.text.Split('\n');


//            foreach (var line in lines)
//            {
//                if (string.IsNullOrWhiteSpace(line)) continue;

//                var parts = line.Split(';');
//                BezierCurveData curve = new BezierCurveData();

//                // 第一个是曲线名
//                curve.name = parts[0];

//                // 后面所有都是点
//                List<Vector2> points = new List<Vector2>();
//                for (int i = 1; i < parts.Length; i++)
//                {
//                    points.Add(ParseVector(parts[i]));
//                }

//                // 第一个点是 start
//                curve.start = points[0];
//                if (points.Count > 1)
//                {
//                    // 最后一个点是 end
//                    curve.end = points[points.Count - 1];
//                }


//                // 中间的都是 controlPoints
//                for (int i = 1; i < points.Count - 1; i++)
//                {
//                    curve.controlPoints.Add(points[i]);
//                }

//                curves.Add(curve);
//                dic_BezierCurveDatas.Add(curve.name, curve);

//            }
//        }

//        Debug.Log("曲线读取完成共" + dic_BezierCurveDatas.Count + "条");

//    }

//    private static Vector2 ParseVector(string s)
//    {
//        var xy = s.Split(',');
//        return new Vector2(float.Parse(xy[0]), float.Parse(xy[1]));
//    }


//    public BezierCurveData bezierCurveData;
//    public float moveTime;
//    public float moveSpeed;

//    public void Init(BezierCurveData bezierCurveData, float Time)
//    {
//        this.bezierCurveData = bezierCurveData;
//        this.moveTime = time;
//        Debug.Log($"初始化曲线 {this.bezierCurveData.name} ,移动时间 {moveTime}");
//    }
//    /// <summary>
//    /// 获取曲线上的点
//    /// </summary>
//    /// <param name="t"></param>
//    /// <returns></returns>
//    public Vector2 GetBezierPoint(float t)
//    {
//        t = t / moveTime;
//        BezierCurveData curve = bezierCurveData;
//        List<Vector2> points = new List<Vector2>();
//        points.Add(curve.start);
//        points.AddRange(curve.controlPoints);
//        points.Add(curve.end);

//        return DeCasteljau_BY(points, t % 1);
//    }

//    /// <summary>
//    /// 贝塞尔
//    /// </summary>
//    /// <param name="points"></param>
//    /// <param name="t"></param>
//    /// <returns></returns>
//    private Vector2 DeCasteljau_BSE(List<Vector2> points, float t)
//    {
//        while (points.Count > 1)
//        {
//            List<Vector2> next = new List<Vector2>();
//            for (int i = 0; i < points.Count - 1; i++)
//            {
//                next.Add(Vector2.Lerp(points[i], points[i + 1], t));
//            }
//            points = next;
//        }
//        return CoordinateTransformation.CanvasToWorld(points[0], UIManager.Instance.uiRoot.GetComponent<RectTransform>(), Camera.main);
//    }
//    /// <summary>
//    /// B样
//    /// </summary>
//    /// <param name="points"></param>
//    /// <param name="t"></param>
//    /// <returns></returns>
//    private Vector2 DeCasteljau_BY(List<Vector2> points, float t)
//    {
//        // 方法A：保持德卡斯特里奥算法（推荐，数值更稳定）
//        while (points.Count > 1)
//        {
//            List<Vector2> next = new List<Vector2>();
//            for (int i = 0; i < points.Count - 1; i++)
//            {
//                next.Add(Vector2.Lerp(points[i], points[i + 1], t));
//            }
//            points = next;
//        }
//        return CoordinateTransformation.CanvasToWorld(points[0],
//               UIManager.Instance.uiRoot.GetComponent<RectTransform>(), Camera.main);

//        /* 方法B：伯恩斯坦多项式形式（标准贝塞尔公式）- 如果要用这个替换上面的循环
//        int n = points.Count - 1;
//        Vector2 result = Vector2.zero;
//        for (int i = 0; i <= n; i++)
//        {
//            float bernstein = BinomialCoefficient(n, i) * Mathf.Pow(t, i) * Mathf.Pow(1 - t, n - i);
//            result += points[i] * bernstein;
//        }
//        return CoordinateTransformation.CanvasToWorld(result, 
//               UIManager.Instance.uiRoot.GetComponent<RectTransform>(), Camera.main);
//        */
//    }

//    // 计算二项式系数
//    private float BinomialCoefficient(int n, int k)
//    {
//        float result = 1f;
//        for (int i = 1; i <= k; i++)
//        {
//            result *= (float)(n - k + i) / i;
//        }
//        return result;
//    }


//}
#endregion