ArrowBeatTap-Gp/Assets/Scripts/ModuleUI/ArrowGame/ArrowGameUI.cs

using System.Collections;
using System.Collections.Generic;
using System.IO;
using FairyGUI;
using FGUI.Arrow_game;
using UnityEngine;

namespace ChillConnect
{
    public class ArrowGameUI : BaseUI
    {
        private ArrowGameUICtrl ctrl;
        private com_arrow_game ui;

        // FGUI界面根容器
        private GComponent _viewContainer;

        #region FGUI 模板引用
        private ArrorPoint _dotTemplate;
        private ArrowEnd _arrowTemplate;
        private LineTile _lineUnitTemplate;
        #endregion

        // 关卡总配置数据
        private LevelConfig _levelConfig;

        // 全局固定参数
        private const float _pointSpacing = 60f; // 点位间距 60px
        private const float _moveSpeed = 120f; // 移动速度
        private List<ArrowConfig> allArrowList = new List<ArrowConfig>();

        // 网格基础参数
        private readonly int gridColNum = 10;
        private readonly float pointSpace = 60f;
        private readonly float outOffset = 200f;

        // 网格边界
        private float gridLeft;
        private float gridRight;
        private readonly int gridRowNum = 10;
        private float gridTop;
        private float gridBottom;

        // 网格占用标记：true=该点位被占用，false=空闲
        private bool[,] _gridOccupied;
        // 记录每个箭头占用的所有网格点位(行,列)
        private Dictionary<ArrowConfig, List<(int row, int col)>> _arrowOccupiedCells = new Dictionary<ArrowConfig, List<(int row, int col)>>();

        
        // 爱心数量
        private int _heartCount = 3;
        // 记录已经发生过碰撞的箭头对象（去重：同个箭头多次碰撞只扣一次血）
        private HashSet<ArrowConfig> _collidedArrows = new HashSet<ArrowConfig>();
        // 统计场上还存在的箭头总数（用于判断全部移除=通关）
        private int _remainArrowCount = 0;

        // 结算界面UI引用（根据你FGUI包名/组件名自行修改）
        // private ResultPanel _resultPanel;
        
        public ArrowGameUI(ArrowGameUICtrl ctrl) : base(ctrl)
        {
            uiName = UIConst.ArrowGameUI;
            this.ctrl = ctrl;
        }

        protected override void SetUIInfo(UIInfo uiInfo)
        {
            uiInfo.packageName = "Arrow_game";
            uiInfo.assetName = "com_arrow_game";
            uiInfo.layerType = UILayerType.Popup;
            uiInfo.isNeedOpenAnim = false;
            uiInfo.isNeedCloseAnim = false;
            uiInfo.isNeedUIMask = true;
        }

        #region 生命周期
        protected override void OnInit()
        {
        }

        protected override void OnClose()
        {
            // 销毁所有动态FGUI对象
            ClearAllDynamicObj();

            // 释放模板资源
            if (_dotTemplate != null) _dotTemplate.Dispose();
            if (_arrowTemplate != null) _arrowTemplate.Dispose();
            if (_lineUnitTemplate != null) _lineUnitTemplate.Dispose();

            _dotTemplate = null;
            _arrowTemplate = null;
            _lineUnitTemplate = null;
            _levelConfig = null;

            // 清空网格占用数据
            _gridOccupied = null;
            _arrowOccupiedCells.Clear();
        }

        protected override void OnBind()
        {
            ui = baseUI as com_arrow_game;
        }

        public override void OnUpdate()
        {
            if (_levelConfig == null) return;
            foreach (var arrow in _levelConfig.arrows)
            {
                UpdateArrowMove(arrow);
            }
        }

