复盘:Unity RTS (4) 网格系统+路线规划

网络的部分搞定后,主要就是RTS的几大难点.

这里先复盘一下遇到的最大的坑:寻路系统

        方案的选择:

        1.基于路点寻路+A*算法的Unity Navigation

        优点:优化非常好,上手很简单,使用了地图烘焙

        缺点:

        1.多角色之间的碰撞和挤压很难看且难以避免

        如果是人型角色这倒没什么,谁没在CS里被挤过,但是一堆坦克挤来挤去就很酸爽了.这点亲身体会,另外可以参考这个帖子.

unity3d多人寻路问题方案_unity 多人寻路-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/u011926026/article/details/63682788#:~:text=%E7%9B%B8%E4%BF%A1%E5%A4%A7%E5%AE%B6%E7%94%A8unity3d%E8%87%AA%E5%B8%A6navmeshagent%E5%AF%BB%E8%B7%AF%E7%9A%84%E6%97%B6%E5%80%99%EF%BC%8C%E4%B8%80%E5%AE%9A%E4%BC%9A%E7%A2%B0%E5%88%B0%E5%A4%9A%E4%BA%BA%E5%AF%BB%E8%B7%AF%E7%9B%B8%E4%BA%92%E6%8C%A4%E5%8E%8B%E7%9A%84%E9%97%AE%E9%A2%98%E3%80%82,%E8%BF%99%E4%B8%AA%E6%88%91%E5%B7%B2%E7%BB%8F%E8%A7%A3%E5%86%B3%E4%BA%86%EF%BC%8C%E8%80%8C%E4%B8%94%E5%B7%B2%E7%BB%8F%E5%BA%94%E7%94%A8%E5%88%B0%E6%88%91%E4%BB%AC%E7%9A%84%E9%A1%B9%E7%9B%AE%E4%B8%AD%EF%BC%8C%E6%84%9F%E8%A7%89%E8%BF%98%E4%B8%8D%E9%94%99%E3%80%82%20%E9%A6%96%E5%85%88%E6%8F%90%E4%B8%8B%E9%97%AE%E9%A2%98%E7%9A%84%E5%8E%9F%E5%9B%A0%EF%BC%9Anavmeshagent%E5%9C%A8%E5%AF%BB%E8%B7%AF%E7%9A%84%E6%97%B6%E5%80%99%EF%BC%8C%E5%B9%B6%E4%B8%8D%E4%BC%9A%E6%8A%8A%E5%88%AB%E4%BA%BA%E5%BD%93%E6%88%90%E9%9A%9C%E7%A2%8D%E7%89%A9%EF%BC%8C%E8%80%8C%E6%98%AF%E5%9C%A8%E5%8D%B3%E5%B0%86%E5%92%8C%E5%85%B6%E4%BB%96agent%E7%A2%B0%E6%92%9E%E7%9A%84%E6%97%B6%E5%80%99%EF%BC%8C%E9%80%9A%E8%BF%87%E5%87%8F%E9%80%9F%EF%BC%8C%E7%A2%B0%E6%92%9E%E8%BD%AC%E5%BC%AF%EF%BC%8C%E5%AE%9E%E7%8E%B0%E9%81%BF%E5%BC%80%E5%85%B6%E4%BB%96agent.

        总之一点,这个东西对于单人或者对挤压没那么敏感的游戏可以,否则得深入底层改一些东西.

        2.动态添加障碍物比如RTS这种能够随时随地建建筑,会产生一定bug

        3.不适用于帧同步(浮点\碰撞)

        2.现成的A*框架

        性能开销过大,适用于单人或者少量角色.

       *3.流场寻路算法(采用)

        思路参考:

        优点:大量单位公用同一份寻路结果节省了大量时间

        PS.寻路远非线路规划这么简单,因为没有单位能够完全按照规划路线行进,每个单位之间会相互影响,这个影响逻辑怎么写是最麻烦的,这不在本文复盘内容之内.

        

一.建立网格系统

        首先无论是A*还是流场寻路,都必须建立一个网格系统,网格系统听着复杂,其实就是写一些方法,将当前的Unity 转化成抽象的网格上的坐标.

比如我有一个位置Vector3(5,10.6,8),我想知道他在我抽象的网格世界的网格坐标是什么

就有了了Vector3Int currentGrid = Grid.FromWorldToCell(Vector3(5,10.6,8));

