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