        protected override void OnOpenBefore(object args)
        {
            _viewContainer = ui.view_container;
            // 初始化FGUI模板
            _dotTemplate = (ArrorPoint)UIPackage.CreateObject("Arrow_game", "ArrorPoint");
            _arrowTemplate = (ArrowEnd)UIPackage.CreateObject("Arrow_game", "ArrowEnd");
            _lineUnitTemplate = (LineTile)UIPackage.CreateObject("Arrow_game", "LineTile");
            LoadLevelConfig();
            InitGridBounds();

            // 初始化网格占用数组
            InitGridOccupied();
            
            // ========== 新增：对局状态重置 ==========
            _heartCount = 3;
            _collidedArrows.Clear();
            if(_levelConfig != null)
                _remainArrowCount = _levelConfig.arrows.Count;
            
            InitView();
        }

        protected override void OnOpen(object args)
        {
        }

        protected override void OnHide()
        {
        }

        protected override void OnDisplay(object args)
        {
        }
        #endregion

        #region 页面初始化 & 关闭按钮
        private void InitView()
        {
            // 关闭按钮
            ui.btn_close.SetClick(() => { CtrlCloseUI(); });

            if (_levelConfig == null) return;

            // 1. 绘制网格圆点
            DrawGridDots(_levelConfig);

            allArrowList = _levelConfig.arrows;

            // 2. 初始化所有箭头 + 路径线条 + 标记网格占用
            foreach (var arrow in _levelConfig.arrows)
            {
                BuildArrowPath(arrow, _levelConfig);
                CreateArrowAndLines(arrow, _levelConfig);
                MarkArrowOccupiedCells(arrow, _levelConfig);
            }
        }
        #endregion

        private void InitGridBounds()
        {
            gridLeft = ui.point.x;
            gridRight = ui.point.x + gridColNum * pointSpace;
            gridTop = ui.point.y;
            gridBottom = ui.point.y + gridRowNum * pointSpace;
        }

        /// <summary>初始化网格占用二维数组</summary>
        private void InitGridOccupied()
        {
            int rows = _levelConfig.gridRows;
            int cols = _levelConfig.gridCols;
            _gridOccupied = new bool[rows, cols];
            // 初始全部置为空闲
            for (int r = 0; r < rows; r++)
                for (int c = 0; c < cols; c++)
                    _gridOccupied[r, c] = false;

            _arrowOccupiedCells.Clear();
        }

        /// <summary>标记单个箭头占用的所有网格点</summary>
        private void MarkArrowOccupiedCells(ArrowConfig arrow, LevelConfig cfg)
        {
            List<(int row, int col)> cellList = new List<(int row, int col)>();
            int totalCol = cfg.gridCols;

            // 遍历箭头整条路径的所有网格点位
            foreach (var pos in arrow.pathPointList)
            {
                int pointId = GetPointIdByPos(pos, cfg);
                PointIdToRowCol(pointId, totalCol, out int r, out int c);

                // 边界保护
                if (r >= 0 && r < cfg.gridRows && c >= 0 && c < cfg.gridCols)
                {
                    _gridOccupied[r, c] = true;
                    cellList.Add((r, c));
                }
            }

            _arrowOccupiedCells[arrow] = cellList;
        }

        /// <summary>释放单个箭头占用的网格（箭头消失时调用）</summary>
        private void ReleaseArrowOccupied(ArrowConfig arrow)
        {
            if (!_arrowOccupiedCells.TryGetValue(arrow, out var cellList))
                return;

            foreach (var (r, c) in cellList)
            {
                if (r >= 0 && r < _levelConfig.gridRows && c >= 0 && c < _levelConfig.gridCols)
                {
                    _gridOccupied[r, c] = false;
                }
            }
            // 移除字典记录，避免冗余
            _arrowOccupiedCells.Remove(arrow);
        }

        #region 配置加载
        private void LoadLevelConfig()
        {
            _levelConfig = JsonHelper.LoadLevel("level_1001.json");
            // 给 path 为空的箭头，设置默认方向
            foreach (var arrow in _levelConfig.arrows)
            {
                if (arrow.path == null || arrow.path.Count == 0)
                {
                    arrow.defaultDir = "up";
                }
                else
                {
                    arrow.defaultDir = null;
                }
            }
        }
        #endregion