我这里的代码是用LStepLock(一个开源定点库)的LVector3,原理一样.

  1. using Lockstep.Math;
  2. using UnityEngine;
  3.  
  4. public class LGrid : MonoBehaviour
  5. {
  6.     [SerializeField] private LFloat cellSize;
  7.     
  8.    /// 
  9.    /// 获得当前真实三维坐标对应的网格坐标
  10.    /// 
  11.    /// 
  12.     public LVector3 LWorldToCell(LVector3 world)
  13.     {
  14.         return new LVector3(
  15.             LFloat.Divide(world.x, cellSize),
  16.             LFloat.Divide(world.y, cellSize),
  17.             LFloat.Divide(world.z, cellSize)
  18.         );
  19.     } 
  20.    /// 
  21.    /// 获得当前网格（左下角）的真实三位坐标中
  22.    /// 
  23.    /// 
  24.     //默认网格初始位置0，0，0
  25.     public LVector3 LCellToWorld(LVector3Int cell)
  26.     {
  27.         return new LVector3(
  28.             (cell.x -1) * cellSize,
  29.             (cell.y) * cellSize,
  30.             (cell.z -1) * cellSize);
  31.     }
  32.    /// 
  33.    /// 获得当前网格（中心点）的真实三位坐标
  34.    /// 
  35.    /// 
  36.     public LVector3 LGetCellCenterWorld(LVector3 cell)
  37.     {
  38.         return new LVector3(
  39.            (cell.x-1)*cellSize+cellSize/2,
  40.            (cell.y)*cellSize,
  41.            (cell.z-1)*cellSize+cellSize/2
  42.         );
  43.     } 
  44.    /// 
  45.    /// 获得当前网格（中心点）的真实三位坐标*1000000L的坐标的值
  46.    /// 
  47.    /// 
  48.    /// 
  49.      public LVector3 LGetCellCenterWorld_s(LVector3 cell)
  50.      {
  51.          return new LVector3(
  52.              ((cell._x-1)*cellSize+cellSize/2),
  53.              (cell._y)*cellSize,
  54.              (cell._z-1)*cellSize+cellSize/2
  55.          );
  56.      }
  57. }

二.初始化导航地图

       这个步骤相当复杂,但是简单来说就是建立一个bool[,]的二维地图,尺寸比如500x500,值为false表示障碍物,true表示可通行.

        对于这次的复盘的任务而言就是传入一张这样的地图,起始点,终点,怎样找到一条从起点到终点的二维地图中的坐标数组

