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