        #region 【核心】网格坐标工具
        /// <summary>点位ID 转 行列索引</summary>
        private void PointIdToRowCol(int pointId, int totalCol, out int row, out int col)
        {
            row = pointId / totalCol;
            col = pointId % totalCol;
        }

        /// <summary>行列 → 实际像素坐标</summary>
        private Vector2 RowColToPos(int row, int col)
        {
            float originX = ui.point.x;
            float originY = ui.point.y;
            float x = originX + col * _levelConfig.pointSpacing;
            float y = originY + row * _levelConfig.pointSpacing;
            return new Vector2(x, y);
        }

        /// <summary>点位ID → 最终像素坐标</summary>
        private Vector2 PointIdToPos(int pointId, int totalCol)
        {
            PointIdToRowCol(pointId, totalCol, out int r, out int c);
            return RowColToPos(r, c);
        }

        /// <summary>像素坐标反向计算点位ID</summary>
        private int GetPointIdByPos(Vector2 pos, LevelConfig cfg)
        {
            float originX = ui.point.x;
            float originY = ui.point.y;

            int col = Mathf.RoundToInt((pos.x - originX) / cfg.pointSpacing);
            int row = Mathf.RoundToInt((pos.y - originY) / cfg.pointSpacing);

            return row * cfg.gridCols + col;
        }

        /// <summary> 根据FGUI旋转角度获取方向 </summary>
        private string GetDirByRotation(float rot)
        {
            rot = Mathf.Round(rot);
            if (rot == 0) return "right";
            if (rot == 90) return "down";
            if (rot == 180) return "left";
            if (rot == 270) return "up";
            return "right";
        }

        /// <summary>方向转旋转角度（箭头默认朝上）</summary>
        private float DirToRotation(string dir)
        {
            return dir switch
            {
                "up" => 0f,
                "right" => 90f,
                "down" => 180f,
                "left" => 270f,
                _ => 0f
            };
        }
        #endregion

        #region 绘制网格圆点
        private void DrawGridDots(LevelConfig cfg)
        {
            if (_dotTemplate == null || _viewContainer == null) return;
            _dotTemplate.visible = false;

            var rows = cfg.gridRows;
            var cols = cfg.gridCols;

            for (var r = 0; r < rows; r++)
            {
                for (var c = 0; c < cols; c++)
                {
                    var dot = ArrorPoint.CreateInstance();
                    var pos = RowColToPos(r, c);
                    dot.SetPosition(pos.x, pos.y, 0);
                    _viewContainer.AddChild(dot);
                }
            }
        }
        #endregion

        #region 构建箭头路径点位
        private void BuildArrowPath(ArrowConfig arrow, LevelConfig cfg)
        {
            arrow.pathPointList = new List<Vector2>();
            int totalCol = cfg.gridCols;

            int curPointId = arrow.startPoint;
            Vector2 curPos = PointIdToPos(curPointId, totalCol);
            arrow.pathPointList.Add(curPos);

            foreach (string dir in arrow.path)
            {
                PointIdToRowCol(curPointId, totalCol, out int r, out int c);
                switch (dir)
                {
                    case "up": r--; break;
                    case "down": r++; break;
                    case "left": c--; break;
                    case "right": c++; break;
                }

                curPointId = r * totalCol + c;
                curPos = PointIdToPos(curPointId, totalCol);
                arrow.pathPointList.Add(curPos);
            }
        }
        #endregion

