uint tile data, resolves #13

Author: Ragath

TiledLib.Pipeline/TiledMapImporter.cs

@@ -11,14 +11,12 @@ public override Map Import(string filename, ContentImporterContext context)
     {
         string GetPath(string path) => Path.IsPathRooted(path) ? path : Path.Combine(Path.GetDirectoryName(filename), path);
 
-        using (var stream = File.OpenRead(filename))
-        {
-            var map = Map.FromStream(stream, ts => File.OpenRead(GetPath(ts.Source)));
+        using var stream = File.OpenRead(filename);
+        var map = Map.FromStream(stream, ts => File.OpenRead(GetPath(ts.Source)));
 
-            foreach (var ts in map.Tilesets.OfType<ExternalTileset>())
-                ts.LoadTileset();
+        foreach (var ts in map.Tilesets.OfType<ExternalTileset>())
+            ts.LoadTileset();
 
-            return map;
-        }
+        return map;
     }
 }

TiledLib.Tests/External_tilesetTests.cs

@@ -23,7 +23,7 @@ Tileset LoadTileset(ExternalTileset t)
                 ts.LoadTileset(LoadTileset);
 
             var q = from t in map.Tilesets
-                    from i in Enumerable.Range(t.FirstGid, t.Rows * t.Columns)
+                    from i in Enumerable.Range(t.FirstGid, t.Rows * t.Columns).Select(i => (uint)i)
                     select new
                     {
                         index = i,

TiledLib/ExternalTileset.cs

@@ -32,8 +32,8 @@ public class ExternalTileset : ITileset
     public Dictionary<int, Dictionary<string, string>> TileProperties => Tileset.TileProperties;
     public Dictionary<int, Frame[]> TileAnimations => Tileset.TileAnimations;
 
-    public Tile this[int gid] => Tileset[gid];
-    public string this[int gid, string property] => Tileset[gid, property];
+    public Tile this[uint gid] => Tileset[gid];
+    public string this[uint gid, string property] => Tileset[gid, property];
 
     public void LoadTileset()
     {
@@ -44,7 +44,7 @@ public void LoadTileset(Func<ExternalTileset, Tileset> loader)
         _Tileset = new Lazy<Tileset>(() =>
         {
             var tileset = loader(this);
-            tileset.FirstGid = this.FirstGid;
+            tileset.FirstGid = this.FirstGid & (int)TileOrientation.MaskID;
             return tileset;
         });
         LoadTileset();

TiledLib/ITileset.cs

@@ -3,8 +3,8 @@
 [JsonConverter(typeof(TilesetConverter))]
 public interface ITileset
 {
-    Tile this[int gid] { get; }
-    string this[int gid, string property] { get; }
+    Tile this[uint gid] { get; }
+    string this[uint gid, string property] { get; }
 
     int Columns { get; }
     int FirstGid { get; }

TiledLib/Layer/tilelayer.cs

@@ -16,7 +16,7 @@ public class TileLayer : BaseLayer, IXmlSerializable
 
     [Required]
     [JsonPropertyName("data")]
-    public int[] Data { get; set; }
+    public uint[] Data { get; set; }
 
     public XmlSchema GetSchema() => null;
 

TiledLib/LayerConverter.cs

@@ -35,21 +35,21 @@ public override BaseLayer Read(ref Utf8JsonReader reader, Type typeToConvert, Js
             switch (tl.Compression)
             {
                 case null:
-                    tl.Data = new int[buffer.Length / sizeof(int)];
+                    tl.Data = new uint[buffer.Length / sizeof(uint)];
                     Buffer.BlockCopy(buffer, 0, tl.Data, 0, buffer.Length);
                     break;
                 case "zlib":
                     using (var mStream = new MemoryStream(buffer))
                     {
                         using var stream = new Zlib.ZlibStream(mStream, Zlib.CompressionMode.Decompress);
-                        var bufferSize = result.Width * result.Height * sizeof(int);
+                        var bufferSize = result.Width * result.Height * sizeof(uint);
                         Array.Resize(ref buffer, bufferSize);
                         stream.Read(buffer, 0, bufferSize);
 
                         if (stream.ReadByte() != -1)
                             throw new JsonException();
 
-                        tl.Data = new int[result.Width * result.Height];
+                        tl.Data = new uint[result.Width * result.Height];
                         Buffer.BlockCopy(buffer, 0, tl.Data, 0, buffer.Length);
                     }
                     break;
@@ -64,7 +64,7 @@ public override BaseLayer Read(ref Utf8JsonReader reader, Type typeToConvert, Js
                         if (stream.ReadByte() != -1)
                             throw new JsonException();
 
-                        tl.Data = new int[result.Width * result.Height];
+                        tl.Data = new uint[result.Width * result.Height];
                         Buffer.BlockCopy(buffer, 0, tl.Data, 0, buffer.Length);
                     }
                     break;

TiledLib/TileOrientation.cs

@@ -1,9 +1,9 @@
 namespace TiledLib;
 
-public enum TileOrientation : int
+public enum TileOrientation : uint
 {
     Default = 0b00000000_00000000_00000000_00000000,
-    FlippedH = unchecked((int)0b10000000_00000000_00000000_00000000),
+    FlippedH = 0b10000000_00000000_00000000_00000000,
     FlippedV = 0b01000000_00000000_00000000_00000000,
     FlippedAD = 0b00100000_00000000_00000000_00000000,
     Rotate90CW = FlippedAD | FlippedH,

TiledLib/Tileset.cs

@@ -46,7 +46,7 @@ public class Tileset : ITileset, IXmlSerializable
     [JsonIgnore] //TODO: Add json support
     public Dictionary<int, Frame[]> TileAnimations { get; init; } = new Dictionary<int, Frame[]>();
 
-    public Tile this[int gid]
+    public Tile this[uint gid]
     {
         get
         {
@@ -57,7 +57,7 @@ public Tile this[int gid]
 
             var columns = Columns;
             var rows = Rows;
-            var index = Utils.GetId(gid) - FirstGid;
+            var index = Utils.GetId(gid) - (int)FirstGid;
             if (index < 0 || index >= rows * columns)
                 throw new ArgumentOutOfRangeException();
 
@@ -74,13 +74,13 @@ public Tile this[int gid]
         }
     }
 
-    public string this[int gid, string property]
+    public string this[uint gid, string property]
     {
         get
         {
-            gid = Utils.GetId(gid);
-            return gid != 0
-                   && TileProperties.TryGetValue(gid - FirstGid, out var tile)
+            var id = Utils.GetId(gid);
+            return id != 0
+                   && TileProperties.TryGetValue(id - FirstGid, out var tile)
                    && tile.TryGetValue(property, out var value) ? value : default;
         }
     }

TiledLib/TmxMisc.cs

@@ -136,11 +136,11 @@ static Frame[] ReadAnimation(this XmlReader reader)
             .ToArray();
     }
 
-    static int[] ReadCSV(this XmlReader reader, int size)
+    static uint[] ReadCSV(this XmlReader reader, int size)
     {
         var data = reader.ReadElementContentAsString()
             .Split(new[] { '\r', '\n', ',' }, StringSplitOptions.RemoveEmptyEntries)
-            .Select(int.Parse)
+            .Select(uint.Parse)
             .ToArray();
 
         if (data.Length == size)
@@ -149,41 +149,39 @@ static int[] ReadCSV(this XmlReader reader, int size)
             throw new XmlException();
     }
 
-    static int[] ReadBase64(this XmlReader reader, int count)
+    static uint[] ReadBase64(this XmlReader reader, int count)
     {
-        var buffer = new byte[count * sizeof(int)];
+        var buffer = new byte[count * sizeof(uint)];
         var size = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length);
         if (reader.ReadElementContentAsBase64(buffer, 0, buffer.Length) != 0)
             throw new InvalidDataException();
-        var data = new int[size / sizeof(int)];
+        var data = new uint[size / sizeof(uint)];
         Buffer.BlockCopy(buffer, 0, data, 0, size);
         return data;
     }
-    static int[] ReadBase64Decompress<T>(this XmlReader reader, Func<Stream, Zlib.CompressionMode, T> streamFactory, int size)
+    static uint[] ReadBase64Decompress<T>(this XmlReader reader, Func<Stream, Zlib.CompressionMode, T> streamFactory, int size)
         where T : Stream
     {
-        var buffer = new byte[size * sizeof(int)];
+        var buffer = new byte[size * sizeof(uint)];
 
         var total = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length);
         if (reader.ReadElementContentAsBase64(buffer, 0, buffer.Length) != 0)
             throw new InvalidDataException();
 
-        using (var mstream = new MemoryStream(buffer, 0, total))
-        using (var stream = streamFactory(mstream, Zlib.CompressionMode.Decompress))
+        using var mstream = new MemoryStream(buffer, 0, total);
+        using var stream = streamFactory(mstream, Zlib.CompressionMode.Decompress);
+        var data = new uint[size];
+        var pos = 0;
+        int count;
+        while ((count = stream.Read(buffer, 0, buffer.Length)) > 0)
         {
-            var data = new int[size];
-            var pos = 0;
-            int count;
-            while ((count = stream.Read(buffer, 0, buffer.Length)) > 0)
-            {
-                Buffer.BlockCopy(buffer, 0, data, pos, count);
-                pos += count;
-            }
-            return data;
+            Buffer.BlockCopy(buffer, 0, data, pos, count);
+            pos += count;
         }
+        return data;
     }
 
-    public static int[] ReadData(this XmlReader reader, int count, out string encoding, out string compression)
+    public static uint[] ReadData(this XmlReader reader, int count, out string encoding, out string compression)
     {
         encoding = reader["encoding"];
         compression = reader["compression"];

TiledLib/Utils.cs

@@ -36,6 +36,6 @@ internal static bool ContainsJson(this StreamReader reader)
         return true;
     }
 
-    public static int GetId(int gid) => gid & (int)TileOrientation.MaskID;
-    public static TileOrientation GetOrientation(int gid) => (TileOrientation)gid & TileOrientation.MaskFlip;
+    public static int GetId(uint gid) => (int)(gid & (uint)TileOrientation.MaskID);
+    public static TileOrientation GetOrientation(uint gid) => (TileOrientation)gid & TileOrientation.MaskFlip;
 }