流场算法

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using System.Collections;
  5. using System.Collections.Generic;
  6. using System.Threading;
  7. using Lockstep.Math;
  8. using UnityEngine;
  9.  
  10. /// 
  11. /// 流场算法
  12. /// 
  13. public class FlowFieldPath
  14. {
  15.     private bool[,] grid;
  16.     public int[,] heatMap;
  17.     private int targetX, targetY;
  18.     private int[,] flowField;
  19.     public bool ifGenerateFineshed = false;
  20.  
  21.     /// 
  22.     /// 初始化流场寻路：传入导航地图
  23.     /// 
  24.     /// 
  25.     public FlowFieldPath(bool[,] grid)
  26.     {
  27.         this.grid = grid;
  28.         heatMap = new int[grid.GetLength(0), grid.GetLength(1)];
  29.         for (int i = 0; i < heatMap.GetLength(0); i++)
  30.         {
  31.             for (int j = 0; j < heatMap.GetLength(1); j++)
  32.             {
  33.                 heatMap[i, j] = int.MaxValue;
  34.             }
  35.         }
  36.     }
  37.  
  38.     /// 
  39.     /// 传入终点，根据重点生成导航热力图
  40.     /// 1.创建新的线程
  41.     /// 
  42.     /// 终点
  43.     public void GenerateHeatMap(Vector2Int target)
  44.     {
  45.         new Thread(() => { GenerateHeatMap_T(target); }).Start();
  46.     }
  47.  
  48.     /// 
  49.     /// 传入终点，根据重点生成导航热力图
  50.     /// 2.正式开始生成热力图，生成的热力图
  51.     /// 
  52.     /// 
  53.     /// 
  54.     public int[,] GenerateHeatMap_T(Vector2Int target)
  55.     {
  56.         heatMap = new int[grid.GetLength(0), grid.GetLength(1)];
  57.         for (int i = 0; i < heatMap.GetLength(0); i++)
  58.         {
  59.             for (int j = 0; j < heatMap.GetLength(1); j++)
  60.             {
  61.                 heatMap[i, j] = int.MaxValue;
  62.             }
  63.         }
  64.  
  65.         this.targetX = target.x;
  66.         this.targetY = target.y;
  67.         Queue queue = new Queue();
  68.         queue.Enqueue(new Vector2Int(targetX, targetY));
  69.         heatMap[targetX, targetY] = 0;
  70.  
  71.         while (queue.Count > 0)
  72.         {
  73.             Vector2Int current = queue.Dequeue();
  74.             List neighbors = GetNeighbors(current);
  75.             foreach (Vector2Int neighbor in neighbors)
  76.             {
  77.                 if (grid[neighbor.x, neighbor.y])
  78.                 {
  79.                     int newHeat = heatMap[current.x, current.y] +
  80.                                   ((neighbor.x == current.x || neighbor.y == current.y) ? 1 : 2);
  81.                     if (newHeat < heatMap[neighbor.x, neighbor.y])
  82.                     {
  83.                         heatMap[neighbor.x, neighbor.y] = newHeat;
  84.                         queue.Enqueue(neighbor);
  85.                     }
  86.                 }
  87.             }
  88.         }
  89.  
  90.         ifGenerateFineshed = true;
  91.         return heatMap;
  92.     }
  93.  
  94.     /// 
  95.     /// 获取热力图某点的热力值
  96.     /// 
  97.     /// 
  98.     /// 
  99.     public int GetHeatMapPoint(LVector2Int loc)
  100.     {
  101.         return heatMap[loc.x, loc.y];
  102.     }
  103.  
  104.     /// 
  105.     /// 根据热力图生成流场图
  106.     /// 
  107.     /// 
  108.     /// 
  109.     public int[,] GenerateFlowField(Vector2Int target)
  110.     {
  111.         Debug.Log("确定流场目标:" + target.x + "," + target.y);
  112.         GenerateHeatMap(target);
  113.         flowField = new int[grid.GetLength(0), grid.GetLength(1)];
  114.         for (int i = 0; i < flowField.GetLength(0); i++)
  115.         {
  116.             for (int j = 0; j < flowField.GetLength(1); j++)
  117.             {
  118.                 List neighbors = GetNeighbors(new Vector2Int(i, j));
  119.                 int minHeat = int.MaxValue;
  120.                 foreach (Vector2Int neighbor in neighbors)
  121.                 {
  122.                     if (grid[neighbor.x, neighbor.y] && heatMap[neighbor.x, neighbor.y] < minHeat)
  123.                     {
  124.                         minHeat = heatMap[neighbor.x, neighbor.y];
  125.                         flowField[i, j] = DirectionToIndex(new Vector2Int(i, j), neighbor);
  126.                     }
  127.                 }
  128.             }
  129.         }
  130.  
  131.         return flowField;
  132.     }
  133.  
  134.     public int CheckDirection(LVector2Int loc)
  135.     {
  136.         return flowField[loc.x, loc.y];
  137.     }
  138.  
  139.     private List GetNeighbors(Vector2Int point)
  140.     {
  141.         List neighbors = new List();
  142.         for (int dx = -1; dx <= 1; dx++)
  143.         {
  144.             for (int dy = -1; dy <= 1; dy++)
  145.             {
  146.                 if (dx == 0 && dy == 0) continue; // 跳过自身
  147.                 int nx = point.x + dx;
  148.                 int ny = point.y + dy;
  149.                 if (nx >= 0 && ny >= 0 && nx < grid.GetLength(0) && ny < grid.GetLength(1))
  150.                 {
  151.                     neighbors.Add(new Vector2Int(nx, ny));
  152.                 }
  153.             }
  154.         }
  155.  
  156.         return neighbors;
  157.     }
  158.  
  159.  
  160.     private int DirectionToIndex(Vector2Int current, Vector2Int target)
  161.     {
  162.         Vector2Int direction = target - current;
  163.         if (direction.x == 0 && direction.y == -1) return 0; // 上
  164.         if (direction.x == 1 && direction.y == -1) return 1; // 右上
  165.         if (direction.x == 1 && direction.y == 0) return 2; // 右
  166.         if (direction.x == 1 && direction.y == 1) return 3; // 右下
  167.         if (direction.x == 0 && direction.y == 1) return 4; // 下
  168.         if (direction.x == -1 && direction.y == 1) return 5; // 左下
  169.         if (direction.x == -1 && direction.y == 0) return 6; // 左
  170.         if (direction.x == -1 && direction.y == -1) return 7; // 左上
  171.  
  172.         return -1;
  173.     }
  174.  
  175.     public LVector2Int GetFlowFieldDirection(LVector2Int point)
  176.     {
  177.         int directionIndex = flowField[point.x, point.y];
  178.         LVector2Int direction = IndexToDirection(directionIndex);
  179.         return direction;
  180.     }
  181.  
  182.     private LVector2Int IndexToDirection(int index)
  183.     {
  184.         switch (index)
  185.         {
  186.             case 0: return new LVector2Int(0, 1); // 上
  187.             case 1: return new LVector2Int(1, 1); // 右上
  188.             case 2: return new LVector2Int(1, 0); // 右
  189.             case 3: return new LVector2Int(1, -1); // 右下
  190.             case 4: return new LVector2Int(0, -1); // 下
  191.             case 5: return new LVector2Int(-1, -1); // 左下
  192.             case 6: return new LVector2Int(-1, 0); // 左
  193.             case 7: return new LVector2Int(-1, 1); // 左上
  194.             default: return new LVector2Int(0, 0); // 默认情况，没有方向
  195.         }
  196.     }
  197. }

注：本文转载自blog.csdn.net的asd55571的文章"https://blog.csdn.net/u011457179/article/details/135682657"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！