        #region 创建箭头 + 线条方块
        private void CreateArrowAndLines(ArrowConfig arrow, LevelConfig cfg)
        {
            arrow.lineUnits = new List<GComponent>();
            arrow.originalLinePos = new List<Vector2>();
            arrow.lineTrackIndex = new List<int>();
            arrow.totalTrack = new List<Vector2>();
            List<Vector2> pathPoints = arrow.pathPointList;

            // 生成整条连续行走轨迹
            if (pathPoints.Count >= 2)
            {
                for (int i = 0; i < pathPoints.Count - 1; i++)
                {
                    Vector2 segStart = pathPoints[i];
                    string dir = arrow.path[i];
                    float offX = 0, offY = 0;
                    switch (dir)
                    {
                        case "right": offX = 10; break;
                        case "left": offX = -10; break;
                        case "down": offY = 10; break;
                        case "up": offY = -10; break;
                    }

                    Vector2 cur = segStart;
                    for (int k = 0; k < 6; k++)
                    {
                        arrow.totalTrack.Add(cur);
                        cur.x += offX;
                        cur.y += offY;
                    }
                }

                if (arrow.path.Count > 0)
                    arrow.finalMoveDir = arrow.path[arrow.path.Count - 1];
            }

            // 路径只有单个点（纯箭头）
            if (pathPoints.Count < 2)
            {
                CreateArrowOnly(arrow, pathPoints[0]);
                // ========= 修复1：单点箭头也初始化轨迹索引 =========
                arrow.arrowTrackIndex = 0;
                arrow.finalMoveDir = GetDirByRotation(arrow.arrowObj.rotation);
                // ========= 修复2：强制记录原始坐标（关键！）=========
                arrow.originalArrowPos = new Vector2(arrow.arrowObj.x, arrow.arrowObj.y);
                return;
            }

            // 生成线条图块
            List<Vector2> tilePositions = new List<Vector2>();
            for (int i = 0; i < pathPoints.Count - 1; i++)
            {
                Vector2 segStart = pathPoints[i];
                string dir = arrow.path[i];
                float offX = 0, offY = 0;
                switch (dir)
                {
                    case "right": offX = 10; break;
                    case "left": offX = -10; break;
                    case "down": offY = 10; break;
                    case "up": offY = -10; break;
                }

                Vector2 cur = segStart;
                for (int k = 0; k < 6; k++)
                {
                    tilePositions.Add(cur);
                    cur.x += offX;
                    cur.y += offY;
                }
            }

            if (tilePositions.Count > 0)
                tilePositions.RemoveAt(tilePositions.Count - 1);

            ColorUtility.TryParseHtmlString(arrow.color, out Color lineColor);
            for (int i = 0; i < tilePositions.Count; i++)
            {
                Vector2 pos = tilePositions[i];
                LineTile unit = LineTile.CreateInstance();
                unit.SetPosition(pos.x, pos.y, 0);
                unit.GetChild("line").asGraph.color = lineColor;
                unit.visible = true;
                unit.touchable = true;
                unit.onClick.Add(() => OnPathClick(arrow));

                _viewContainer.AddChild(unit);
                arrow.lineUnits.Add(unit);
                arrow.originalLinePos.Add(pos);
                arrow.lineTrackIndex.Add(i);
            }

            // 创建箭头
            CreateArrowOnly(arrow, pathPoints[pathPoints.Count - 1]);
            arrow.originalArrowPos = new Vector2(arrow.arrowObj.x, arrow.arrowObj.y);
            arrow.arrowTrackIndex = arrow.totalTrack.Count - 1;
        }

        // 线条/箭头 统一点击回调
        private void OnPathClick(ArrowConfig clickArrow)
        {
            if (clickArrow.isMoving)
                return;

            clickArrow.isMoving = true;
            bool hasBlock = CheckBlockByGrid(clickArrow);
            if (hasBlock)
            {
                MoveThenReset(clickArrow);
            }
            else
            {
                MoveToDisappear(clickArrow);
            }
        }

