Fork: 0
root / DungeonShooting
Transfer to URL with SHA Find file
Newer
Older
DungeonShooting / DungeonShooting_Godot / src / framework / map / serialize / tileSet / TileSetTerrainInfo.cs
@小李xl 小李xl on 12 Jan 2024 17 KB TileSetSplit.GetTileSet()支持2x2地形
Raw Blame History 
  1.  
  2. using System.Collections.Generic;
  3. using System.Text.Json.Serialization;
  4. using Godot;
  5. using static TerrainPeering;
  6.  
  7. /// <summary>
  8. /// 地形配置数据, 数据都为 int 数组, 下标0和1分别代表x和y, 单位: 像素
  9. /// </summary>
  10. public class TileSetTerrainInfo : IClone<TileSetTerrainInfo>
  11. {
  12.     public const byte TerrainLayerType = 1;
  13.     public const byte MiddleLayerType = 2;
  14.     public const byte FloorLayerType = 3;
  15.  
  16.     //type = 3
  17.     /// <summary>
  18.     /// 地板 (1块) type = 3
  19.     /// </summary>
  20.     [JsonInclude] public Dictionary<uint, int[]> F;
  21.  
  22.     /// <summary>
  23.     /// 侧方墙壁 (4块) type = 2
  24.     /// </summary>
  25.     [JsonInclude] public Dictionary<uint, int[]> M;
  26.     
  27.     /// <summary>
  28.     /// 自动平铺地形 (47块/13块) type = 1
  29.     /// </summary>
  30.     [JsonInclude] public Dictionary<uint, int[]> T;
  31.  
  32.     /// <summary>
  33.     /// 地形类型, 0: 3x3地形, 1: 2x2地形
  34.     /// </summary>
  35.     [JsonInclude]
  36.     public byte TerrainType;
  37.  
  38.     public void InitData()
  39.     {
  40.         TerrainType = 0;
  41.         F = new Dictionary<uint, int[]>();
  42.         M = new Dictionary<uint, int[]>();
  43.         T = new Dictionary<uint, int[]>();
  44.     }
  45.  
  46.     public TileSetTerrainInfo Clone()
  47.     {
  48.         var terrainInfo = new TileSetTerrainInfo();
  49.         terrainInfo.InitData();
  50.         foreach (var pair in T)
  51.         {
  52.             terrainInfo.T.Add(pair.Key, new []{ pair.Value[0], pair.Value[1] });
  53.         }
  54.         foreach (var pair in M)
  55.         {
  56.             terrainInfo.M.Add(pair.Key, new []{ pair.Value[0], pair.Value[1] });
  57.         }
  58.         foreach (var pair in F)
  59.         {
  60.             terrainInfo.F.Add(pair.Key, new []{ pair.Value[0], pair.Value[1] });
  61.         }
  62.         terrainInfo.TerrainType = TerrainType;
  63.         return terrainInfo;
  64.     }
  65.  
  66.     /// <summary>
  67.     /// 返回这个TileSet地形是否可以正常使用了
  68.     /// </summary>
  69.     /// <returns></returns>
  70.     public bool CanUse()
  71.     {
  72.         if (TerrainType == 0)
  73.         {
  74.             if (T == null || T.Count != 47)
  75.             {
  76.                 return false;
  77.             }
  78.         }
  79.         else
  80.         {
  81.             if (T == null || T.Count != 13)
  82.             {
  83.                 return false;
  84.             }
  85.         }
  86.  
  87.         return M != null && M.Count == 4 && F != null && F.Count == 1;
  88.     }
  89.  
  90.     /// <summary>
  91.     /// 将存储的坐标数据转换成 Vector2I 对象, 返回的 Vector2I 单位: 格
  92.     /// </summary>
  93.     public Vector2I GetPosition(int[] ints)
  94.     {
  95.         return new Vector2I(ints[0] / GameConfig.TileCellSize, ints[1] / GameConfig.TileCellSize);
  96.     }
  97.     
  98.     /// <summary>
  99.     /// 将地形掩码中的坐标转换为索引。
  100.     /// </summary>
  101.     /// <param name="bitCoords">地形坐标</param>
  102.     /// <param name="type">地形类型</param>
  103.     public int TerrainCoordsToIndex(Vector2I bitCoords, byte type)
  104.     {
  105.         if (type == TerrainLayerType)
  106.         {
  107.             return bitCoords.Y * GameConfig.TerrainBit3x3.X + bitCoords.X;
  108.         }
  109.         else if (type == MiddleLayerType)
  110.         {
  111.             return bitCoords.Y * GameConfig.TerrainBitMiddle.X + bitCoords.X;
  112.         }
  113.         else if (type == FloorLayerType)
  114.         {
  115.             return bitCoords.Y * GameConfig.TerrainBitFloor.X + bitCoords.X;
  116.         }
  117.         return -1;
  118.     }
  119.  
  120.     /// <summary>
  121.     /// 将地掩码值转换为索引值
  122.     /// </summary>
  123.     /// <param name="bit">地形掩码值</param>
  124.     /// <param name="type">地形类型</param>
  125.     public int TerrainBitToIndex(uint bit, byte type)
  126.     {
  127.         if (type == TerrainLayerType) //顶部墙壁
  128.         {
  129.             if (TerrainType == 0) //47格
  130.             {
  131.                 switch (bit)
  132.                 {
  133.                     case Center | Bottom: return 0;
  134.                     case Center | Right | Bottom: return 1;
  135.                     case Left | Center | Right | Bottom: return 2;
  136.                     case Left | Center | Bottom: return 3;
  137.                     case LeftTop | Top | Left | Center | Right | Bottom: return 4; 
  138.                     case Left | Center | Right | Bottom | RightBottom: return 5;
  139.                     case Left | Center | Right | LeftBottom | Bottom: return 6;
  140.                     case Top | RightTop | Left | Center | Right | Bottom: return 7;
  141.                     case Center | Right | Bottom | RightBottom: return 8;
  142.                     case Top | Left | Center | Right | LeftBottom | Bottom | RightBottom: return 9;
  143.                     case Left | Center | Right | LeftBottom | Bottom | RightBottom: return 10;
  144.                     case Left | Center | LeftBottom | Bottom: return 11;
  145.                     case Top | Center | Bottom: return 12;
  146.                     case Top | Center | Right | Bottom: return 13;
  147.                     case Top | Left | Center | Right | Bottom: return 14;
  148.                     case Top | Left | Center | Bottom: return 15;
  149.                     case Top | Center | Right | Bottom | RightBottom: return 16;
  150.                     case Top | RightTop | Left | Center | Right | LeftBottom | Bottom | RightBottom: return 17;
  151.                     case LeftTop | Top | Left | Center | Right | LeftBottom | Bottom | RightBottom: return 18;
  152.                     case Top | Left | Center | LeftBottom | Bottom: return 19;
  153.                     case Top | RightTop | Center | Right | Bottom | RightBottom: return 20;
  154.                     case Top | RightTop | Left | Center | Right | LeftBottom | Bottom: return 21;
  155.                     case LeftTop | Top | Left | Center | Right | LeftBottom | Bottom: return 23;
  156.                     case Top | Center: return 24;
  157.                     case Top | Center | Right: return 25;
  158.                     case Top | Left | Center | Right: return 26;
  159.                     case Top | Left | Center: return 27;
  160.                     case Top | RightTop | Center | Right | Bottom: return 28;
  161.                     case LeftTop | Top | RightTop | Left | Center | Right | Bottom | RightBottom: return 29;
  162.                     case LeftTop | Top | RightTop | Left | Center | Right | LeftBottom | Bottom: return 30;
  163.                     case LeftTop | Top | Left | Center | Bottom: return 31;
  164.                     case Top | RightTop | Left | Center | Right | Bottom | RightBottom: return 32;
  165.                     case LeftTop | Top | RightTop | Left | Center | Right | LeftBottom | Bottom | RightBottom: return 33;
  166.                     case LeftTop | Top | Left | Center | Right | Bottom | RightBottom: return 34;
  167.                     case LeftTop | Top | Left | Center | LeftBottom | Bottom: return 35; 
  168.                     case Center: return 36;
  169.                     case Center | Right: return 37;
  170.                     case Left | Center | Right: return 38;
  171.                     case Left | Center: return 39;
  172.                     case Top | Left | Center | Right | LeftBottom | Bottom: return 40;   
  173.                     case Top | RightTop | Left | Center | Right: return 41;
  174.                     case LeftTop | Top | Left | Center | Right: return 42;
  175.                     case Top | Left | Center | Right | Bottom | RightBottom: return 43;  
  176.                     case Top | RightTop | Center | Right: return 44;
  177.                     case LeftTop | Top | RightTop | Left | Center | Right: return 45;    
  178.                     case LeftTop | Top | RightTop | Left | Center | Right | Bottom: return 46;
  179.                     case LeftTop | Top | Left | Center: return 47;
  180.                 }
  181.             }
  182.             else if (TerrainType == 1) //13格
  183.             {
  184.                 switch (bit)
  185.                 {
  186.                     //第一排
  187.                     case Center | RightBottom: return 0;
  188.                     case Center | RightBottom | LeftBottom: return 1;
  189.                     case Center | LeftBottom: return 2;
  190.                     case Center | LeftTop | RightTop | LeftBottom: return 3;
  191.                     case Center | LeftTop | RightTop | RightBottom: return 4;
  192.                     //第二排
  193.                     case Center | RightTop | RightBottom: return 5;
  194.                     case Center | LeftTop | LeftBottom | RightTop | RightBottom: return 6;
  195.                     case Center | LeftTop | LeftBottom: return 7;
  196.                     case Center | LeftTop | LeftBottom | RightBottom: return 8;
  197.                     case Center | RightTop | LeftBottom | RightBottom: return 9;
  198.                     //第三排
  199.                     case Center | RightTop: return 10;
  200.                     case Center | LeftTop | RightTop: return 11;
  201.                     case Center | LeftTop: return 12;
  202.                 }
  203.             }
  204.         }
  205.         else if (type == MiddleLayerType)
  206.         {
  207.             if (bit < 4)
  208.             {
  209.                 return (int)bit;
  210.             }
  211.         }
  212.         else if (type == FloorLayerType)
  213.         {
  214.             if (bit == 0)
  215.             {
  216.                 return 0;
  217.             }
  218.         }
  219.  
  220.         return -1;
  221.     }
  222.  
  223.     /// <summary>
  224.     /// 根据给定的索引和类型计算地形掩码值。
  225.     /// </summary>
  226.     /// <param name="index">用于确定地形掩码的索引。</param>
  227.     /// <param name="type">要计算地形位值的图层类型。</param>
  228.     /// <returns></returns>
  229.     public uint IndexToTerrainBit(int index, byte type)
  230.     {
  231.         if (type == TerrainLayerType) //顶部墙壁
  232.         {
  233.             if (TerrainType == 0) //47格
  234.             {
  235.                 switch (index)
  236.                 {
  237.                     case 0: return Center | Bottom;
  238.                     case 1: return Center | Right | Bottom;
  239.                     case 2: return Left | Center | Right | Bottom;
  240.                     case 3: return Left | Center | Bottom;
  241.                     case 4: return LeftTop | Top | Left | Center | Right | Bottom; 
  242.                     case 5: return Left | Center | Right | Bottom | RightBottom;
  243.                     case 6: return Left | Center | Right | LeftBottom | Bottom;
  244.                     case 7: return Top | RightTop | Left | Center | Right | Bottom;
  245.                     case 8: return Center | Right | Bottom | RightBottom;
  246.                     case 9: return Top | Left | Center | Right | LeftBottom | Bottom | RightBottom;
  247.                     case 10: return Left | Center | Right | LeftBottom | Bottom | RightBottom;
  248.                     case 11: return Left | Center | LeftBottom | Bottom;
  249.                     case 12: return Top | Center | Bottom;
  250.                     case 13: return Top | Center | Right | Bottom;
  251.                     case 14: return Top | Left | Center | Right | Bottom;
  252.                     case 15: return Top | Left | Center | Bottom;
  253.                     case 16: return Top | Center | Right | Bottom | RightBottom;
  254.                     case 17: return Top | RightTop | Left | Center | Right | LeftBottom | Bottom | RightBottom;
  255.                     case 18: return LeftTop | Top | Left | Center | Right | LeftBottom | Bottom | RightBottom;
  256.                     case 19: return Top | Left | Center | LeftBottom | Bottom;
  257.                     case 20: return Top | RightTop | Center | Right | Bottom | RightBottom;
  258.                     case 21: return Top | RightTop | Left | Center | Right | LeftBottom | Bottom;
  259.                     case 23: return LeftTop | Top | Left | Center | Right | LeftBottom | Bottom;
  260.                     case 24: return Top | Center;
  261.                     case 25: return Top | Center | Right;
  262.                     case 26: return Top | Left | Center | Right;
  263.                     case 27: return Top | Left | Center;
  264.                     case 28: return Top | RightTop | Center | Right | Bottom;
  265.                     case 29: return LeftTop | Top | RightTop | Left | Center | Right | Bottom | RightBottom;
  266.                     case 30: return LeftTop | Top | RightTop | Left | Center | Right | LeftBottom | Bottom;
  267.                     case 31: return LeftTop | Top | Left | Center | Bottom;
  268.                     case 32: return Top | RightTop | Left | Center | Right | Bottom | RightBottom;
  269.                     case 33: return LeftTop | Top | RightTop | Left | Center | Right | LeftBottom | Bottom | RightBottom;
  270.                     case 34: return LeftTop | Top | Left | Center | Right | Bottom | RightBottom;
  271.                     case 35: return LeftTop | Top | Left | Center | LeftBottom | Bottom;   
  272.                     case 36: return Center;
  273.                     case 37: return Center | Right;
  274.                     case 38: return Left | Center | Right;
  275.                     case 39: return Left | Center;
  276.                     case 40: return Top | Left | Center | Right | LeftBottom | Bottom;     
  277.                     case 41: return Top | RightTop | Left | Center | Right;
  278.                     case 42: return LeftTop | Top | Left | Center | Right;
  279.                     case 43: return Top | Left | Center | Right | Bottom | RightBottom;    
  280.                     case 44: return Top | RightTop | Center | Right;
  281.                     case 45: return LeftTop | Top | RightTop | Left | Center | Right;      
  282.                     case 46: return LeftTop | Top | RightTop | Left | Center | Right | Bottom;
  283.                     case 47: return LeftTop | Top | Left | Center;
  284.                 }
  285.             }
  286.             else if (TerrainType == 1) //13格
  287.             {
  288.                 switch (index)
  289.                 {
  290.                     //第一排
  291.                     case 0: return Center | RightBottom;
  292.                     case 1: return Center | RightBottom | LeftBottom;
  293.                     case 2: return Center | LeftBottom;
  294.                     case 3: return Center | LeftTop | RightTop | LeftBottom;
  295.                     case 4: return Center | LeftTop | RightTop | RightBottom;
  296.                     //第二排
  297.                     case 5: return Center | RightTop | RightBottom;
  298.                     case 6: return Center | LeftTop | LeftBottom | RightTop | RightBottom;
  299.                     case 7: return Center | LeftTop | LeftBottom;
  300.                     case 8: return Center | LeftTop | LeftBottom | RightBottom;
  301.                     case 9: return Center | RightTop | LeftBottom | RightBottom;
  302.                     //第三排
  303.                     case 10: return Center | RightTop;
  304.                     case 11: return Center | LeftTop | RightTop;
  305.                     case 12: return Center | LeftTop;
  306.                 }
  307.             }
  308.         }
  309.         else if (type == MiddleLayerType)
  310.         {
  311.             if (index >= 0 && index < 4)
  312.             {
  313.                 return (uint)index;
  314.             }
  315.         }
  316.  
  317.         return None;
  318.     }
  319.     
  320.     /// <summary>
  321.     /// 将地形掩码存入 TileSetTerrainInfo 中
  322.     /// </summary>
  323.     public void SetTerrainCell(int index, byte type, int[] cellData)
  324.     {
  325.         if (type == TerrainLayerType) //顶部墙壁
  326.         {
  327.             var terrainBit = IndexToTerrainBit(index, type);
  328.             if (terrainBit != None)
  329.             {
  330.                 T[terrainBit] = cellData;
  331.             }
  332.         }
  333.         else if (type == MiddleLayerType) //侧方墙壁
  334.         {
  335.             switch (index)
  336.             {
  337.                 case 0: M[0] = cellData; break;
  338.                 case 1: M[1] = cellData; break;
  339.                 case 2: M[2] = cellData; break;
  340.                 case 3: M[3] = cellData; break;
  341.             }
  342.         }
  343.         else if (type == FloorLayerType) //地板
  344.         {
  345.             F[0] = cellData;
  346.         }
  347.     }
  348.  
  349.     /// <summary>
  350.     /// 移除地形掩码
  351.     /// </summary>
  352.     public void RemoveTerrainCell(int index, byte type)
  353.     {
  354.         if (type == TerrainLayerType) //顶部墙壁
  355.         {
  356.             var terrainBit = IndexToTerrainBit(index, type);
  357.             if (terrainBit != None)
  358.             {
  359.                 T.Remove(terrainBit);
  360.             }
  361.         }
  362.         else if (type == MiddleLayerType) //侧方墙壁
  363.         {
  364.             switch (index)
  365.             {
  366.                 case 0: M.Remove(0); break;
  367.                 case 1: M.Remove(1); break;
  368.                 case 2: M.Remove(2); break;
  369.                 case 3: M.Remove(3); break;
  370.             }
  371.         }
  372.         else if (type == FloorLayerType) //地板
  373.         {
  374.             F.Remove(0);
  375.         }
  376.     }
  377.     
  378.     /// <summary>
  379.     /// 获取指定索引的地形掩码存储的数据
  380.     /// </summary>
  381.     public int[] GetTerrainCell(int index, byte type)
  382.     {
  383.         if (type == TerrainLayerType) //顶部墙壁
  384.         {
  385.             var terrainBit = IndexToTerrainBit(index, type);
  386.             if (terrainBit != None)
  387.             {
  388.                 if (T.TryGetValue(terrainBit, out var cellData))
  389.                 {
  390.                     return cellData;
  391.                 }
  392.             }
  393.         }
  394.         else if (type == MiddleLayerType) //侧方墙壁
  395.         {
  396.             switch (index)
  397.             {
  398.                 case 0:
  399.                 {
  400.                     if (M.TryGetValue(0, out var cellData)) return cellData;
  401.                 }
  402.                     break;
  403.                 case 1:
  404.                 {
  405.                     if (M.TryGetValue(1, out var cellData)) return cellData;
  406.                 }
  407.                     break;
  408.                 case 2:
  409.                 {
  410.                     if (M.TryGetValue(2, out var cellData)) return cellData;
  411.                 }
  412.                     break;
  413.                 case 3:
  414.                 {
  415.                     if (M.TryGetValue(3, out var cellData)) return cellData;
  416.                 }
  417.                     break;
  418.             }
  419.         }
  420.         else if (type == FloorLayerType) //地板
  421.         {
  422.             if (F.TryGetValue(0, out var cellData)) return cellData;
  423.         }
  424.  
  425.         return null;
  426.     }
  427. }