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