        // 基于网格行列的阻挡检测
        private bool CheckBlockByGrid(ArrowConfig curArrow)
        {
            if (_gridOccupied == null || _levelConfig == null) return false;

            // 当前箭头网格行列
            Vector2 arrowPos = new Vector2(curArrow.arrowObj.x, curArrow.arrowObj.y);
            int curPointId = GetPointIdByPos(arrowPos, _levelConfig);
            PointIdToRowCol(curPointId, _levelConfig.gridCols, out int curRow, out int curCol);

            // 超出网格直接判定无阻挡
            if (curRow < 0 || curRow >= _levelConfig.gridRows || curCol < 0 || curCol >= _levelConfig.gridCols)
                return false;

            // 获取移动方向
            string moveDir;
            if (curArrow.path != null && curArrow.path.Count > 0)
            {
                moveDir = curArrow.path[curArrow.path.Count - 1];
            }
            else if (!string.IsNullOrEmpty(curArrow.defaultDir))
            {
                moveDir = curArrow.defaultDir;
            }
            else
            {
                moveDir = "up";
            }

            bool isCollide = false;
            // 沿方向遍历前方网格
            switch (moveDir)
            {
                case "up":
                    for (int r = curRow - 1; r >= 0; r--)
                    {
                        if (_gridOccupied[r, curCol])
                        {
                            isCollide = true;
                            break;
                        }
                    }
                    break;
                case "down":
                    for (int r = curRow + 1; r < _levelConfig.gridRows; r++)
                    {
                        if (_gridOccupied[r, curCol])
                        {
                            isCollide = true;
                            break;
                        }
                    }
                    break;
                case "left":
                    for (int c = curCol - 1; c >= 0; c--)
                    {
                        if (_gridOccupied[curRow, c])
                        {
                            isCollide = true;
                            break;
                        }
                    }
                    break;
                case "right":
                    for (int c = curCol + 1; c < _levelConfig.gridCols; c++)
                    {
                        if (_gridOccupied[curRow, c])
                        {
                            isCollide = true;
                            break;
                        }
                    }
                    break;
            }

            // ========== 新增：碰撞判重 + 扣爱心 ==========
            if (isCollide)
            {
                // 这条线第一次碰撞，才扣血
                if (!_collidedArrows.Contains(curArrow))
                {
                    _collidedArrows.Add(curArrow);
                    _heartCount--;
                    
                    if (_heartCount > 0) ui.HeartsPanel.GetChild($"xin_{_heartCount+1}").visible = false;
                    
                    // 爱心归零 → 失败结算
                    if (_heartCount <= 0)
                    {
                        ShowResult(false);
                    }
                }
            }

            return isCollide;
        }

        // 创建箭头 + 绑定点击
        private void CreateArrowOnly(ArrowConfig arrow, Vector2 arrowPos)
        {
            ArrowEnd arrowIns = ArrowEnd.CreateInstance();
            arrowIns.SetPosition(arrowPos.x, arrowPos.y, 0);
            arrowIns.touchable = true;

            if (arrow.path != null && arrow.path.Count > 0)
            {
                string lastDir = arrow.path[arrow.path.Count - 1];
                arrowIns.rotation = DirToRotation(lastDir);
            }
            else if (!string.IsNullOrEmpty(arrow.defaultDir))
            {
                // 纯单点箭头 使用默认方向旋转
                arrowIns.rotation = DirToRotation(arrow.defaultDir);
            }

            ColorUtility.TryParseHtmlString(arrow.color, out Color arrowColor);
            GImage icon = arrowIns.GetChild("icon").asImage;
            if (icon != null) icon.color = arrowColor;

            arrowIns.visible = true;
            arrowIns.onClick.Add(() => OnPathClick(arrow));
            _viewContainer.AddChild(arrowIns);

            arrow.arrowObj = arrowIns;
            arrow.isMoving = false;
        }

        // 移动后复位动画（回弹，不释放占用）
        private void MoveThenReset(ArrowConfig arrow)
        {
            CrazyAsyKit.StartCoroutine(MoveAndResetCoroutine(arrow));
        }

