Fork: 0
root / DungeonShooting
Transfer to URL with SHA Find file
Newer
Older
DungeonShooting / DungeonShooting_Godot / src / framework / map / DungeonTileMap.cs
@小李xl 小李xl on 17 Jan 2024 62 KB TileMap编辑器添加未选中层变暗功能
Raw Blame History 
  1.  
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using Godot;
  6.  
  7. /// <summary>
  8. /// 地牢地砖管理类, 提供一些操作 TileMap 和计算导航的接口
  9. /// </summary>
  10. public class DungeonTileMap
  11. {
  12.     //--------------------- 导航 -------------------------
  13.     
  14.     //已经标记过的点
  15.     private readonly HashSet<Vector2I> _usePoints = new HashSet<Vector2I>();
  16.  
  17.     //导航区域数据
  18.     private readonly List<NavigationPolygonData> _polygonDataList = new List<NavigationPolygonData>();
  19.  
  20.     //连接门的导航区域
  21.     private readonly List<DoorNavigationInfo> _connectNavigationItemList = new List<DoorNavigationInfo>();
  22.     
  23.     //----------------------------------------------------
  24.     
  25.     private TileMap _tileRoot;
  26.     //地面地砖在 Atlas 的位置
  27.     private List<Vector2I> _floorAtlasCoords;
  28.     //生成导航的结果
  29.     private GenerateNavigationResult _generateNavigationResult;
  30.  
  31.     private InfiniteGrid<bool> _tempAisleFloorGrid = new InfiniteGrid<bool>();
  32.  
  33.     public DungeonTileMap(TileMap tileRoot)
  34.     {
  35.         _tileRoot = tileRoot;
  36.     }
  37.  
  38.     /// <summary>
  39.     /// 根据 startRoom 和 config 数据自动填充 tileMap 参数中的地图数据, 该函数为协程函数
  40.     /// </summary>
  41.     public IEnumerator AutoFillRoomTile(AutoTileConfig config, RoomInfo startRoomInfo, SeedRandom random)
  42.     {
  43.         _connectNavigationItemList.Clear();
  44.         yield return _AutoFillRoomTile(config, startRoomInfo, random);
  45.     }
  46.     
  47.     private IEnumerator _AutoFillRoomTile(AutoTileConfig config, RoomInfo roomInfo, SeedRandom random)
  48.     {
  49.         foreach (var info in roomInfo.Next)
  50.         {
  51.             yield return _AutoFillRoomTile(config, info, random);
  52.         }
  53.         
  54.         //铺房间
  55.         if (roomInfo.RoomSplit == null) //自动填充的矩形房间, 现已经弃用
  56.         {
  57.             FillRect(MapLayer.AutoFloorLayer, config.Floor, roomInfo.Position + Vector2.One,
  58.                 roomInfo.Size - new Vector2(2, 2));
  59.  
  60.             FillRect(MapLayer.AutoTopLayer, config.Wall_In_LT, roomInfo.Position, Vector2.One);
  61.             FillRect(MapLayer.AutoTopLayer, config.Wall_Left, roomInfo.Position + new Vector2(0, 1),
  62.                 new Vector2(1, roomInfo.Size.Y - 2));
  63.             FillRect(MapLayer.AutoTopLayer, config.Wall_In_LB, roomInfo.Position + new Vector2(0, roomInfo.Size.Y - 1),
  64.                 new Vector2(1, 1));
  65.             FillRect(MapLayer.AutoTopLayer, config.Wall_Bottom, roomInfo.Position + new Vector2(1, roomInfo.Size.Y - 1),
  66.                 new Vector2(roomInfo.Size.X - 2, 1));
  67.             FillRect(MapLayer.AutoTopLayer, config.Wall_In_RB,
  68.                 roomInfo.Position + new Vector2(roomInfo.Size.X - 1, roomInfo.Size.Y - 1),
  69.                 Vector2.One);
  70.             FillRect(MapLayer.AutoTopLayer, config.Wall_Right, roomInfo.Position + new Vector2(roomInfo.Size.X - 1, 1),
  71.                 new Vector2(1, roomInfo.Size.Y - 2));
  72.             FillRect(MapLayer.AutoTopLayer, config.Wall_In_RT, roomInfo.Position + new Vector2(roomInfo.Size.X - 1, 0),
  73.                 Vector2.One);
  74.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Top, roomInfo.Position + Vector2.Right,
  75.                 new Vector2(roomInfo.Size.X - 2, 1));
  76.         }
  77.         else
  78.         {
  79.             var rectPos = roomInfo.RoomSplit.RoomInfo.Position.AsVector2I();
  80.             var tileInfo = roomInfo.RoomSplit.TileInfo;
  81.             
  82.             //---------------------- 生成房间小地图预览 ----------------------
  83.             //先计算范围
  84.             var x = int.MaxValue;
  85.             var y = int.MaxValue;
  86.             var x2 = int.MinValue;
  87.             var y2 = int.MinValue;
  88.             for (var i = 0; i < tileInfo.Floor.Count; i += 4)
  89.             {
  90.                 var posX = tileInfo.Floor[i];
  91.                 var posY = tileInfo.Floor[i + 1];
  92.                 x = Mathf.Min(x, posX);
  93.                 x2 = Mathf.Max(x2, posX);
  94.                 y = Mathf.Min(y, posY);
  95.                 y2 = Mathf.Max(y2, posY);
  96.             }
  97.             //创建image, 这里留两个像素宽高用于描边
  98.             var image = Image.Create(x2 - x + 3, y2 - y + 3, false, Image.Format.Rgba8);
  99.             //image.Fill(Colors.Green);
  100.             //填充像素点
  101.             for (var i = 0; i < tileInfo.Floor.Count; i += 4)
  102.             {
  103.                 var posX = tileInfo.Floor[i] - x + 1;
  104.                 var posY = tileInfo.Floor[i + 1] - y + 1;
  105.                 image.SetPixel(posX, posY, new Color(0, 0, 0, 0.5882353F));
  106.             }
  107.             //创建texture
  108.             var imageTexture = ImageTexture.CreateFromImage(image);
  109.             roomInfo.PreviewTexture = imageTexture;
  110.  
  111.             //---------------------- 填充tile操作 ----------------------
  112.             var terrainInfo = config.TerrainInfo;
  113.  
  114.             //自动地形层
  115.             //底层
  116.             SetAutoLayerDataFromList(MapLayer.AutoFloorLayer, config.SourceId, roomInfo, tileInfo.Floor, rectPos, terrainInfo);
  117.             //中层
  118.             SetAutoLayerDataFromList(MapLayer.AutoMiddleLayer, config.SourceId, roomInfo, tileInfo.Middle, rectPos, terrainInfo);
  119.             //顶层
  120.             SetAutoLayerDataFromList(MapLayer.AutoTopLayer, config.SourceId, roomInfo, tileInfo.Top, rectPos, terrainInfo);
  121.             
  122.             //自定义数据层
  123.             SetCustomLayerDataFromList(MapLayer.CustomFloorLayer1, roomInfo, tileInfo.CustomFloor1, rectPos);
  124.             SetCustomLayerDataFromList(MapLayer.CustomFloorLayer2, roomInfo, tileInfo.CustomFloor2, rectPos);
  125.             SetCustomLayerDataFromList(MapLayer.CustomFloorLayer3, roomInfo, tileInfo.CustomFloor3, rectPos);
  126.             SetCustomLayerDataFromList(MapLayer.CustomMiddleLayer1, roomInfo, tileInfo.CustomMiddle1, rectPos);
  127.             SetCustomLayerDataFromList(MapLayer.CustomMiddleLayer2, roomInfo, tileInfo.CustomMiddle2, rectPos);
  128.             SetCustomLayerDataFromList(MapLayer.CustomTopLayer, roomInfo, tileInfo.CustomTop, rectPos);
  129.             
  130.             //寻找可用传送点
  131.             var maxCount = (roomInfo.Size.X - 2) * (roomInfo.Size.Y - 2);
  132.             var startPosition = roomInfo.Position + roomInfo.Size / 2;
  133.             for (int i = 0; i < maxCount; i++)
  134.             {
  135.                 var pos = SpiralUtil.Screw(i) + startPosition;
  136.                 if (IsWayTile(MapLayer.AutoFloorLayer, pos.X, pos.Y))
  137.                 {
  138.                     roomInfo.Waypoints = pos;
  139.                     break;
  140.                 }
  141.             }
  142.             
  143.             //---------------------- 随机选择预设 ----------------------
  144.             RoomPreinstallInfo preinstallInfo;
  145.             if (EditorPlayManager.IsPlay && roomInfo.RoomType == GameApplication.Instance.DungeonManager.CurrConfig.DesignatedType) //编辑器模式, 指定预设
  146.             {
  147.                 preinstallInfo = EditorTileMapManager.SelectPreinstall;
  148.             }
  149.             else //普通模式
  150.             {
  151.                 if (roomInfo.RoomSplit.Preinstall.Count == 1)
  152.                 {
  153.                     preinstallInfo = roomInfo.RoomSplit.Preinstall[0];
  154.                 }
  155.                 else
  156.                 {
  157.                     var weights = roomInfo.RoomSplit.Preinstall.Select(info => info.Weight).ToArray();
  158.                     var index = random.RandomWeight(weights);
  159.                     preinstallInfo = roomInfo.RoomSplit.Preinstall[index];
  160.                 }
  161.             }
  162.             
  163.             var roomPreinstall = new RoomPreinstall(roomInfo, preinstallInfo);
  164.             roomInfo.RoomPreinstall = roomPreinstall;
  165.             //执行预处理操作
  166.             roomPreinstall.Pretreatment(random);
  167.         }
  168.  
  169.         // yield break;
  170.         //铺过道
  171.         foreach (var doorInfo in roomInfo.Doors)
  172.         {
  173.             //必须是正向门
  174.             if (!doorInfo.IsForward)
  175.             {
  176.                 continue;
  177.             }
  178.             
  179.             //普通的直线连接
  180.             var doorDir1 = doorInfo.Direction;
  181.             var doorDir2 = doorInfo.ConnectDoor.Direction;
  182.             if (!doorInfo.HasCross)
  183.             {
  184.                 var rect = doorInfo.GetAisleRect();
  185.                 switch (doorDir1)
  186.                 {
  187.                     case DoorDirection.E:
  188.                         FullHorizontalAisle(config, rect);
  189.                         FullHorizontalAisleLeft(config, rect, doorInfo);
  190.                         FullHorizontalAisleRight(config, rect, doorInfo.ConnectDoor);
  191.                         break;
  192.                     case DoorDirection.W:
  193.                         FullHorizontalAisle(config, rect);
  194.                         FullHorizontalAisleLeft(config, rect, doorInfo.ConnectDoor);
  195.                         FullHorizontalAisleRight(config, rect, doorInfo);
  196.                         break;
  197.                     
  198.                     case DoorDirection.S:
  199.                         FullVerticalAisle(config, rect);
  200.                         FullVerticalAisleUp(config, rect, doorInfo);
  201.                         FullVerticalAisleDown(config, rect, doorInfo.ConnectDoor);
  202.                         break;
  203.                     case DoorDirection.N:
  204.                         FullVerticalAisle(config, rect);
  205.                         FullVerticalAisleUp(config, rect, doorInfo.ConnectDoor);
  206.                         FullVerticalAisleDown(config, rect, doorInfo);
  207.                         break;
  208.                 }
  209.             }
  210.             else //带交叉点
  211.             {
  212.                 //方向, 0横向, 1纵向
  213.                 var dir1 = (doorDir1 == DoorDirection.S || doorDir1 == DoorDirection.N) ? 1 : 0;
  214.                 var dir2 = (doorDir2 == DoorDirection.S || doorDir2 == DoorDirection.N) ? 1 : 0;
  215.  
  216.                 var aisleRect = doorInfo.GetCrossAisleRect();
  217.                 var rect = aisleRect.Rect1;
  218.                 var rect2 = aisleRect.Rect2;
  219.     
  220.                 //填充交叉点
  221.                 FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, aisleRect.Cross.Position, aisleRect.Cross.Size);
  222.  
  223.                 //墙壁, 0横向, 1纵向
  224.                 if (dir1 == 0)
  225.                 {
  226.                     FullHorizontalAisle(config, rect);
  227.                     FullHorizontalAisleLeft(config, rect, doorDir1 == DoorDirection.E ? doorInfo : null);
  228.                     FullHorizontalAisleRight(config, rect, doorDir1 == DoorDirection.W ? doorInfo : null);
  229.                 }
  230.                 else
  231.                 {
  232.                     FullVerticalAisle(config, rect);
  233.                     FullVerticalAisleUp(config, rect, doorDir1 == DoorDirection.S ? doorInfo : null);
  234.                     FullVerticalAisleDown(config, rect, doorDir1 == DoorDirection.N ? doorInfo : null);
  235.                 }
  236.     
  237.                 //墙壁, 0横向, 1纵向
  238.                 if (dir2 == 0)
  239.                 {
  240.                     FullHorizontalAisle(config, rect2);
  241.                     FullHorizontalAisleLeft(config, rect2, doorDir2 == DoorDirection.E ? doorInfo.ConnectDoor : null);
  242.                     FullHorizontalAisleRight(config, rect2, doorDir2 == DoorDirection.W ? doorInfo.ConnectDoor : null);
  243.                 }
  244.                 else
  245.                 {
  246.                     FullVerticalAisle(config, rect2);
  247.                     FullVerticalAisleUp(config, rect2, doorDir2 == DoorDirection.S ? doorInfo.ConnectDoor : null);
  248.                     FullVerticalAisleDown(config, rect2, doorDir2 == DoorDirection.N ? doorInfo.ConnectDoor : null);
  249.                 }
  250.     
  251.                 if ((doorDir1 == DoorDirection.N && doorDir2 == DoorDirection.E) || //↑→
  252.                     (doorDir2 == DoorDirection.N && doorDir1 == DoorDirection.E))
  253.                 {
  254.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Out_RT, doorInfo.Cross + new Vector2(0, GameConfig.CorridorWidth - 1), Vector2.One);
  255.                     FillRect(MapLayer.AutoTopLayer, config.Wall_In_RT, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, -1), Vector2.One);
  256.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Top, doorInfo.Cross + new Vector2I(0, -1), new Vector2(GameConfig.CorridorWidth - 1, 1));
  257.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Center, doorInfo.Cross, new Vector2(GameConfig.CorridorWidth - 1, 1));
  258.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Right, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, 0), new Vector2(1, GameConfig.CorridorWidth));
  259.                     
  260.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross - new Vector2I(0, 2), new Vector2(GameConfig.CorridorWidth + 1, 1));
  261.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross + new Vector2I(GameConfig.CorridorWidth, -1), new Vector2(1, GameConfig.CorridorWidth + 1));
  262.                 }
  263.                 else if ((doorDir1 == DoorDirection.E && doorDir2 == DoorDirection.S) || //→↓
  264.                          (doorDir2 == DoorDirection.E && doorDir1 == DoorDirection.S))
  265.                 {
  266.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Out_RB, doorInfo.Cross + new Vector2I(0, -1), Vector2.One);
  267.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Right, doorInfo.Cross, Vector2.One);
  268.                     FillRect(MapLayer.AutoTopLayer, config.Wall_In_RB, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, GameConfig.CorridorWidth - 1), Vector2.One);
  269.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Right, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, -1), new Vector2(1, GameConfig.CorridorWidth));
  270.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Bottom, doorInfo.Cross + new Vector2(0, GameConfig.CorridorWidth - 1), new Vector2(GameConfig.CorridorWidth - 1, 1));
  271.                     
  272.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross + new Vector2I(GameConfig.CorridorWidth, -1), new Vector2(1, GameConfig.CorridorWidth + 1));
  273.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross + new Vector2I(0, GameConfig.CorridorWidth), new Vector2(GameConfig.CorridorWidth + 1, 1));
  274.                 }
  275.                 else if ((doorDir1 == DoorDirection.S && doorDir2 == DoorDirection.W) || //↓←
  276.                          (doorDir2 == DoorDirection.S && doorDir1 == DoorDirection.W))
  277.                 {
  278.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Out_LB, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, -1), Vector2.One);
  279.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Left, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, 0), Vector2.One);
  280.                     FillRect(MapLayer.AutoTopLayer, config.Wall_In_LB, doorInfo.Cross + new Vector2(0, GameConfig.CorridorWidth - 1), Vector2.One);
  281.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Left, doorInfo.Cross + new Vector2I(0, -1), new Vector2(1, GameConfig.CorridorWidth));
  282.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Bottom, doorInfo.Cross + new Vector2(1, GameConfig.CorridorWidth - 1), new Vector2(GameConfig.CorridorWidth - 1, 1));
  283.                     
  284.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross + new Vector2I(-1, -1), new Vector2(1, GameConfig.CorridorWidth + 1));
  285.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross + new Vector2I(-1, GameConfig.CorridorWidth), new Vector2(GameConfig.CorridorWidth + 1, 1));
  286.                 }
  287.                 else if ((doorDir1 == DoorDirection.W && doorDir2 == DoorDirection.N) || //←↑
  288.                          (doorDir2 == DoorDirection.W && doorDir1 == DoorDirection.N))
  289.                 {
  290.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Out_LT, doorInfo.Cross + new Vector2(GameConfig.CorridorWidth - 1, GameConfig.CorridorWidth - 1), Vector2.One);
  291.                     FillRect(MapLayer.AutoTopLayer, config.Wall_In_LT, doorInfo.Cross + new Vector2I(0, -1), Vector2.One);
  292.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Top, doorInfo.Cross + new Vector2(1, -1), new Vector2(GameConfig.CorridorWidth - 1, 1));
  293.                     FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Center, doorInfo.Cross + new Vector2(1, 0), new Vector2(GameConfig.CorridorWidth - 1, 1));
  294.                     FillRect(MapLayer.AutoTopLayer, config.Wall_Left, doorInfo.Cross + new Vector2(0, 0), new Vector2(1, GameConfig.CorridorWidth));
  295.                     
  296.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross - new Vector2I(1, 2), new Vector2(GameConfig.CorridorWidth + 1, 1));
  297.                     FillRect(MapLayer.AutoTopLayer, config.TopMask, doorInfo.Cross - new Vector2I(1, 1), new Vector2(1, GameConfig.CorridorWidth + 1));
  298.                 }
  299.             }
  300.             
  301.             //先计算范围
  302.             var x = int.MaxValue;
  303.             var y = int.MaxValue;
  304.             var x2 = int.MinValue;
  305.             var y2 = int.MinValue;
  306.             _tempAisleFloorGrid.ForEach((gx, gy, data) =>
  307.             {
  308.                 x = Mathf.Min(x, gx);
  309.                 x2 = Mathf.Max(x2, gx);
  310.                 y = Mathf.Min(y, gy);
  311.                 y2 = Mathf.Max(y2, gy);
  312.                 return true;
  313.             });
  314.             //创建image, 这里留两个像素宽高用于描边
  315.             var image = Image.Create(x2 - x + 3, y2 - y + 3, false, Image.Format.Rgba8);
  316.             //image.Fill(new Color(0, 1, 0, 0.2f));
  317.             //填充像素点
  318.             _tempAisleFloorGrid.ForEach((gx, gy, data) =>
  319.             {
  320.                 var posX = gx - x + 1;
  321.                 var posY = gy - y + 1;
  322.                 //image.SetPixel(posX, posY, new Color(1, 0, 0, 0.5882353F));
  323.                 image.SetPixel(posX, posY, new Color(0, 0, 0, 0.5882353F));
  324.                 return true;
  325.             });
  326.             //创建texture
  327.             var imageTexture = ImageTexture.CreateFromImage(image);
  328.             doorInfo.AislePreviewTexture = imageTexture;
  329.             doorInfo.ConnectDoor.AislePreviewTexture = imageTexture;
  330.             
  331.             _tempAisleFloorGrid.Clear();
  332.         }
  333.     }
  334.  
  335.     //设置自动地形层的数据
  336.     private void SetAutoLayerDataFromList(int layer, int sourceId, RoomInfo roomInfo, List<int> data, Vector2I rectPos, TileSetTerrainInfo terrainInfo)
  337.     {
  338.         for (var i = 0; i < data.Count; i += 4)
  339.         {
  340.             var posX = data[i];
  341.             var posY = data[i + 1];
  342.             var pos = new Vector2I(roomInfo.Position.X + posX - rectPos.X, roomInfo.Position.Y + posY - rectPos.Y);
  343.             var bit = (uint)data[i + 2];
  344.             var type = (byte)data[i + 3];
  345.             var index = terrainInfo.TerrainBitToIndex(bit, type);
  346.             var terrainCell = terrainInfo.GetTerrainCell(index, type);
  347.             var atlasCoords = terrainInfo.GetPosition(terrainCell);
  348.             _tileRoot.SetCell(layer, pos, sourceId, atlasCoords);
  349.         }
  350.     }
  351.     
  352.     //设置自定义层的数据
  353.     private void SetCustomLayerDataFromList(int layer, RoomInfo roomInfo,  List<int> data, Vector2I rectPos)
  354.     {
  355.         for (var i = 0; i < data.Count; i += 5)
  356.         {
  357.             var posX = data[i];
  358.             var posY = data[i + 1];
  359.             var sourceId = data[i + 2];
  360.             var atlasCoordsX = data[i + 3];
  361.             var atlasCoordsY = data[i + 4];
  362.             var pos = new Vector2I(roomInfo.Position.X + posX - rectPos.X, roomInfo.Position.Y + posY - rectPos.Y);
  363.             _tileRoot.SetCell(layer, pos, sourceId, new Vector2I(atlasCoordsX, atlasCoordsY));
  364.         }
  365.     }
  366.  
  367.     /// <summary>
  368.     /// 给TileMap添加轮廓, 该函数为协程函数
  369.     /// </summary>
  370.     /// <param name="tileCellData">描轮廓的Tile</param>
  371.     public IEnumerator AddOutlineTile(TileCellData tileCellData)
  372.     {
  373.         var c = 0;
  374.         var rect = _tileRoot.GetUsedRect();
  375.         var endX = rect.End.X + 1;
  376.         var endY = rect.End.Y + 1;
  377.         for (int x = rect.Position.X - 1; x <= endX; x++)
  378.         {
  379.             for (int y = rect.Position.Y - 1; y <= endY; y++)
  380.             {
  381.                 if (c++ > 1000) //份帧处理, 不要挤在一帧
  382.                 {
  383.                     c = 0;
  384.                     yield return 0;
  385.                 }
  386.                 var pos = new Vector2I(x, y);
  387.                 var flag1 = _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, pos) != -1 ||
  388.                             _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, pos) != -1 ||
  389.                             _tileRoot.GetCellSourceId(MapLayer.AutoAisleFloorLayer, pos) != -1 ||
  390.                             (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, pos) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, pos) != tileCellData.AutoTileCoords);
  391.                 if (!flag1) //空地
  392.                 {
  393.                     var posDown = new Vector2I(pos.X, pos.Y + 1);
  394.                     var posTop = new Vector2I(pos.X, pos.Y - 1);
  395.                     var posLeft = new Vector2I(pos.X - 1, pos.Y);
  396.                     var posRight = new Vector2I(pos.X + 1, pos.Y);
  397.                     
  398.                     var posLD = new Vector2I(pos.X - 1, pos.Y + 1);
  399.                     var posLT = new Vector2I(pos.X - 1, pos.Y - 1);
  400.                     var posRD = new Vector2I(pos.X + 1, pos.Y + 1);
  401.                     var posRT = new Vector2I(pos.X + 1, pos.Y - 1);
  402.                     
  403.                     var flag2 = _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posDown) != -1 ||
  404.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posDown) != -1 ||
  405.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posDown) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posDown) != tileCellData.AutoTileCoords) ||
  406.  
  407.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posTop) != -1 ||
  408.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posTop) != -1 ||
  409.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posTop) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posTop) != tileCellData.AutoTileCoords) ||
  410.  
  411.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posLeft) != -1 ||
  412.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posLeft) != -1 ||
  413.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posLeft) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posLeft) != tileCellData.AutoTileCoords) ||
  414.  
  415.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posRight) != -1 ||
  416.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posRight) != -1 ||
  417.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posRight) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posRight) != tileCellData.AutoTileCoords) ||
  418.                                 //
  419.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posLD) != -1 ||
  420.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posLD) != -1 ||
  421.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posLD) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posLD) != tileCellData.AutoTileCoords) ||
  422.  
  423.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posLT) != -1 ||
  424.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posLT) != -1 ||
  425.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posLT) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posLT) != tileCellData.AutoTileCoords) ||
  426.  
  427.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posRD) != -1 ||
  428.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posRD) != -1 ||
  429.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posRD) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posRD) != tileCellData.AutoTileCoords) ||
  430.  
  431.                                 _tileRoot.GetCellSourceId(MapLayer.AutoFloorLayer, posRT) != -1 ||
  432.                                 _tileRoot.GetCellSourceId(MapLayer.AutoMiddleLayer, posRT) != -1 ||
  433.                                 (_tileRoot.GetCellSourceId(MapLayer.AutoTopLayer, posRT) != -1 && _tileRoot.GetCellAtlasCoords(MapLayer.AutoTopLayer, posRT) != tileCellData.AutoTileCoords);
  434.                     
  435.                     if (flag2) //非空地, 那么说明这个点需要填充 WALL_BLOCK
  436.                     {
  437.                         _tileRoot.SetCell(MapLayer.AutoTopLayer, pos, tileCellData.SourceId, tileCellData.AutoTileCoords);
  438.                     }
  439.                 }
  440.             }
  441.         }
  442.     }
  443.     
  444.     //填充tile区域
  445.     private void FillRect(int layer, TileCellData data, Vector2 pos, Vector2 size)
  446.     {
  447.         for (int i = 0; i < size.X; i++)
  448.         {
  449.             for (int j = 0; j < size.Y; j++)
  450.             {
  451.                 var p = new Vector2I((int)pos.X + i, (int)pos.Y + j);
  452.                 if (layer == MapLayer.AutoAisleFloorLayer)
  453.                 {
  454.                     _tempAisleFloorGrid.Set(p, true);
  455.                 }
  456.                 _tileRoot.SetCell(layer, p, data.SourceId, data.AutoTileCoords);
  457.             }
  458.         }
  459.     }
  460.  
  461.     //清除tile区域
  462.     private void ClearRect(int layer, Vector2 pos, Vector2 size)
  463.     {
  464.         for (int i = 0; i < size.X; i++)
  465.         {
  466.             for (int j = 0; j < size.Y; j++)
  467.             {
  468.                 var p = new Vector2I((int)pos.X + i, (int)pos.Y + j);
  469.                 if (layer == MapLayer.AutoAisleFloorLayer)
  470.                 {
  471.                     _tempAisleFloorGrid.Remove(p.X, p.Y);
  472.                 }
  473.                 _tileRoot.SetCell(layer, p, 0);
  474.             }
  475.         }
  476.     }
  477.  
  478.     //横向过道
  479.     private void FullHorizontalAisle(AutoTileConfig config, Rect2 rect)
  480.     {
  481.         FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, rect.Position + new Vector2(0, 1), rect.Size - new Vector2(0, 2));
  482.         FillRect(MapLayer.AutoTopLayer, config.TopMask, rect.Position - new Vector2(0, 2), new Vector2(rect.Size.X, 1));
  483.         FillRect(MapLayer.AutoTopLayer, config.TopMask, rect.Position + new Vector2(0, rect.Size.Y), new Vector2(rect.Size.X, 1));
  484.         FillRect(MapLayer.AutoMiddleLayer, config.Wall_Top, rect.Position - new Vector2(0, 1), new Vector2(rect.Size.X, 1));
  485.         FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Center, rect.Position, new Vector2(rect.Size.X, 1));
  486.         FillRect(MapLayer.AutoTopLayer, config.Wall_Bottom, rect.Position + new Vector2(0, rect.Size.Y - 1), new Vector2(rect.Size.X, 1));
  487.     }
  488.  
  489.     //纵向过道
  490.     private void FullVerticalAisle(AutoTileConfig config, Rect2 rect)
  491.     {
  492.         FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, rect.Position + new Vector2(1, 0), rect.Size - new Vector2(2, 0));
  493.         FillRect(MapLayer.AutoTopLayer, config.TopMask, rect.Position - new Vector2(1, 0), new Vector2(1, rect.Size.Y - 1));
  494.         FillRect(MapLayer.AutoTopLayer, config.TopMask, rect.Position + new Vector2(rect.Size.X, 0), new Vector2(1, rect.Size.Y - 1));
  495.         FillRect(MapLayer.AutoTopLayer, config.Wall_Left, rect.Position, new Vector2(1, rect.Size.Y - 1));
  496.         FillRect(MapLayer.AutoTopLayer, config.Wall_Right, rect.Position + new Vector2(rect.Size.X - 1, 0), new Vector2(1, rect.Size.Y - 1));
  497.     }
  498.  
  499.     //横向过道, 门朝右, 连接方向向左
  500.     private void FullHorizontalAisleLeft(AutoTileConfig config, Rect2 rect, RoomDoorInfo doorInfo = null)
  501.     {
  502.         //左
  503.         ClearRect(MapLayer.AutoTopLayer, rect.Position + new Vector2(-1, 1), new Vector2(1, rect.Size.Y - 2));
  504.         if (doorInfo == null)
  505.         {
  506.             FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, rect.Position + new Vector2(-1, 1),
  507.                 new Vector2(1, rect.Size.Y - 2));
  508.         }
  509.         else
  510.         {
  511.             ClearRect(MapLayer.AutoTopLayer, rect.Position - new Vector2(1, 1), new Vector2(2, 4));
  512.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Left, rect.Position - new Vector2(1, 0), Vector2.One);
  513.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Out_LB, rect.Position - new Vector2(1, 1), Vector2.One);
  514.             FillRect(MapLayer.AutoTopLayer, config.Wall_Out_LT, rect.Position + new Vector2(-1, 3), Vector2.One);
  515.             
  516.             FillRect(MapLayer.AutoFloorLayer, config.Floor, rect.Position + new Vector2(-1, 1), new Vector2(1, rect.Size.Y - 2));
  517.             //生成门的导航区域
  518.             var x = rect.Position.X * GameConfig.TileCellSize;
  519.             var y = rect.Position.Y * GameConfig.TileCellSize;
  520.             
  521.             var op1 = new Vector2(x - GameConfig.TileCellSize * 1.5f, y + GameConfig.TileCellSize * 1.5f);
  522.             var op2 = new Vector2(x + GameConfig.TileCellSize * 0.5f, y + GameConfig.TileCellSize * 1.5f);
  523.             var op3 = new Vector2(x + GameConfig.TileCellSize * 0.5f, y + GameConfig.TileCellSize * 3f);
  524.             var op4 = new Vector2(x - GameConfig.TileCellSize * 1.5f, y + GameConfig.TileCellSize * 3f);
  525.             AddDoorNavigation(
  526.                 doorInfo, op1, op2, op3, op4,
  527.                 op1,
  528.                 new Vector2(op1.X + GameConfig.TileCellSize, op2.Y),
  529.                 new Vector2(op1.X + GameConfig.TileCellSize, op3.Y),
  530.                 op4
  531.             );
  532.         }
  533.     }
  534.     
  535.     //横向过道, 门朝左, 连接方向向右
  536.     private void FullHorizontalAisleRight(AutoTileConfig config, Rect2 rect, RoomDoorInfo doorInfo = null)
  537.     {
  538.         //右
  539.         ClearRect(MapLayer.AutoTopLayer, rect.Position + new Vector2(rect.Size.X, 1), new Vector2(1, rect.Size.Y - 2));
  540.         if (doorInfo == null)
  541.         {
  542.             FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, rect.Position + new Vector2(rect.Size.X, 1), new Vector2(1, rect.Size.Y - 2));
  543.         }
  544.         else
  545.         {
  546.             ClearRect(MapLayer.AutoTopLayer, rect.Position + new Vector2(rect.Size.X - 1,  -1), new Vector2(2, 4));
  547.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Right, rect.Position + new Vector2(rect.Size.X, 0), Vector2.One);
  548.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Out_RB, rect.Position + new Vector2(rect.Size.X, -1), Vector2.One);
  549.             FillRect(MapLayer.AutoTopLayer, config.Wall_Out_RT, rect.Position + new Vector2(rect.Size.X, 3), Vector2.One);
  550.             
  551.             FillRect(MapLayer.AutoFloorLayer, config.Floor, rect.Position + new Vector2(rect.Size.X, 1), new Vector2(1, rect.Size.Y - 2));
  552.             //生成门的导航区域
  553.             var x = rect.Position.X * GameConfig.TileCellSize;
  554.             var y = rect.Position.Y * GameConfig.TileCellSize;
  555.             
  556.             var op1 = new Vector2(x - GameConfig.TileCellSize * 1.5f + (rect.Size.X + 1) * GameConfig.TileCellSize, y + GameConfig.TileCellSize * 1.5f);
  557.             var op2 = new Vector2(x + GameConfig.TileCellSize * 0.5f + (rect.Size.X + 1) * GameConfig.TileCellSize, y + GameConfig.TileCellSize * 1.5f);
  558.             var op3 = new Vector2(x + GameConfig.TileCellSize * 0.5f + (rect.Size.X + 1) * GameConfig.TileCellSize, y + GameConfig.TileCellSize * 3f);
  559.             var op4 = new Vector2(x - GameConfig.TileCellSize * 1.5f + (rect.Size.X + 1) * GameConfig.TileCellSize, y + GameConfig.TileCellSize * 3f);
  560.             AddDoorNavigation(
  561.                 doorInfo, op1, op2, op3, op4,
  562.                 new Vector2(op2.X - GameConfig.TileCellSize, op1.Y),
  563.                 op2,
  564.                 op3,
  565.                 new Vector2(op2.X - GameConfig.TileCellSize, op4.Y)
  566.             );
  567.         }
  568.     }
  569.  
  570.     //纵向过道, 门朝下, 连接方向向上
  571.     private void FullVerticalAisleUp(AutoTileConfig config, Rect2 rect, RoomDoorInfo doorInfo = null)
  572.     {
  573.         //上
  574.         ClearRect(MapLayer.AutoTopLayer, rect.Position + new Vector2(1, -1), new Vector2(rect.Size.X - 2, 1));
  575.         if (doorInfo == null)
  576.         {
  577.             FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, rect.Position + new Vector2(1, -1), new Vector2(rect.Size.X - 2, 1));
  578.         }
  579.         else
  580.         {
  581.             ClearRect(MapLayer.AutoTopLayer, rect.Position + new Vector2(1, 0), new Vector2(2, 2));
  582.  
  583.             FillRect(MapLayer.AutoTopLayer, config.Wall_Out_RT, rect.Position + new Vector2(0, -1), Vector2.One);
  584.             FillRect(MapLayer.AutoTopLayer, config.Wall_Out_LT, rect.Position + new Vector2(3, -1), Vector2.One);
  585.             
  586.             FillRect(MapLayer.AutoFloorLayer, config.Floor, rect.Position + new Vector2(1, -1), new Vector2(rect.Size.X - 2, 1));
  587.             //生成门的导航区域
  588.             var x = rect.Position.X * GameConfig.TileCellSize;
  589.             var y = rect.Position.Y * GameConfig.TileCellSize;
  590.             
  591.             var op1 = new Vector2(x + GameConfig.TileCellSize * 1.5f, y - GameConfig.TileCellSize * 1f);
  592.             var op2 = new Vector2(x + GameConfig.TileCellSize * 2.5f, y - GameConfig.TileCellSize * 1f);
  593.             var op3 = new Vector2(x + GameConfig.TileCellSize * 2.5f, y + GameConfig.TileCellSize * 0.5f);
  594.             var op4 = new Vector2(x + GameConfig.TileCellSize * 1.5f, y + GameConfig.TileCellSize * 0.5f);
  595.             AddDoorNavigation(
  596.                 doorInfo, op1, op2, op3, op4,
  597.                 op1,
  598.                 op2,
  599.                 new Vector2(op3.X, op1.Y + GameConfig.TileCellSize),
  600.                 new Vector2(op4.X, op1.Y + GameConfig.TileCellSize)
  601.             );
  602.         }
  603.     }
  604.     
  605.     //纵向过道, 门朝上, 连接方向向下
  606.     private void FullVerticalAisleDown(AutoTileConfig config, Rect2 rect, RoomDoorInfo doorInfo = null)
  607.     {
  608.         //下
  609.         ClearRect(MapLayer.AutoMiddleLayer, rect.Position + new Vector2(1, rect.Size.Y), new Vector2(rect.Size.X - 2, 1));
  610.         if (doorInfo == null)
  611.         {
  612.             FillRect(MapLayer.AutoAisleFloorLayer, config.Floor, rect.Position + new Vector2(1, rect.Size.Y), new Vector2(rect.Size.X - 2, 1));
  613.         }
  614.         else
  615.         {
  616.             ClearRect(MapLayer.AutoTopLayer, rect.Position + new Vector2(1, rect.Size.Y - 2), new Vector2(2, 2));
  617.             ClearRect(MapLayer.AutoMiddleLayer, rect.Position + new Vector2(0, rect.Size.Y - 1), new Vector2(4, 2));
  618.  
  619.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Out_RB, rect.Position + new Vector2(0, rect.Size.Y - 1), Vector2.One);
  620.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Right, rect.Position + new Vector2(0, rect.Size.Y), Vector2.One);
  621.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Out_LB, rect.Position + new Vector2(rect.Size.X - 1, rect.Size.Y - 1), Vector2.One);
  622.             FillRect(MapLayer.AutoMiddleLayer, config.Wall_Vertical_Left, rect.Position + new Vector2(rect.Size.X - 1, rect.Size.Y), Vector2.One);
  623.             
  624.             FillRect(MapLayer.AutoFloorLayer, config.Floor, rect.Position + new Vector2(1, rect.Size.Y), new Vector2(rect.Size.X - 2, 1));
  625.             //生成门的导航区域
  626.             var x = rect.Position.X * GameConfig.TileCellSize;
  627.             var y = rect.Position.Y * GameConfig.TileCellSize;
  628.             
  629.             var op1 = new Vector2(x + GameConfig.TileCellSize * 1.5f, y - GameConfig.TileCellSize * 1f + (rect.Size.Y + 1) * GameConfig.TileCellSize);
  630.             var op2 = new Vector2(x + GameConfig.TileCellSize * 2.5f, y - GameConfig.TileCellSize * 1f + (rect.Size.Y + 1) * GameConfig.TileCellSize);
  631.             var op3 = new Vector2(x + GameConfig.TileCellSize * 2.5f, y + GameConfig.TileCellSize * 0.5f + (rect.Size.Y + 1) * GameConfig.TileCellSize);
  632.             var op4 = new Vector2(x + GameConfig.TileCellSize * 1.5f, y + GameConfig.TileCellSize * 0.5f + (rect.Size.Y + 1) * GameConfig.TileCellSize);
  633.             AddDoorNavigation(
  634.                 doorInfo, op1, op2, op3, op4,
  635.                 new Vector2(op1.X, op3.Y - GameConfig.TileCellSize),
  636.                 new Vector2(op2.X, op3.Y - GameConfig.TileCellSize),
  637.                 op3,
  638.                 op4
  639.             );
  640.         }
  641.     }
  642.  
  643.     /// <summary>
  644.     /// 添加房间
  645.     /// </summary>
  646.     private void AddDoorNavigation(RoomDoorInfo doorInfo,
  647.         Vector2 op1, Vector2 op2, Vector2 op3, Vector2 op4,
  648.         Vector2 cp1, Vector2 cp2, Vector2 cp3, Vector2 cp4)
  649.     {
  650.         var openPolygonData = new NavigationPolygonData();
  651.         openPolygonData.Type = NavigationPolygonType.Out;
  652.         openPolygonData.SetPoints(new []{ op1, op2, op3, op4 });
  653.  
  654.         var closePolygonData = new NavigationPolygonData();
  655.         closePolygonData.Type = NavigationPolygonType.Out;
  656.         closePolygonData.SetPoints(new []{ cp1, cp2, cp3, cp4 });
  657.  
  658.         _connectNavigationItemList.Add(new DoorNavigationInfo(doorInfo, openPolygonData, closePolygonData));
  659.     }
  660.  
  661.     /// <summary>
  662.     /// 计算并动生成导航区域, layer 为需要计算的层级，如果没有设置 floorAtlasCoords，则该 layer 下不为空的地砖都将视为可行走区域
  663.     /// </summary>
  664.     public void GenerateNavigationPolygon(int layer)
  665.     {
  666.         _usePoints.Clear();
  667.         _polygonDataList.Clear();
  668.  
  669.         try
  670.         {
  671.             var size = new Vector2(GameConfig.TileCellSize, GameConfig.TileCellSize);
  672.  
  673.             var rect = _tileRoot.GetUsedRect();
  674.  
  675.             var x = rect.Position.X;
  676.             var y = rect.Position.Y;
  677.             var w = rect.Size.X;
  678.             var h = rect.Size.Y;
  679.  
  680.             for (int j = y; j < h; j++)
  681.             {
  682.                 for (int i = x; i < w; i++)
  683.                 {
  684.                     if (IsWayTile(layer, i, j))
  685.                     {
  686.                         if (!_usePoints.Contains(new Vector2I(i, j)))
  687.                         {
  688.                             NavigationPolygonData polygonData = null;
  689.  
  690.                             if (!IsWayTile(layer, i, j - 1))
  691.                             {
  692.                                 polygonData = CalcOutline(layer, i, j, size);
  693.                             }
  694.                             else if (!IsWayTile(layer, i, j + 1))
  695.                             {
  696.                                 polygonData = CalcInline(layer, i, j, size);
  697.                             }
  698.  
  699.                             if (polygonData != null)
  700.                             {
  701.                                 _polygonDataList.Add(polygonData);
  702.                             }
  703.                         }
  704.                     }
  705.                 }
  706.             }
  707.  
  708.             _generateNavigationResult = new GenerateNavigationResult(true);
  709.         }
  710.         catch (NavigationPointException e)
  711.         {
  712.             _usePoints.Clear();
  713.             _polygonDataList.Clear();
  714.             Debug.Log(e.Message);
  715.             _generateNavigationResult = new GenerateNavigationResult(false, e);
  716.         }
  717.     }
  718.  
  719.     /// <summary>
  720.     /// 获取生成导航区域操作的结果, 如果没有调用过 GenerateNavigationPolygon() 函数, 则返回 null
  721.     /// </summary>
  722.     /// <returns></returns>
  723.     public GenerateNavigationResult GetGenerateNavigationResult()
  724.     {
  725.         return _generateNavigationResult;
  726.     }
  727.     
  728.     /// <summary>
  729.     /// 将导航区域挂载到 navigationRoot 上
  730.     /// </summary>
  731.     public void MountNavigationPolygon(Node2D navigationRoot)
  732.     {
  733.         //TestData();
  734.         // 在 Godot4.0_rc6 中 如果将所有点都放在 NavigationPolygon 里面, 即使点是对的, 但调用 MakePolygonsFromOutlines 还是可能会报错, 这应该是个bug
  735.         
  736.         //通过 GenerateNavigationPolygon() 计算出来的导航区域
  737.         for (var i = 0; i < _polygonDataList.Count; i++)
  738.         {
  739.             var polygonData = _polygonDataList[i];
  740.             CreateNavigationRegion(navigationRoot, polygonData);
  741.         }
  742.  
  743.         //门占用区域的导航区域
  744.         for (var i = 0; i < _connectNavigationItemList.Count; i++)
  745.         {
  746.             var item = _connectNavigationItemList[i];
  747.             item.CloseNavigationNode = CreateNavigationRegion(navigationRoot, item.CloseNavigationData);
  748.             item.OpenNavigationNode = CreateNavigationRegion(navigationRoot, item.OpenNavigationData);
  749.             item.CloseNavigationNode.Enabled = false;
  750.             item.OpenNavigationNode.Enabled = false;
  751.             item.DoorInfo.Navigation = item;
  752.         }
  753.     }
  754.  
  755.     //创建导航区域
  756.     private NavigationRegion2D CreateNavigationRegion(Node2D navigationRoot, NavigationPolygonData polygonData)
  757.     {
  758.         var polygon = new NavigationPolygon();
  759.         polygon.CellSize = GameConfig.NavigationCellSize;
  760.         polygon.AddOutline(polygonData.GetPoints());
  761.         polygon.MakePolygonsFromOutlines();
  762.         //var param = new NavigationMeshSourceGeometryData2D();
  763.         //NavigationServer2D.BakeFromSourceGeometryData(polygon, param);
  764.         var navigationPolygon = new NavigationRegion2D();
  765.         navigationPolygon.Name = "NavigationRegion" + (navigationRoot.GetChildCount() + 1);
  766.         navigationPolygon.NavigationPolygon = polygon;
  767.         navigationRoot.AddChild(navigationPolygon);
  768.         return navigationPolygon;
  769.     }
  770.  
  771.     /// <summary>
  772.     /// 获取房间内的导航点数据
  773.     /// </summary>
  774.     public NavigationPolygonData[] GetPolygonData()
  775.     {
  776.         return _polygonDataList.ToArray();
  777.     }
  778.  
  779.     /// <summary>
  780.     /// 设置导航网格数据
  781.     /// </summary>
  782.     /// <param name="list"></param>
  783.     public void SetPolygonData(List<NavigationPolygonData> list)
  784.     {
  785.         _polygonDataList.Clear();
  786.         _polygonDataList.AddRange(list);
  787.         _generateNavigationResult = new GenerateNavigationResult(true);
  788.     }
  789.  
  790.     /// <summary>
  791.     /// 清除生成的导航数据
  792.     /// </summary>
  793.     public void ClearPolygonData()
  794.     {
  795.         _polygonDataList.Clear();
  796.         _generateNavigationResult = null;
  797.     }
  798.     
  799.     /// <summary>
  800.     /// 获取连接门导航数据, 必须要调用 AutoFillRoomTile() 函数才有数据
  801.     /// </summary>
  802.     public NavigationPolygonData[] GetConnectDoorPolygonData()
  803.     {
  804.         var array = new NavigationPolygonData[_connectNavigationItemList.Count];
  805.         for (var i = 0; i < _connectNavigationItemList.Count; i++)
  806.         {
  807.             array[i] = _connectNavigationItemList[i].OpenNavigationData;
  808.         }
  809.         return array;
  810.     }
  811.  
  812.     /// <summary>
  813.     /// 设置地面的地砖，将影响导航网格计算
  814.     /// </summary>
  815.     public void SetFloorAtlasCoords(List<Vector2I> floorAtlasCoords)
  816.     {
  817.         _floorAtlasCoords = floorAtlasCoords;
  818.     }
  819.     
  820.     /// <summary>
  821.     /// 返回指定位置的Tile是否为可以行走
  822.     /// </summary>
  823.     private bool IsWayTile(int layer, int x, int y)
  824.     {
  825.         if (_floorAtlasCoords == null || _floorAtlasCoords.Count == 0)
  826.         {
  827.             return _tileRoot.GetCellSourceId(layer, new Vector2I(x, y)) != -1;
  828.         }
  829.  
  830.         var result = _tileRoot.GetCellAtlasCoords(layer, new Vector2I(x, y));
  831.         return _floorAtlasCoords.Contains(result);
  832.     }
  833.  
  834.     //计算导航网格外轮廓
  835.     private NavigationPolygonData CalcOutline(int layer, int i, int j, Vector2 size)
  836.     {
  837.         var polygonData = new NavigationPolygonData();
  838.         polygonData.Type = NavigationPolygonType.Out;
  839.         var points = new List<Vector2>();
  840.         // 0:右, 1:下, 2:左, 3:上
  841.         var dir = 0;
  842.         var offset = new Vector2(size.X * 0.5f, size.Y * 0.5f);
  843.         //找到路, 向右开始找边界
  844.         var startPos = new Vector2I(i, j);
  845.  
  846.         var tempI = i;
  847.         var tempJ = j;
  848.  
  849.         while (true)
  850.         {
  851.             switch (dir)
  852.             {
  853.                 case 0: //右
  854.                 {
  855.                     if (IsWayTile(layer, tempI, tempJ - 1)) //先向上找
  856.                     {
  857.                         dir = 3;
  858.  
  859.                         var pos = new Vector2I(tempI, tempJ);
  860.                         if (points.Count > 1 && pos == startPos)
  861.                         {
  862.                             polygonData.SetPoints(points.ToArray());
  863.                             return polygonData;
  864.                         }
  865.  
  866.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  867.                         PutUsePoint(pos);
  868.  
  869.                         tempJ--;
  870.                         break;
  871.                     }
  872.                     else if (IsWayTile(layer, tempI + 1, tempJ)) //再向右找
  873.                     {
  874.                         if (points.Count == 0)
  875.                         {
  876.                             points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  877.                         }
  878.  
  879.                         var pos = new Vector2I(tempI, tempJ);
  880.                         if (points.Count > 1 && pos == startPos)
  881.                         {
  882.                             polygonData.SetPoints(points.ToArray());
  883.                             return polygonData;
  884.                         }
  885.  
  886.                         PutUsePoint(new Vector2I(tempI, tempJ));
  887.                         tempI++;
  888.                         break;
  889.                     }
  890.                     else if (IsWayTile(layer, tempI, tempJ + 1)) //向下找
  891.                     {
  892.                         dir = 1;
  893.  
  894.                         var pos = new Vector2I(tempI, tempJ);
  895.                         if (points.Count > 1 && pos == startPos)
  896.                         {
  897.                             polygonData.SetPoints(points.ToArray());
  898.                             return polygonData;
  899.                         }
  900.  
  901.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  902.                         PutUsePoint(pos);
  903.  
  904.                         tempJ++;
  905.                         break;
  906.                     }
  907.  
  908.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  909.                 }
  910.                 case 1: //下
  911.                 {
  912.                     if (IsWayTile(layer, tempI + 1, tempJ)) //先向右找
  913.                     {
  914.                         dir = 0;
  915.  
  916.                         var pos = new Vector2I(tempI, tempJ);
  917.                         if (points.Count > 1 && pos == startPos)
  918.                         {
  919.                             polygonData.SetPoints(points.ToArray());
  920.                             return polygonData;
  921.                         }
  922.  
  923.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  924.                         PutUsePoint(pos);
  925.  
  926.                         tempI++;
  927.                         break;
  928.                     }
  929.                     else if (IsWayTile(layer, tempI, tempJ + 1)) //再向下找
  930.                     {
  931.                         if (points.Count == 0)
  932.                         {
  933.                             points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  934.                         }
  935.  
  936.                         var pos = new Vector2I(tempI, tempJ);
  937.                         if (points.Count > 1 && pos == startPos)
  938.                         {
  939.                             polygonData.SetPoints(points.ToArray());
  940.                             return polygonData;
  941.                         }
  942.  
  943.                         PutUsePoint(new Vector2I(tempI, tempJ));
  944.                         tempJ++;
  945.                         break;
  946.                     }
  947.                     else if (IsWayTile(layer, tempI - 1, tempJ)) //向左找
  948.                     {
  949.                         dir = 2;
  950.  
  951.                         var pos = new Vector2I(tempI, tempJ);
  952.                         if (points.Count > 1 && pos == startPos)
  953.                         {
  954.                             polygonData.SetPoints(points.ToArray());
  955.                             return polygonData;
  956.                         }
  957.  
  958.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  959.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  960.                         PutUsePoint(pos);
  961.  
  962.                         tempI--;
  963.                         break;
  964.                     }
  965.  
  966.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  967.                 }
  968.                 case 2: //左
  969.                 {
  970.                     if (IsWayTile(layer, tempI, tempJ + 1)) //先向下找
  971.                     {
  972.                         dir = 1;
  973.  
  974.                         var pos = new Vector2I(tempI, tempJ);
  975.                         if (points.Count > 1 && pos == startPos)
  976.                         {
  977.                             polygonData.SetPoints(points.ToArray());
  978.                             return polygonData;
  979.                         }
  980.  
  981.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  982.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  983.                         PutUsePoint(pos);
  984.  
  985.                         tempJ++;
  986.                         break;
  987.                     }
  988.                     else if (IsWayTile(layer, tempI - 1, tempJ)) //再向左找
  989.                     {
  990.                         if (points.Count == 0)
  991.                         {
  992.                             //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  993.                             points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  994.                         }
  995.  
  996.                         var pos = new Vector2I(tempI, tempJ);
  997.                         if (points.Count > 1 && pos == startPos)
  998.                         {
  999.                             polygonData.SetPoints(points.ToArray());
  1000.                             return polygonData;
  1001.                         }
  1002.  
  1003.                         PutUsePoint(new Vector2I(tempI, tempJ));
  1004.                         tempI--;
  1005.                         break;
  1006.                     }
  1007.                     else if (IsWayTile(layer, tempI, tempJ - 1)) //向上找
  1008.                     {
  1009.                         dir = 3;
  1010.  
  1011.                         var pos = new Vector2I(tempI, tempJ);
  1012.                         if (points.Count > 1 && pos == startPos)
  1013.                         {
  1014.                             polygonData.SetPoints(points.ToArray());
  1015.                             return polygonData;
  1016.                         }
  1017.  
  1018.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1019.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1020.                         PutUsePoint(pos);
  1021.  
  1022.                         tempJ--;
  1023.                         break;
  1024.                     }
  1025.  
  1026.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  1027.                 }
  1028.                 case 3: //上
  1029.                 {
  1030.                     if (IsWayTile(layer, tempI - 1, tempJ)) //先向左找
  1031.                     {
  1032.                         dir = 2;
  1033.  
  1034.                         var pos = new Vector2I(tempI, tempJ);
  1035.                         if (points.Count > 1 && pos == startPos)
  1036.                         {
  1037.                             polygonData.SetPoints(points.ToArray());
  1038.                             return polygonData;
  1039.                         }
  1040.  
  1041.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1042.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1043.                         PutUsePoint(pos);
  1044.  
  1045.                         tempI--;
  1046.                         break;
  1047.                     }
  1048.                     else if (IsWayTile(layer, tempI, tempJ - 1)) //再向上找
  1049.                     {
  1050.                         if (points.Count == 0)
  1051.                         {
  1052.                             points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1053.                         }
  1054.  
  1055.                         var pos = new Vector2I(tempI, tempJ);
  1056.                         if (points.Count > 1 && pos == startPos)
  1057.                         {
  1058.                             polygonData.SetPoints(points.ToArray());
  1059.                             return polygonData;
  1060.                         }
  1061.  
  1062.                         PutUsePoint(new Vector2I(tempI, tempJ));
  1063.                         tempJ--;
  1064.                         break;
  1065.                     }
  1066.                     else if (IsWayTile(layer, tempI + 1, tempJ)) //向右找
  1067.                     {
  1068.                         dir = 0;
  1069.  
  1070.                         var pos = new Vector2I(tempI, tempJ);
  1071.                         if (points.Count > 1 && pos == startPos)
  1072.                         {
  1073.                             polygonData.SetPoints(points.ToArray());
  1074.                             return polygonData;
  1075.                         }
  1076.  
  1077.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1078.                         PutUsePoint(pos);
  1079.  
  1080.                         tempI++;
  1081.                         break;
  1082.                     }
  1083.  
  1084.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  1085.                 }
  1086.             }
  1087.         }
  1088.     }
  1089.  
  1090.     //计算导航网格内轮廓
  1091.     private NavigationPolygonData CalcInline(int layer, int i, int j, Vector2 size)
  1092.     {
  1093.         var polygonData = new NavigationPolygonData();
  1094.         polygonData.Type = NavigationPolygonType.In;
  1095.         var points = new List<Vector2>();
  1096.         // 0:右, 1:下, 2:左, 3:上
  1097.         var dir = 0;
  1098.         var offset = new Vector2(size.X * 0.5f, size.Y * 0.5f);
  1099.         //找到路, 向右开始找边界
  1100.         var startPos = new Vector2I(i - 1, j);
  1101.         PutUsePoint(startPos);
  1102.  
  1103.         var tempI = i;
  1104.         var tempJ = j;
  1105.  
  1106.         while (true)
  1107.         {
  1108.             switch (dir)
  1109.             {
  1110.                 case 0: //右
  1111.                 {
  1112.                     if (IsWayTile(layer, tempI, tempJ + 1)) //向下找
  1113.                     {
  1114.                         dir = 1;
  1115.  
  1116.                         var pos = new Vector2I(tempI, tempJ);
  1117.                         if (points.Count > 1 && pos == startPos)
  1118.                         {
  1119.                             polygonData.SetPoints(points.ToArray());
  1120.                             return polygonData;
  1121.                         }
  1122.  
  1123.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1124.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1125.                         PutUsePoint(pos);
  1126.  
  1127.                         tempJ++;
  1128.                         break;
  1129.                     }
  1130.                     else if (IsWayTile(layer, tempI + 1, tempJ)) //再向右找
  1131.                     {
  1132.                         if (points.Count == 0)
  1133.                         {
  1134.                             //points.Add(new Vector2((tempI - 1) * size.X + offset.X, tempJ * size.Y + offset.Y));
  1135.                             points.Add(new Vector2((tempI - 1) * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1136.                         }
  1137.  
  1138.                         var pos = new Vector2I(tempI, tempJ);
  1139.                         if (points.Count > 1 && pos == startPos)
  1140.                         {
  1141.                             polygonData.SetPoints(points.ToArray());
  1142.                             return polygonData;
  1143.                         }
  1144.  
  1145.                         PutUsePoint(new Vector2I(tempI, tempJ));
  1146.                         tempI++;
  1147.                         break;
  1148.                     }
  1149.                     else if (IsWayTile(layer, tempI, tempJ - 1)) //先向上找
  1150.                     {
  1151.                         dir = 3;
  1152.  
  1153.                         var pos = new Vector2I(tempI, tempJ);
  1154.                         if (points.Count > 1 && pos == startPos)
  1155.                         {
  1156.                             polygonData.SetPoints(points.ToArray());
  1157.                             return polygonData;
  1158.                         }
  1159.  
  1160.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1161.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1162.                         PutUsePoint(pos);
  1163.  
  1164.                         tempJ--;
  1165.                         break;
  1166.                     }
  1167.  
  1168.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  1169.                 }
  1170.                 case 1: //下
  1171.                 {
  1172.                     if (IsWayTile(layer, tempI - 1, tempJ)) //向左找
  1173.                     {
  1174.                         dir = 2;
  1175.  
  1176.                         var pos = new Vector2I(tempI, tempJ);
  1177.                         if (points.Count > 1 && pos == startPos)
  1178.                         {
  1179.                             polygonData.SetPoints(points.ToArray());
  1180.                             return polygonData;
  1181.                         }
  1182.  
  1183.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1184.                         PutUsePoint(pos);
  1185.  
  1186.                         tempI--;
  1187.                         break;
  1188.                     }
  1189.                     else if (IsWayTile(layer, tempI, tempJ + 1)) //再向下找
  1190.                     {
  1191.                         if (points.Count == 0)
  1192.                         {
  1193.                             points.Add(new Vector2((tempI - 1) * size.X + offset.X, tempJ * size.Y + offset.Y));
  1194.                         }
  1195.  
  1196.                         var pos = new Vector2I(tempI, tempJ);
  1197.                         if (points.Count > 1 && pos == startPos)
  1198.                         {
  1199.                             polygonData.SetPoints(points.ToArray());
  1200.                             return polygonData;
  1201.                         }
  1202.  
  1203.                         PutUsePoint(new Vector2I(tempI, tempJ));
  1204.                         tempJ++;
  1205.                         break;
  1206.                     }
  1207.                     else if (IsWayTile(layer, tempI + 1, tempJ)) //先向右找
  1208.                     {
  1209.                         dir = 0;
  1210.  
  1211.                         var pos = new Vector2I(tempI, tempJ);
  1212.                         if (points.Count > 1 && pos == startPos)
  1213.                         {
  1214.                             polygonData.SetPoints(points.ToArray());
  1215.                             return polygonData;
  1216.                         }
  1217.  
  1218.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1219.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1220.                         PutUsePoint(pos);
  1221.  
  1222.                         tempI++;
  1223.                         break;
  1224.                     }
  1225.  
  1226.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  1227.                 }
  1228.                 case 2: //左
  1229.                 {
  1230.                     if (IsWayTile(layer, tempI, tempJ - 1)) //向上找
  1231.                     {
  1232.                         dir = 3;
  1233.  
  1234.                         var pos = new Vector2I(tempI, tempJ);
  1235.                         if (points.Count > 1 && pos == startPos)
  1236.                         {
  1237.                             polygonData.SetPoints(points.ToArray());
  1238.                             return polygonData;
  1239.                         }
  1240.  
  1241.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1242.                         PutUsePoint(pos);
  1243.  
  1244.                         tempJ--;
  1245.                         break;
  1246.                     }
  1247.                     else if (IsWayTile(layer, tempI - 1, tempJ)) //再向左找
  1248.                     {
  1249.                         if (points.Count == 0)
  1250.                         {
  1251.                             points.Add(new Vector2((tempI - 1) * size.X + offset.X, tempJ * size.Y + offset.Y));
  1252.                         }
  1253.  
  1254.                         var pos = new Vector2I(tempI, tempJ);
  1255.                         if (points.Count > 1 && pos == startPos)
  1256.                         {
  1257.                             polygonData.SetPoints(points.ToArray());
  1258.                             return polygonData;
  1259.                         }
  1260.  
  1261.                         PutUsePoint(new Vector2I(tempI, tempJ));
  1262.                         tempI--;
  1263.                         break;
  1264.                     }
  1265.                     else if (IsWayTile(layer, tempI, tempJ + 1)) //先向下找
  1266.                     {
  1267.                         dir = 1;
  1268.  
  1269.                         var pos = new Vector2I(tempI, tempJ);
  1270.                         if (points.Count > 1 && pos == startPos)
  1271.                         {
  1272.                             polygonData.SetPoints(points.ToArray());
  1273.                             return polygonData;
  1274.                         }
  1275.  
  1276.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1277.                         PutUsePoint(pos);
  1278.  
  1279.                         tempJ++;
  1280.                         break;
  1281.                     }
  1282.  
  1283.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  1284.                 }
  1285.                 case 3: //上
  1286.                 {
  1287.                     if (IsWayTile(layer, tempI + 1, tempJ)) //向右找
  1288.                     {
  1289.                         dir = 0;
  1290.  
  1291.                         var pos = new Vector2I(tempI, tempJ);
  1292.                         if (points.Count > 1 && pos == startPos)
  1293.                         {
  1294.                             polygonData.SetPoints(points.ToArray());
  1295.                             return polygonData;
  1296.                         }
  1297.  
  1298.                         //points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1299.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y * 2));
  1300.                         PutUsePoint(pos);
  1301.  
  1302.                         tempI++;
  1303.                         break;
  1304.                     }
  1305.                     else if (IsWayTile(layer, tempI, tempJ - 1)) //再向上找
  1306.                     {
  1307.                         if (points.Count == 0)
  1308.                         {
  1309.                             points.Add(new Vector2((tempI - 1) * size.X + offset.X, tempJ * size.Y + offset.Y));
  1310.                         }
  1311.  
  1312.                         var pos = new Vector2I(tempI, tempJ);
  1313.                         if (points.Count > 1 && pos == startPos)
  1314.                         {
  1315.                             polygonData.SetPoints(points.ToArray());
  1316.                             return polygonData;
  1317.                         }
  1318.  
  1319.                         PutUsePoint(new Vector2I(tempI, tempJ));
  1320.                         tempJ--;
  1321.                         break;
  1322.                     }
  1323.                     else if (IsWayTile(layer, tempI - 1, tempJ)) //先向左找
  1324.                     {
  1325.                         dir = 2;
  1326.  
  1327.                         var pos = new Vector2I(tempI, tempJ);
  1328.                         if (points.Count > 1 && pos == startPos)
  1329.                         {
  1330.                             polygonData.SetPoints(points.ToArray());
  1331.                             return polygonData;
  1332.                         }
  1333.  
  1334.                         points.Add(new Vector2(tempI * size.X + offset.X, tempJ * size.Y + offset.Y));
  1335.                         PutUsePoint(pos);
  1336.  
  1337.                         tempI--;
  1338.                         break;
  1339.                     }
  1340.  
  1341.                     throw new NavigationPointException(new Vector2I(tempI, tempJ), "生成导航多边形发生错误! 点: " + new Vector2I(tempI, tempJ) + "发生交错!");
  1342.                 }
  1343.             }
  1344.         }
  1345.     }
  1346.  
  1347.     //记录导航网格中已经使用过的坐标
  1348.     private void PutUsePoint(Vector2I pos)
  1349.     {
  1350.         if (_usePoints.Contains(pos))
  1351.         {
  1352.             throw new NavigationPointException(pos, "生成导航多边形发生错误! 点: " + pos + "发生交错!");
  1353.         }
  1354.  
  1355.         _usePoints.Add(pos);
  1356.     }
  1357. }