        private IEnumerator MoveAndResetCoroutine(ArrowConfig arrow)
        {
            float frameDelay = 0.01f;
            int stepCount = 2;
            int moved = 0;
            int trackMaxIndex = arrow.totalTrack.Count - 1;

            string dir;
            if (arrow.path != null && arrow.path.Count > 0)
            {
                dir = arrow.path[arrow.path.Count - 1];
            }
            else if (!string.IsNullOrEmpty(arrow.defaultDir))
            {
                dir = arrow.defaultDir;
            }
            else
            {
                dir = "up";
            }
            arrow.finalMoveDir = dir;

            while (moved < stepCount)
            {
                for (int i = 0; i < arrow.lineUnits.Count; i++)
                {
                    int curIdx = arrow.lineTrackIndex[i];
                    if (curIdx < trackMaxIndex)
                    {
                        curIdx++;
                        arrow.lineUnits[i].SetPosition(arrow.totalTrack[curIdx].x, arrow.totalTrack[curIdx].y, 0);
                        arrow.lineTrackIndex[i] = curIdx;
                    }
                    else
                    {
                        float dx = 0, dy = 0;
                        switch (arrow.finalMoveDir)
                        {
                            case "right": dx = 10; break;
                            case "left": dx = -10; break;
                            case "down": dy = 10; break;
                            case "up": dy = -10; break;
                        }
                        arrow.lineUnits[i].x += dx;
                        arrow.lineUnits[i].y += dy;
                    }
                }

                int arrowIdx = arrow.arrowTrackIndex;
                if (arrowIdx < trackMaxIndex)
                {
                    arrowIdx++;
                    arrow.arrowObj.SetPosition(arrow.totalTrack[arrowIdx].x, arrow.totalTrack[arrowIdx].y, 0);
                    arrow.arrowTrackIndex = arrowIdx;
                }
                else
                {
                    float dx = 0, dy = 0;
                    switch (arrow.finalMoveDir)
                    {
                        case "right": dx = 10; break;
                        case "left": dx = -10; break;
                        case "down": dy = 10; break;
                        case "up": dy = -10; break;
                    }
                    arrow.arrowObj.x += dx;
                    arrow.arrowObj.y += dy;
                }

                moved++;
                yield return new WaitForSeconds(frameDelay);
            }

            // 复位位置
            for (int i = 0; i < arrow.lineUnits.Count; i++)
            {
                arrow.lineUnits[i].SetPosition(arrow.originalLinePos[i].x, arrow.originalLinePos[i].y, 0);
                arrow.lineTrackIndex[i] = i;
            }
            // 单点/多点箭头统一读取原始坐标复位
            arrow.arrowObj.SetPosition(arrow.originalArrowPos.x, arrow.originalArrowPos.y, 0);
            arrow.arrowTrackIndex = arrow.totalTrack.Count - 1;

            arrow.isMoving = false;
        }

        private void MoveToDisappear(ArrowConfig arrow)
        {
            CrazyAsyKit.StartCoroutine(MoveAndDisappearCoroutine(arrow));
        }

        private IEnumerator MoveAndDisappearCoroutine(ArrowConfig arrow)
        {
            float frameDelay = 0.01f;
            int trackMaxIndex = arrow.totalTrack.Count - 1;

            string dir;
            if (arrow.path != null && arrow.path.Count > 0)
            {
                dir = arrow.path[arrow.path.Count - 1];
            }
            else if (!string.IsNullOrEmpty(arrow.defaultDir))
            {
                dir = arrow.defaultDir;
            }
            else
            {
                dir = "up";
            }
            arrow.finalMoveDir = dir;

            while (true)
            {
                // 线条移动
                for (int i = 0; i < arrow.lineUnits.Count; i++)
                {
                    int curIdx = arrow.lineTrackIndex[i];
                    if (curIdx < trackMaxIndex)
                    {
                        curIdx++;
                        arrow.lineUnits[i].SetPosition(arrow.totalTrack[curIdx].x, arrow.totalTrack[curIdx].y, 0);
                        arrow.lineTrackIndex[i] = curIdx;
                    }
                    else
                    {
                        float dx = 0, dy = 0;
                        switch (arrow.finalMoveDir)
                        {
                            case "right": dx = 10; break;
                            case "left": dx = -10; break;
                            case "down": dy = 10; break;
                            case "up": dy = -10; break;
                        }
                        arrow.lineUnits[i].x += dx;
                        arrow.lineUnits[i].y += dy;
                    }
                }

                // 箭头移动
                int arrowIdx = arrow.arrowTrackIndex;
                if (arrowIdx < trackMaxIndex)
                {
                    arrowIdx++;
                    arrow.arrowObj.SetPosition(arrow.totalTrack[arrowIdx].x, arrow.totalTrack[arrowIdx].y, 0);
                    arrow.arrowTrackIndex = arrowIdx;
                }
                else
                {
                    float dx = 0, dy = 0;
                    switch (arrow.finalMoveDir)
                    {
                        case "right": dx = 10; break;
                        case "left": dx = -10; break;
                        case "down": dy = 10; break;
                        case "up": dy = -10; break;
                    }
                    arrow.arrowObj.x += dx;
                    arrow.arrowObj.y += dy;
                }

                // 边界判断
                float curX = arrow.arrowObj.x;
                float curY = arrow.arrowObj.y;
                bool isOut = false;
                switch (arrow.finalMoveDir)
                {
                    case "right":
                        if (curX > gridRight + outOffset) isOut = true;
                        break;
                    case "left":
                        if (curX < gridLeft - outOffset) isOut = true;
                        break;
                    case "down":
                        if (curY > gridBottom + outOffset) isOut = true;
                        break;
                    case "up":
                        if (curY < gridTop - outOffset) isOut = true;
                        break;
                }

                if (isOut)
                {
                    // 箭头移出屏幕，释放网格占用
                    ReleaseArrowOccupied(arrow);

                    // 隐藏视图
                    foreach (var line in arrow.lineUnits)
                        line.visible = false;
                    arrow.arrowObj.visible = false;
                    arrow.isMoving = false;
                    
                    // ========== 新增：存活箭头-1，判断全部移除 ==========
                    _remainArrowCount--;
                    if (_remainArrowCount <= 0)
                    {
                        ShowResult(true);
                    }

                    yield break;
                }

                yield return new WaitForSeconds(frameDelay);
            }
        }

        private void CreateLineUnitBetweenTwoPoint(Vector2 pStart, Vector2 pEnd, Color lineColor, List<GComponent> lineList)
        {
            if (_lineUnitTemplate == null) return;
            float offsetX = 0f;
            float offsetY = 0f;

            if (Mathf.Abs(pEnd.x - pStart.x) > 1f)
                offsetX = 10f;
            else
                offsetY = 10f;

            Vector2 curPos = pStart;
            for (int i = 0; i < 6; i++)
            {
                LineTile unit = LineTile.CreateInstance();
                unit.SetPosition(curPos.x, curPos.y, 0);
                unit.GetChild("line").asGraph.color = lineColor;
                unit.visible = true;

                _viewContainer.AddChild(unit);
                lineList.Add(unit);

                curPos.x += offsetX;
                curPos.y += offsetY;
            }
        }
        #endregion

        #region 点击 & 移动逻辑
        private void OnArrowClick(ArrowConfig arrow)
        {
            if (arrow.isMoving) return;
            arrow.isMoving = true;
        }

        private void UpdateArrowMove(ArrowConfig arrow)
        {
            if (!arrow.isMoving) return;
            List<Vector2> path = arrow.pathPointList;

            if (arrow.targetIndex < 0)
            {
                arrow.isMoving = false;
                arrow.arrowObj.visible = false;
                foreach (var line in arrow.lineUnits) line.visible = false;
                return;
            }

            Vector2 targetPos = path[arrow.targetIndex];
            Vector2 curPos = new Vector2(arrow.arrowObj.x, arrow.arrowObj.y);
            float distance = Vector2.Distance(curPos, targetPos);

            if (distance < 2f)
            {
                arrow.targetIndex--;
            }
            else
            {
                Vector2 dir = (targetPos - curPos).normalized;
                Vector2 newPos = curPos + dir * _moveSpeed * Time.deltaTime;
                arrow.arrowObj.SetPosition(newPos.x, newPos.y, 0);
            }

            RefreshLineVisible(arrow);
        }

        private void RefreshLineVisible(ArrowConfig arrow)
        {
            int segIndex = 0;
            int totalSeg = arrow.pathPointList.Count - 1;

            for (int s = 0; s < totalSeg; s++)
            {
                bool isShow = s < arrow.targetIndex;
                for (int i = 0; i < 6; i++)
                {
                    arrow.lineUnits[segIndex + i].visible = isShow;
                }
                segIndex += 6;
            }
        }
        #endregion

        #region 资源清理
        private void ClearAllDynamicObj()
        {
            if (_levelConfig == null || _viewContainer == null) return;
            foreach (var arrow in _levelConfig.arrows)
            {
                if (arrow.arrowObj != null)
                {
                    _viewContainer.RemoveChild(arrow.arrowObj);
                    arrow.arrowObj.Dispose();
                    arrow.arrowObj = null;
                }

                foreach (var line in arrow.lineUnits)
                {
                    _viewContainer.RemoveChild(line);
                    line.Dispose();
                }
                arrow.lineUnits.Clear();
            }
        }
        #endregion
        
        /// <summary>
        /// 弹出结算
        /// isSuccess: true=成功，false=失败
        /// </summary>
        private void ShowResult(bool isSuccess)
        {
            // 暂停所有交互/移动（可选）
            foreach (var arrow in _levelConfig.arrows)
            {
                arrow.isMoving = false;
            }
            
            uiCtrlDispatcher.Dispatch(UICtrlMsg.LevelSuccessUI_Open, isSuccess);
        }
        
        // 重新开始本局
        private void OnRestartGame(object a = null)
        {
            if (a!=null && (bool)a)
            {
                _heartCount = 3;
                for (int i = _heartCount; i > 0; i--)
                {
                    ui.HeartsPanel.GetChild($"xin_{i}").visible = true;
                }
                return;
            }
            
            // 先清空当前所有动态物体
            ClearAllDynamicObj();
            // 重新走初始化流程
            InitGridBounds();
            InitGridOccupied();
            _heartCount = 3;
            _collidedArrows.Clear();
            _remainArrowCount = _levelConfig.arrows.Count;
            DataMgr.ArrowResultLevel.Value = 1;
            InitView();
        }


        #region 消息监听
        protected override void AddListener()
        {
            GameDispatcher.Instance.AddListener(GameMsg.reset_game, OnRestartGame);
            
        }

        protected override void RemoveListener()
        {
            GameDispatcher.Instance.RemoveListener(GameMsg.reset_game, OnRestartGame);
        }
        #endregion
    }

    #region 配置解析 & 数据结构
    public static class JsonHelper
    {
        public static LevelConfig LoadLevel(string fileName)
        {
            string path = Path.Combine(Application.streamingAssetsPath, fileName);
            return JsonUtility.FromJson<LevelConfig>(File.ReadAllText(path));
        }
    }

    [System.Serializable]
    public class LevelConfig
    {
        public int levelId;
        public string levelName;
        public int gridRows;
        public int gridCols;
        public int pointSpacing;
        public List<ArrowConfig> arrows;
    }

    [System.Serializable]
    public class ArrowConfig
    {
        public int id;
        public int startPoint;
        public int endPoint;
        public string color;
        public List<string> path;

        public string defaultDir;
        public List<Vector2> pathPointList;
        public List<GComponent> lineUnits;
        public GComponent arrowObj;

        public bool isMoving;
        public List<Vector2> originalLinePos;
        public Vector2 originalArrowPos;
        public int targetIndex;

        public List<Vector2> totalTrack;
        public List<int> lineTrackIndex;
        public int arrowTrackIndex;
        public string finalMoveDir;
    }
    #endregion
}