diff --git a/DotTiled.Benchmark/DotTiled.Benchmark.csproj b/DotTiled.Benchmark/DotTiled.Benchmark.csproj
new file mode 100644
index 0000000..739d619
--- /dev/null
+++ b/DotTiled.Benchmark/DotTiled.Benchmark.csproj
@@ -0,0 +1,20 @@
+ïŧŋ
+
+
+ Exe
+ net8.0
+ enable
+ enable
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/DotTiled.Benchmark/Program.cs b/DotTiled.Benchmark/Program.cs
new file mode 100644
index 0000000..2acbce2
--- /dev/null
+++ b/DotTiled.Benchmark/Program.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
+
+namespace MyBenchmarks
+{
+ [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+ [CategoriesColumn]
+ [Orderer(SummaryOrderPolicy.FastestToSlowest)]
+ [HideColumns(["StdDev", "Error", "RatioSD"])]
+ public class MapLoading
+ {
+ private string _tmxPath = @"DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmx";
+ private string _tmxContents = "";
+
+ private string _tmjPath = @"DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmj";
+ private string _tmjContents = "";
+
+ public MapLoading()
+ {
+ var basePath = Path.GetDirectoryName(WhereAmI())!;
+ var tmxPath = Path.Combine(basePath, $"../{_tmxPath}");
+ var tmjPath = Path.Combine(basePath, $"../{_tmjPath}");
+
+ _tmxContents = System.IO.File.ReadAllText(tmxPath);
+ _tmjContents = System.IO.File.ReadAllText(tmjPath);
+ }
+
+ static string WhereAmI([CallerFilePath] string callerFilePath = "") => callerFilePath;
+
+ [BenchmarkCategory("MapFromInMemoryTmxString")]
+ [Benchmark(Baseline = true, Description = "DotTiled")]
+ public DotTiled.Map LoadWithDotTiledFromInMemoryTmxString()
+ {
+ using var stringReader = new StringReader(_tmxContents);
+ using var xmlReader = XmlReader.Create(stringReader);
+ using var mapReader = new DotTiled.TmxMapReader(xmlReader, _ => throw new Exception(), _ => throw new Exception(), []);
+ return mapReader.ReadMap();
+ }
+
+ [BenchmarkCategory("MapFromInMemoryTmjString")]
+ [Benchmark(Baseline = true, Description = "DotTiled")]
+ public DotTiled.Map LoadWithDotTiledFromInMemoryTmjString()
+ {
+ using var mapReader = new DotTiled.TmjMapReader(_tmjContents, _ => throw new Exception(), _ => throw new Exception(), []);
+ return mapReader.ReadMap();
+ }
+
+ [BenchmarkCategory("MapFromInMemoryTmxString")]
+ [Benchmark(Description = "TiledLib")]
+ public TiledLib.Map LoadWithTiledLibFromInMemoryTmxString()
+ {
+ using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(_tmxContents));
+ return TiledLib.Map.FromStream(memStream);
+ }
+
+ [BenchmarkCategory("MapFromInMemoryTmjString")]
+ [Benchmark(Description = "TiledLib")]
+ public TiledLib.Map LoadWithTiledLibFromInMemoryTmjString()
+ {
+ using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(_tmjContents));
+ return TiledLib.Map.FromStream(memStream);
+ }
+
+ [BenchmarkCategory("MapFromInMemoryTmxString")]
+ [Benchmark(Description = "TiledCSPlus")]
+ public TiledCSPlus.TiledMap LoadWithTiledCSPlusFromInMemoryTmxString()
+ {
+ using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(_tmxContents));
+ return new TiledCSPlus.TiledMap(memStream);
+ }
+ }
+
+ public class Program
+ {
+ public static void Main(string[] args)
+ {
+ var config = BenchmarkDotNet.Configs.DefaultConfig.Instance
+ .WithArtifactsPath(args[0])
+ .WithOptions(ConfigOptions.DisableOptimizationsValidator)
+ .AddDiagnoser(BenchmarkDotNet.Diagnosers.MemoryDiagnoser.Default);
+ var summary = BenchmarkRunner.Run(config);
+ }
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertData.cs b/DotTiled.Tests/Assert/AssertData.cs
new file mode 100644
index 0000000..31ffff2
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertData.cs
@@ -0,0 +1,43 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ internal static void AssertData(Data? expected, Data? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ // Attributes
+ Assert.NotNull(actual);
+ AssertEqual(expected.Encoding, actual.Encoding, nameof(Data.Encoding));
+ AssertEqual(expected.Compression, actual.Compression, nameof(Data.Compression));
+
+ // Data
+ AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Data.GlobalTileIDs));
+ AssertEqual(expected.FlippingFlags, actual.FlippingFlags, nameof(Data.FlippingFlags));
+
+ if (expected.Chunks is not null)
+ {
+ Assert.NotNull(actual.Chunks);
+ AssertEqual(expected.Chunks.Length, actual.Chunks.Length, "Chunks.Length");
+ for (var i = 0; i < expected.Chunks.Length; i++)
+ AssertChunk(expected.Chunks[i], actual.Chunks[i]);
+ }
+ }
+
+ private static void AssertChunk(Chunk expected, Chunk actual)
+ {
+ // Attributes
+ AssertEqual(expected.X, actual.X, nameof(Chunk.X));
+ AssertEqual(expected.Y, actual.Y, nameof(Chunk.Y));
+ AssertEqual(expected.Width, actual.Width, nameof(Chunk.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(Chunk.Height));
+
+ // Data
+ AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Chunk.GlobalTileIDs));
+ AssertEqual(expected.FlippingFlags, actual.FlippingFlags, nameof(Chunk.FlippingFlags));
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertImage.cs b/DotTiled.Tests/Assert/AssertImage.cs
new file mode 100644
index 0000000..a674faa
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertImage.cs
@@ -0,0 +1,21 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ internal static void AssertImage(Image? expected, Image? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ // Attributes
+ Assert.NotNull(actual);
+ AssertEqual(expected.Format, actual.Format, nameof(Image.Format));
+ AssertEqual(expected.Source, actual.Source, nameof(Image.Source));
+ AssertEqual(expected.TransparentColor, actual.TransparentColor, nameof(Image.TransparentColor));
+ AssertEqual(expected.Width, actual.Width, nameof(Image.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(Image.Height));
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertLayer.cs b/DotTiled.Tests/Assert/AssertLayer.cs
new file mode 100644
index 0000000..5432d62
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertLayer.cs
@@ -0,0 +1,75 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ internal static void AssertLayer(BaseLayer? expected, BaseLayer? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ // Attributes
+ Assert.NotNull(actual);
+ AssertEqual(expected.ID, actual.ID, nameof(BaseLayer.ID));
+ AssertEqual(expected.Name, actual.Name, nameof(BaseLayer.Name));
+ AssertEqual(expected.Class, actual.Class, nameof(BaseLayer.Class));
+ AssertEqual(expected.Opacity, actual.Opacity, nameof(BaseLayer.Opacity));
+ AssertEqual(expected.Visible, actual.Visible, nameof(BaseLayer.Visible));
+ AssertEqual(expected.TintColor, actual.TintColor, nameof(BaseLayer.TintColor));
+ AssertEqual(expected.OffsetX, actual.OffsetX, nameof(BaseLayer.OffsetX));
+ AssertEqual(expected.OffsetY, actual.OffsetY, nameof(BaseLayer.OffsetY));
+ AssertEqual(expected.ParallaxX, actual.ParallaxX, nameof(BaseLayer.ParallaxX));
+ AssertEqual(expected.ParallaxY, actual.ParallaxY, nameof(BaseLayer.ParallaxY));
+
+ AssertProperties(expected.Properties, actual.Properties);
+ AssertLayer((dynamic)expected, (dynamic)actual);
+ }
+
+ private static void AssertLayer(TileLayer expected, TileLayer actual)
+ {
+ // Attributes
+ AssertEqual(expected.Width, actual.Width, nameof(TileLayer.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(TileLayer.Height));
+ AssertEqual(expected.X, actual.X, nameof(TileLayer.X));
+ AssertEqual(expected.Y, actual.Y, nameof(TileLayer.Y));
+
+ Assert.NotNull(actual.Data);
+ AssertData(expected.Data, actual.Data);
+ }
+
+ private static void AssertLayer(ObjectLayer expected, ObjectLayer actual)
+ {
+ // Attributes
+ AssertEqual(expected.DrawOrder, actual.DrawOrder, nameof(ObjectLayer.DrawOrder));
+ AssertEqual(expected.X, actual.X, nameof(ObjectLayer.X));
+ AssertEqual(expected.Y, actual.Y, nameof(ObjectLayer.Y));
+
+ Assert.NotNull(actual.Objects);
+ AssertEqual(expected.Objects.Count, actual.Objects.Count, "Objects.Count");
+ for (var i = 0; i < expected.Objects.Count; i++)
+ AssertObject(expected.Objects[i], actual.Objects[i]);
+ }
+
+ private static void AssertLayer(ImageLayer expected, ImageLayer actual)
+ {
+ // Attributes
+ AssertEqual(expected.RepeatX, actual.RepeatX, nameof(ImageLayer.RepeatX));
+ AssertEqual(expected.RepeatY, actual.RepeatY, nameof(ImageLayer.RepeatY));
+ AssertEqual(expected.X, actual.X, nameof(ImageLayer.X));
+ AssertEqual(expected.Y, actual.Y, nameof(ImageLayer.Y));
+
+ Assert.NotNull(actual.Image);
+ AssertImage(expected.Image, actual.Image);
+ }
+
+ private static void AssertLayer(Group expected, Group actual)
+ {
+ // Attributes
+ Assert.NotNull(actual.Layers);
+ AssertEqual(expected.Layers.Count, actual.Layers.Count, "Layers.Count");
+ for (var i = 0; i < expected.Layers.Count; i++)
+ AssertLayer(expected.Layers[i], actual.Layers[i]);
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertMap.cs b/DotTiled.Tests/Assert/AssertMap.cs
new file mode 100644
index 0000000..e9ad8be
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertMap.cs
@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Numerics;
+
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ private static void AssertEqual(T expected, T actual, string nameof)
+ {
+ if (expected == null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ if (typeof(T) == typeof(float))
+ {
+ var expectedFloat = (float)(object)expected;
+ var actualFloat = (float)(object)actual!;
+
+ var expecRounded = MathF.Round(expectedFloat, 3);
+ var actRounded = MathF.Round(actualFloat, 3);
+
+ Assert.True(expecRounded == actRounded, $"Expected {nameof} '{expecRounded}' but got '{actRounded}'");
+ return;
+ }
+
+ if (expected is Vector2)
+ {
+ var expectedVector = (Vector2)(object)expected;
+ var actualVector = (Vector2)(object)actual!;
+
+ AssertEqual(expectedVector.X, actualVector.X, $"{nameof}.X");
+ AssertEqual(expectedVector.Y, actualVector.Y, $"{nameof}.Y");
+
+ return;
+ }
+
+ if (typeof(T).IsArray)
+ {
+ var expectedArray = (Array)(object)expected;
+ var actualArray = (Array)(object)actual!;
+
+ Assert.NotNull(actualArray);
+ AssertEqual(expectedArray.Length, actualArray.Length, $"{nameof}.Length");
+
+ for (var i = 0; i < expectedArray.Length; i++)
+ AssertEqual(expectedArray.GetValue(i), actualArray.GetValue(i), $"{nameof}[{i}]");
+
+ return;
+ }
+
+ if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(List<>))
+ {
+ var expectedList = (IList)(object)expected;
+ var actualList = (IList)(object)actual!;
+
+ Assert.NotNull(actualList);
+ AssertEqual(expectedList.Count, actualList.Count, $"{nameof}.Count");
+
+ for (var i = 0; i < expectedList.Count; i++)
+ AssertEqual(expectedList[i], actualList[i], $"{nameof}[{i}]");
+
+ return;
+ }
+
+ Assert.True(expected.Equals(actual), $"Expected {nameof} '{expected}' but got '{actual}'");
+ }
+
+ internal static void AssertMap(Map expected, Map actual)
+ {
+ // Attributes
+ AssertEqual(expected.Version, actual.Version, nameof(Map.Version));
+ AssertEqual(expected.TiledVersion, actual.TiledVersion, nameof(Map.TiledVersion));
+ AssertEqual(expected.Class, actual.Class, nameof(Map.Class));
+ AssertEqual(expected.Orientation, actual.Orientation, nameof(Map.Orientation));
+ AssertEqual(expected.RenderOrder, actual.RenderOrder, nameof(Map.RenderOrder));
+ AssertEqual(expected.CompressionLevel, actual.CompressionLevel, nameof(Map.CompressionLevel));
+ AssertEqual(expected.Width, actual.Width, nameof(Map.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(Map.Height));
+ AssertEqual(expected.TileWidth, actual.TileWidth, nameof(Map.TileWidth));
+ AssertEqual(expected.TileHeight, actual.TileHeight, nameof(Map.TileHeight));
+ AssertEqual(expected.HexSideLength, actual.HexSideLength, nameof(Map.HexSideLength));
+ AssertEqual(expected.StaggerAxis, actual.StaggerAxis, nameof(Map.StaggerAxis));
+ AssertEqual(expected.StaggerIndex, actual.StaggerIndex, nameof(Map.StaggerIndex));
+ AssertEqual(expected.ParallaxOriginX, actual.ParallaxOriginX, nameof(Map.ParallaxOriginX));
+ AssertEqual(expected.ParallaxOriginY, actual.ParallaxOriginY, nameof(Map.ParallaxOriginY));
+ AssertEqual(expected.BackgroundColor, actual.BackgroundColor, nameof(Map.BackgroundColor));
+ AssertEqual(expected.NextLayerID, actual.NextLayerID, nameof(Map.NextLayerID));
+ AssertEqual(expected.NextObjectID, actual.NextObjectID, nameof(Map.NextObjectID));
+ AssertEqual(expected.Infinite, actual.Infinite, nameof(Map.Infinite));
+
+ AssertProperties(actual.Properties, expected.Properties);
+
+ Assert.NotNull(actual.Tilesets);
+ AssertEqual(expected.Tilesets.Count, actual.Tilesets.Count, "Tilesets.Count");
+ for (var i = 0; i < expected.Tilesets.Count; i++)
+ AssertTileset(expected.Tilesets[i], actual.Tilesets[i]);
+
+ Assert.NotNull(actual.Layers);
+ AssertEqual(expected.Layers.Count, actual.Layers.Count, "Layers.Count");
+ for (var i = 0; i < expected.Layers.Count; i++)
+ AssertLayer(expected.Layers[i], actual.Layers[i]);
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertObject.cs b/DotTiled.Tests/Assert/AssertObject.cs
new file mode 100644
index 0000000..6c586bb
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertObject.cs
@@ -0,0 +1,73 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ internal static void AssertObject(Object expected, Object actual)
+ {
+ // Attributes
+ AssertEqual(expected.ID, actual.ID, nameof(Object.ID));
+ AssertEqual(expected.Name, actual.Name, nameof(Object.Name));
+ AssertEqual(expected.Type, actual.Type, nameof(Object.Type));
+ AssertEqual(expected.X, actual.X, nameof(Object.X));
+ AssertEqual(expected.Y, actual.Y, nameof(Object.Y));
+ AssertEqual(expected.Width, actual.Width, nameof(Object.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(Object.Height));
+ AssertEqual(expected.Rotation, actual.Rotation, nameof(Object.Rotation));
+ AssertEqual(expected.Visible, actual.Visible, nameof(Object.Visible));
+ AssertEqual(expected.Template, actual.Template, nameof(Object.Template));
+
+ AssertProperties(expected.Properties, actual.Properties);
+
+ Assert.True(expected.GetType() == actual.GetType(), $"Expected object type {expected.GetType()} but got {actual.GetType()}");
+ AssertObject((dynamic)expected, (dynamic)actual);
+ }
+
+ private static void AssertObject(RectangleObject expected, RectangleObject actual)
+ {
+ Assert.True(true); // A rectangle object is the same as the abstract Object
+ }
+
+ private static void AssertObject(EllipseObject expected, EllipseObject actual)
+ {
+ Assert.True(true); // An ellipse object is the same as the abstract Object
+ }
+
+ private static void AssertObject(PointObject expected, PointObject actual)
+ {
+ Assert.True(true); // A point object is the same as the abstract Object
+ }
+
+ private static void AssertObject(PolygonObject expected, PolygonObject actual)
+ {
+ AssertEqual(expected.Points, actual.Points, nameof(PolygonObject.Points));
+ }
+
+ private static void AssertObject(PolylineObject expected, PolylineObject actual)
+ {
+ AssertEqual(expected.Points, actual.Points, nameof(PolylineObject.Points));
+ }
+
+ private static void AssertObject(TextObject expected, TextObject actual)
+ {
+ // Attributes
+ AssertEqual(expected.FontFamily, actual.FontFamily, nameof(TextObject.FontFamily));
+ AssertEqual(expected.PixelSize, actual.PixelSize, nameof(TextObject.PixelSize));
+ AssertEqual(expected.Wrap, actual.Wrap, nameof(TextObject.Wrap));
+ AssertEqual(expected.Color, actual.Color, nameof(TextObject.Color));
+ AssertEqual(expected.Bold, actual.Bold, nameof(TextObject.Bold));
+ AssertEqual(expected.Italic, actual.Italic, nameof(TextObject.Italic));
+ AssertEqual(expected.Underline, actual.Underline, nameof(TextObject.Underline));
+ AssertEqual(expected.Strikeout, actual.Strikeout, nameof(TextObject.Strikeout));
+ AssertEqual(expected.Kerning, actual.Kerning, nameof(TextObject.Kerning));
+ AssertEqual(expected.HorizontalAlignment, actual.HorizontalAlignment, nameof(TextObject.HorizontalAlignment));
+ AssertEqual(expected.VerticalAlignment, actual.VerticalAlignment, nameof(TextObject.VerticalAlignment));
+
+ AssertEqual(expected.Text, actual.Text, nameof(TextObject.Text));
+ }
+
+ private static void AssertObject(TileObject expected, TileObject actual)
+ {
+ // Attributes
+ AssertEqual(expected.GID, actual.GID, nameof(TileObject.GID));
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertProperties.cs b/DotTiled.Tests/Assert/AssertProperties.cs
new file mode 100644
index 0000000..740ba2b
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertProperties.cs
@@ -0,0 +1,69 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ internal static void AssertProperties(Dictionary? expected, Dictionary? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ Assert.NotNull(actual);
+ AssertEqual(expected.Count, actual.Count, "Properties.Count");
+ foreach (var kvp in expected)
+ {
+ Assert.Contains(kvp.Key, actual.Keys);
+ AssertProperty((dynamic)kvp.Value, (dynamic)actual[kvp.Key]);
+ }
+ }
+
+ private static void AssertProperty(IProperty expected, IProperty actual)
+ {
+ AssertEqual(expected.Type, actual.Type, "Property.Type");
+ AssertEqual(expected.Name, actual.Name, "Property.Name");
+ AssertProperties((dynamic)actual, (dynamic)expected);
+ }
+
+ private static void AssertProperty(StringProperty expected, StringProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "StringProperty.Value");
+ }
+
+ private static void AssertProperty(IntProperty expected, IntProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "IntProperty.Value");
+ }
+
+ private static void AssertProperty(FloatProperty expected, FloatProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "FloatProperty.Value");
+ }
+
+ private static void AssertProperty(BoolProperty expected, BoolProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "BoolProperty.Value");
+ }
+
+ private static void AssertProperty(ColorProperty expected, ColorProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "ColorProperty.Value");
+ }
+
+ private static void AssertProperty(FileProperty expected, FileProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "FileProperty.Value");
+ }
+
+ private static void AssertProperty(ObjectProperty expected, ObjectProperty actual)
+ {
+ AssertEqual(expected.Value, actual.Value, "ObjectProperty.Value");
+ }
+
+ private static void AssertProperty(ClassProperty expected, ClassProperty actual)
+ {
+ AssertEqual(expected.PropertyType, actual.PropertyType, "ClassProperty.PropertyType");
+ AssertProperties(expected.Properties, actual.Properties);
+ }
+}
diff --git a/DotTiled.Tests/Assert/AssertTileset.cs b/DotTiled.Tests/Assert/AssertTileset.cs
new file mode 100644
index 0000000..e6b39bb
--- /dev/null
+++ b/DotTiled.Tests/Assert/AssertTileset.cs
@@ -0,0 +1,160 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+ internal static void AssertTileset(Tileset expected, Tileset actual)
+ {
+ // Attributes
+ AssertEqual(expected.Version, actual.Version, nameof(Tileset.Version));
+ AssertEqual(expected.TiledVersion, actual.TiledVersion, nameof(Tileset.TiledVersion));
+ AssertEqual(expected.FirstGID, actual.FirstGID, nameof(Tileset.FirstGID));
+ AssertEqual(expected.Source, actual.Source, nameof(Tileset.Source));
+ AssertEqual(expected.Name, actual.Name, nameof(Tileset.Name));
+ AssertEqual(expected.Class, actual.Class, nameof(Tileset.Class));
+ AssertEqual(expected.TileWidth, actual.TileWidth, nameof(Tileset.TileWidth));
+ AssertEqual(expected.TileHeight, actual.TileHeight, nameof(Tileset.TileHeight));
+ AssertEqual(expected.Spacing, actual.Spacing, nameof(Tileset.Spacing));
+ AssertEqual(expected.Margin, actual.Margin, nameof(Tileset.Margin));
+ AssertEqual(expected.TileCount, actual.TileCount, nameof(Tileset.TileCount));
+ AssertEqual(expected.Columns, actual.Columns, nameof(Tileset.Columns));
+ AssertEqual(expected.ObjectAlignment, actual.ObjectAlignment, nameof(Tileset.ObjectAlignment));
+ AssertEqual(expected.RenderSize, actual.RenderSize, nameof(Tileset.RenderSize));
+ AssertEqual(expected.FillMode, actual.FillMode, nameof(Tileset.FillMode));
+
+ // At most one of
+ AssertImage(expected.Image, actual.Image);
+ AssertTileOffset(expected.TileOffset, actual.TileOffset);
+ AssertGrid(expected.Grid, actual.Grid);
+ AssertProperties(expected.Properties, actual.Properties);
+ // TODO: AssertTerrainTypes(actual.TerrainTypes, expected.TerrainTypes);
+ if (expected.Wangsets is not null)
+ {
+ Assert.NotNull(actual.Wangsets);
+ AssertEqual(expected.Wangsets.Count, actual.Wangsets.Count, "Wangsets.Count");
+ for (var i = 0; i < expected.Wangsets.Count; i++)
+ AssertWangset(expected.Wangsets[i], actual.Wangsets[i]);
+ }
+ AssertTransformations(expected.Transformations, actual.Transformations);
+
+ // Any number of
+ Assert.NotNull(actual.Tiles);
+ AssertEqual(expected.Tiles.Count, actual.Tiles.Count, "Tiles.Count");
+ for (var i = 0; i < expected.Tiles.Count; i++)
+ AssertTile(expected.Tiles[i], actual.Tiles[i]);
+ }
+
+ private static void AssertTileOffset(TileOffset? expected, TileOffset? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ // Attributes
+ Assert.NotNull(actual);
+ AssertEqual(expected.X, actual.X, nameof(TileOffset.X));
+ AssertEqual(expected.Y, actual.Y, nameof(TileOffset.Y));
+ }
+
+ private static void AssertGrid(Grid? expected, Grid? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ // Attributes
+ Assert.NotNull(actual);
+ AssertEqual(expected.Orientation, actual.Orientation, nameof(Grid.Orientation));
+ AssertEqual(expected.Width, actual.Width, nameof(Grid.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(Grid.Height));
+ }
+
+ private static void AssertWangset(Wangset expected, Wangset actual)
+ {
+ // Attributes
+ AssertEqual(expected.Name, actual.Name, nameof(Wangset.Name));
+ AssertEqual(expected.Class, actual.Class, nameof(Wangset.Class));
+ AssertEqual(expected.Tile, actual.Tile, nameof(Wangset.Tile));
+
+ // At most one of
+ AssertProperties(expected.Properties, actual.Properties);
+ if (expected.WangColors is not null)
+ {
+ Assert.NotNull(actual.WangColors);
+ AssertEqual(expected.WangColors.Count, actual.WangColors.Count, "WangColors.Count");
+ for (var i = 0; i < expected.WangColors.Count; i++)
+ AssertWangColor(expected.WangColors[i], actual.WangColors[i]);
+ }
+ for (var i = 0; i < expected.WangTiles.Count; i++)
+ AssertWangTile(expected.WangTiles[i], actual.WangTiles[i]);
+ }
+
+ private static void AssertWangColor(WangColor expected, WangColor actual)
+ {
+ // Attributes
+ AssertEqual(expected.Name, actual.Name, nameof(WangColor.Name));
+ AssertEqual(expected.Class, actual.Class, nameof(WangColor.Class));
+ AssertEqual(expected.Color, actual.Color, nameof(WangColor.Color));
+ AssertEqual(expected.Tile, actual.Tile, nameof(WangColor.Tile));
+ AssertEqual(expected.Probability, actual.Probability, nameof(WangColor.Probability));
+
+ AssertProperties(expected.Properties, actual.Properties);
+ }
+
+ private static void AssertWangTile(WangTile expected, WangTile actual)
+ {
+ // Attributes
+ AssertEqual(expected.TileID, actual.TileID, nameof(WangTile.TileID));
+ AssertEqual(expected.WangID, actual.WangID, nameof(WangTile.WangID));
+ }
+
+ private static void AssertTransformations(Transformations? expected, Transformations? actual)
+ {
+ if (expected is null)
+ {
+ Assert.Null(actual);
+ return;
+ }
+
+ // Attributes
+ Assert.NotNull(actual);
+ AssertEqual(expected.HFlip, actual.HFlip, nameof(Transformations.HFlip));
+ AssertEqual(expected.VFlip, actual.VFlip, nameof(Transformations.VFlip));
+ AssertEqual(expected.Rotate, actual.Rotate, nameof(Transformations.Rotate));
+ AssertEqual(expected.PreferUntransformed, actual.PreferUntransformed, nameof(Transformations.PreferUntransformed));
+ }
+
+ private static void AssertTile(Tile expected, Tile actual)
+ {
+ // Attributes
+ AssertEqual(expected.ID, actual.ID, nameof(Tile.ID));
+ AssertEqual(expected.Type, actual.Type, nameof(Tile.Type));
+ AssertEqual(expected.Probability, actual.Probability, nameof(Tile.Probability));
+ AssertEqual(expected.X, actual.X, nameof(Tile.X));
+ AssertEqual(expected.Y, actual.Y, nameof(Tile.Y));
+ AssertEqual(expected.Width, actual.Width, nameof(Tile.Width));
+ AssertEqual(expected.Height, actual.Height, nameof(Tile.Height));
+
+ // Elements
+ AssertProperties(actual.Properties, expected.Properties);
+ AssertImage(actual.Image, expected.Image);
+ AssertLayer((BaseLayer?)actual.ObjectLayer, (BaseLayer?)expected.ObjectLayer);
+ if (expected.Animation is not null)
+ {
+ Assert.NotNull(actual.Animation);
+ AssertEqual(expected.Animation.Count, actual.Animation.Count, "Animation.Count");
+ for (var i = 0; i < expected.Animation.Count; i++)
+ AssertFrame(expected.Animation[i], actual.Animation[i]);
+ }
+ }
+
+ private static void AssertFrame(Frame expected, Frame actual)
+ {
+ // Attributes
+ AssertEqual(expected.TileID, actual.TileID, nameof(Frame.TileID));
+ AssertEqual(expected.Duration, actual.Duration, nameof(Frame.Duration));
+ }
+}
diff --git a/DotTiled.Tests/DotTiled.Tests.csproj b/DotTiled.Tests/DotTiled.Tests.csproj
index c110013..faa22d4 100644
--- a/DotTiled.Tests/DotTiled.Tests.csproj
+++ b/DotTiled.Tests/DotTiled.Tests.csproj
@@ -25,8 +25,8 @@
-
-
+
+
diff --git a/DotTiled.Tests/Serialization/TestData.cs b/DotTiled.Tests/Serialization/TestData.cs
new file mode 100644
index 0000000..c3d52f8
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData.cs
@@ -0,0 +1,79 @@
+using System.Xml;
+
+namespace DotTiled.Tests;
+
+public static partial class TestData
+{
+ public static XmlReader GetXmlReaderFor(string testDataFile)
+ {
+ var fullyQualifiedTestDataFile = $"DotTiled.Tests.{ConvertPathToAssemblyResourcePath(testDataFile)}";
+ using var stream = typeof(TestData).Assembly.GetManifestResourceStream(fullyQualifiedTestDataFile)
+ ?? throw new ArgumentException($"Test data file '{fullyQualifiedTestDataFile}' not found");
+
+ using var stringReader = new StreamReader(stream);
+ var xml = stringReader.ReadToEnd();
+ var xmlStringReader = new StringReader(xml);
+ return XmlReader.Create(xmlStringReader);
+ }
+
+ public static string GetRawStringFor(string testDataFile)
+ {
+ var fullyQualifiedTestDataFile = $"DotTiled.Tests.{ConvertPathToAssemblyResourcePath(testDataFile)}";
+ using var stream = typeof(TestData).Assembly.GetManifestResourceStream(fullyQualifiedTestDataFile)
+ ?? throw new ArgumentException($"Test data file '{fullyQualifiedTestDataFile}' not found");
+
+ using var stringReader = new StreamReader(stream);
+ return stringReader.ReadToEnd();
+ }
+
+ private static string ConvertPathToAssemblyResourcePath(string path) =>
+ path.Replace("/", ".").Replace("\\", ".").Replace(" ", "_");
+
+ public static IEnumerable MapTests =>
+ [
+ ["Serialization/TestData/Map/default_map/default-map", (string f) => TestData.DefaultMap(), Array.Empty()],
+ ["Serialization/TestData/Map/map_with_common_props/map-with-common-props", (string f) => TestData.MapWithCommonProps(), Array.Empty()],
+ ["Serialization/TestData/Map/map_with_custom_type_props/map-with-custom-type-props", (string f) => TestData.MapWithCustomTypeProps(), TestData.MapWithCustomTypePropsCustomTypeDefinitions()],
+ ["Serialization/TestData/Map/map_with_embedded_tileset/map-with-embedded-tileset", (string f) => TestData.MapWithEmbeddedTileset(), Array.Empty()],
+ ["Serialization/TestData/Map/map_with_external_tileset/map-with-external-tileset", (string f) => TestData.MapWithExternalTileset(f), Array.Empty()],
+ ["Serialization/TestData/Map/map_with_flippingflags/map-with-flippingflags", (string f) => TestData.MapWithFlippingFlags(f), Array.Empty()],
+ ["Serialization/TestData/Map/map_external_tileset_multi/map-external-tileset-multi", (string f) => TestData.MapExternalTilesetMulti(f), Array.Empty()],
+ ["Serialization/TestData/Map/map_external_tileset_wangset/map-external-tileset-wangset", (string f) => TestData.MapExternalTilesetWangset(f), Array.Empty()],
+ ["Serialization/TestData/Map/map_with_many_layers/map-with-many-layers", (string f) => TestData.MapWithManyLayers(f), Array.Empty()],
+ ];
+
+ private static CustomTypeDefinition[] typedefs = [
+ new CustomClassDefinition
+ {
+ Name = "TestClass",
+ ID = 1,
+ UseAs = CustomClassUseAs.Property,
+ Members = [
+ new StringProperty
+ {
+ Name = "Name",
+ Value = ""
+ },
+ new FloatProperty
+ {
+ Name = "Amount",
+ Value = 0f
+ }
+ ]
+ },
+ new CustomClassDefinition
+ {
+ Name = "Test",
+ ID = 2,
+ UseAs = CustomClassUseAs.All,
+ Members = [
+ new ClassProperty
+ {
+ Name = "Yep",
+ PropertyType = "TestClass",
+ Properties = []
+ }
+ ]
+ }
+ ];
+}
diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.cs b/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs
similarity index 68%
rename from DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.cs
rename to DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs
index ad27d8e..eff73d9 100644
--- a/DotTiled.Tests/TmxSerializer/TestData/Map/simple-tileset-embed.cs
+++ b/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs
@@ -1,37 +1,28 @@
namespace DotTiled.Tests;
-public partial class TmxSerializerMapTests
+public partial class TestData
{
- private static Map SimpleMapWithEmbeddedTileset() => new Map
+ public static Map DefaultMap() => new Map
{
- Version = "1.10",
- TiledVersion = "1.11.0",
+ Class = "",
Orientation = MapOrientation.Orthogonal,
- RenderOrder = RenderOrder.RightDown,
Width = 5,
Height = 5,
TileWidth = 32,
TileHeight = 32,
Infinite = false,
+ HexSideLength = null,
+ StaggerAxis = null,
+ StaggerIndex = null,
+ ParallaxOriginX = 0,
+ ParallaxOriginY = 0,
+ RenderOrder = RenderOrder.RightDown,
+ CompressionLevel = -1,
+ BackgroundColor = new Color { R = 0, G = 0, B = 0, A = 0 },
+ Version = "1.10",
+ TiledVersion = "1.11.0",
NextLayerID = 2,
NextObjectID = 1,
- Tilesets = [
- new Tileset
- {
- FirstGID = 1,
- Name = "Tileset 1",
- TileWidth = 32,
- TileHeight = 32,
- TileCount = 8,
- Columns = 4,
- Image = new Image
- {
- Source = "tiles.png",
- Width = 128,
- Height = 64
- }
- }
- ],
Layers = [
new TileLayer
{
@@ -42,13 +33,14 @@ public partial class TmxSerializerMapTests
Data = new Data
{
Encoding = DataEncoding.Csv,
+ Chunks = null,
Compression = null,
GlobalTileIDs = [
- 1,1,1,1,1,
- 1,1,1,1,1,
- 1,1,1,1,1,
- 2,2,2,2,2,
- 2,2,2,2,2
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0
],
FlippingFlags = [
FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
@@ -57,7 +49,7 @@ public partial class TmxSerializerMapTests
FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
]
- },
+ }
}
]
};
diff --git a/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmj b/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmj
new file mode 100644
index 0000000..896df6c
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmj
@@ -0,0 +1,32 @@
+{ "compressionlevel":-1,
+ "height":5,
+ "infinite":false,
+ "layers":[
+ {
+ "data":[0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0],
+ "height":5,
+ "id":1,
+ "name":"Tile Layer 1",
+ "opacity":1,
+ "type":"tilelayer",
+ "visible":true,
+ "width":5,
+ "x":0,
+ "y":0
+ }],
+ "nextlayerid":2,
+ "nextobjectid":1,
+ "orientation":"orthogonal",
+ "renderorder":"right-down",
+ "tiledversion":"1.11.0",
+ "tileheight":32,
+ "tilesets":[],
+ "tilewidth":32,
+ "type":"map",
+ "version":"1.10",
+ "width":5
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-csv.tmx b/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmx
similarity index 100%
rename from DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-csv.tmx
rename to DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.tmx
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.cs b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.cs
new file mode 100644
index 0000000..24651b6
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.cs
@@ -0,0 +1,121 @@
+using System.Globalization;
+
+namespace DotTiled.Tests;
+
+public partial class TestData
+{
+ public static Map MapExternalTilesetMulti(string fileExt) => new Map
+ {
+ Class = "",
+ Orientation = MapOrientation.Orthogonal,
+ Width = 5,
+ Height = 5,
+ TileWidth = 32,
+ TileHeight = 32,
+ Infinite = false,
+ HexSideLength = null,
+ StaggerAxis = null,
+ StaggerIndex = null,
+ ParallaxOriginX = 0,
+ ParallaxOriginY = 0,
+ RenderOrder = RenderOrder.RightDown,
+ CompressionLevel = -1,
+ BackgroundColor = Color.Parse("#00000000", CultureInfo.InvariantCulture),
+ Version = "1.10",
+ TiledVersion = "1.11.0",
+ NextLayerID = 2,
+ NextObjectID = 1,
+ Tilesets = [
+ new Tileset
+ {
+ TileOffset = new TileOffset
+ {
+ X = 1,
+ Y = 5
+ },
+ Version = "1.10",
+ TiledVersion = "1.11.0",
+ FirstGID = 1,
+ Name = "multi-tileset",
+ TileWidth = 256,
+ TileHeight = 96,
+ TileCount = 2,
+ Columns = 0,
+ Source = $"multi-tileset.{(fileExt == "tmx" ? "tsx" : "tsj")}",
+ Grid = new Grid
+ {
+ Orientation = GridOrientation.Orthogonal,
+ Width = 1,
+ Height = 1
+ },
+ Properties = new Dictionary
+ {
+ ["tilesetbool"] = new BoolProperty { Name = "tilesetbool", Value = true },
+ ["tilesetcolor"] = new ColorProperty { Name = "tilesetcolor", Value = Color.Parse("#ffff0000", CultureInfo.InvariantCulture) },
+ ["tilesetfile"] = new FileProperty { Name = "tilesetfile", Value = "" },
+ ["tilesetfloat"] = new FloatProperty { Name = "tilesetfloat", Value = 5.2f },
+ ["tilesetint"] = new IntProperty { Name = "tilesetint", Value = 9 },
+ ["tilesetobject"] = new ObjectProperty { Name = "tilesetobject", Value = 0 },
+ ["tilesetstring"] = new StringProperty { Name = "tilesetstring", Value = "hello world!" }
+ },
+ Tiles = [
+ new Tile
+ {
+ ID = 0,
+ Width = 256,
+ Height = 96,
+ Image = new Image
+ {
+ Format = ImageFormat.Png,
+ Source = "tileset.png",
+ Width = 256,
+ Height = 96
+ }
+ },
+ new Tile
+ {
+ ID = 1,
+ Width = 256,
+ Height = 96,
+ Image = new Image
+ {
+ Format = ImageFormat.Png,
+ Source = "tileset.png",
+ Width = 256,
+ Height = 96
+ }
+ }
+ ]
+ }
+ ],
+ Layers = [
+ new TileLayer
+ {
+ ID = 1,
+ Name = "Tile Layer 1",
+ Width = 5,
+ Height = 5,
+ Data = new Data
+ {
+ Encoding = DataEncoding.Csv,
+ Chunks = null,
+ Compression = null,
+ GlobalTileIDs = [
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 2, 0, 0, 0
+ ],
+ FlippingFlags = [
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
+ ]
+ }
+ }
+ ]
+ };
+}
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.tmj b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.tmj
new file mode 100644
index 0000000..da37182
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.tmj
@@ -0,0 +1,36 @@
+{ "compressionlevel":-1,
+ "height":5,
+ "infinite":false,
+ "layers":[
+ {
+ "data":[0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 2, 0, 0, 0],
+ "height":5,
+ "id":1,
+ "name":"Tile Layer 1",
+ "opacity":1,
+ "type":"tilelayer",
+ "visible":true,
+ "width":5,
+ "x":0,
+ "y":0
+ }],
+ "nextlayerid":2,
+ "nextobjectid":1,
+ "orientation":"orthogonal",
+ "renderorder":"right-down",
+ "tiledversion":"1.11.0",
+ "tileheight":32,
+ "tilesets":[
+ {
+ "firstgid":1,
+ "source":"multi-tileset.tsj"
+ }],
+ "tilewidth":32,
+ "type":"map",
+ "version":"1.10",
+ "width":5
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.tmx
similarity index 66%
rename from DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx
rename to DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.tmx
index d35b438..477c112 100644
--- a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-base64-zlib.tmx
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.tmx
@@ -1,8 +1,13 @@
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/multi-tileset.tsj b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/multi-tileset.tsj
new file mode 100644
index 0000000..d190934
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/multi-tileset.tsj
@@ -0,0 +1,71 @@
+{ "columns":0,
+ "grid":
+ {
+ "height":1,
+ "orientation":"orthogonal",
+ "width":1
+ },
+ "margin":0,
+ "name":"multi-tileset",
+ "properties":[
+ {
+ "name":"tilesetbool",
+ "type":"bool",
+ "value":true
+ },
+ {
+ "name":"tilesetcolor",
+ "type":"color",
+ "value":"#ffff0000"
+ },
+ {
+ "name":"tilesetfile",
+ "type":"file",
+ "value":""
+ },
+ {
+ "name":"tilesetfloat",
+ "type":"float",
+ "value":5.2
+ },
+ {
+ "name":"tilesetint",
+ "type":"int",
+ "value":9
+ },
+ {
+ "name":"tilesetobject",
+ "type":"object",
+ "value":0
+ },
+ {
+ "name":"tilesetstring",
+ "type":"string",
+ "value":"hello world!"
+ }],
+ "spacing":0,
+ "tilecount":2,
+ "tiledversion":"1.11.0",
+ "tileheight":96,
+ "tileoffset":
+ {
+ "x":1,
+ "y":5
+ },
+ "tiles":[
+ {
+ "id":0,
+ "image":"tileset.png",
+ "imageheight":96,
+ "imagewidth":256
+ },
+ {
+ "id":1,
+ "image":"tileset.png",
+ "imageheight":96,
+ "imagewidth":256
+ }],
+ "tilewidth":256,
+ "type":"tileset",
+ "version":"1.10"
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/multi-tileset.tsx b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/multi-tileset.tsx
new file mode 100644
index 0000000..a28bfac
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/multi-tileset.tsx
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/tileset.png b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/tileset.png
new file mode 100644
index 0000000..97c1fb3
Binary files /dev/null and b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/tileset.png differ
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.cs b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.cs
new file mode 100644
index 0000000..9aaa7d7
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.cs
@@ -0,0 +1,92 @@
+using System.Globalization;
+
+namespace DotTiled.Tests;
+
+public partial class TestData
+{
+ public static Map MapExternalTilesetWangset(string fileExt) => new Map
+ {
+ Class = "",
+ Orientation = MapOrientation.Orthogonal,
+ Width = 5,
+ Height = 5,
+ TileWidth = 24,
+ TileHeight = 24,
+ Infinite = false,
+ HexSideLength = null,
+ StaggerAxis = null,
+ StaggerIndex = null,
+ ParallaxOriginX = 0,
+ ParallaxOriginY = 0,
+ RenderOrder = RenderOrder.RightDown,
+ CompressionLevel = -1,
+ BackgroundColor = Color.Parse("#00000000", CultureInfo.InvariantCulture),
+ Version = "1.10",
+ TiledVersion = "1.11.0",
+ NextLayerID = 2,
+ NextObjectID = 1,
+ Tilesets = [
+ new Tileset
+ {
+ Version = "1.10",
+ TiledVersion = "1.11.0",
+ FirstGID = 1,
+ Name = "tileset",
+ TileWidth = 24,
+ TileHeight = 24,
+ TileCount = 48,
+ Columns = 10,
+ Source = $"wangset-tileset.{(fileExt == "tmx" ? "tsx" : "tsj")}",
+ Transformations = new Transformations
+ {
+ HFlip = true,
+ VFlip = true,
+ Rotate = false,
+ PreferUntransformed = false
+ },
+ Grid = new Grid
+ {
+ Orientation = GridOrientation.Orthogonal,
+ Width = 32,
+ Height = 32
+ },
+ Image = new Image
+ {
+ Format = ImageFormat.Png,
+ Source = "tileset.png",
+ Width = 256,
+ Height = 96,
+ }
+ }
+ ],
+ Layers = [
+ new TileLayer
+ {
+ ID = 1,
+ Name = "Tile Layer 1",
+ Width = 5,
+ Height = 5,
+ Data = new Data
+ {
+ Encoding = DataEncoding.Csv,
+ Chunks = null,
+ Compression = null,
+ GlobalTileIDs = [
+ 2, 2, 12, 11, 0,
+ 1, 12, 1, 11, 0,
+ 2, 1, 0, 1, 0,
+ 12, 11, 12, 2, 0,
+ 0, 0, 0, 0, 0
+ ],
+ FlippingFlags = [
+ FlippingFlags.FlippedHorizontally, FlippingFlags.None, FlippingFlags.FlippedHorizontally, FlippingFlags.FlippedHorizontally, FlippingFlags.None,
+ FlippingFlags.FlippedVertically, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedVertically | FlippingFlags.FlippedHorizontally, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedVertically | FlippingFlags.FlippedHorizontally, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedHorizontally, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
+ ]
+ }
+ }
+ ]
+ };
+}
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.tmj b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.tmj
new file mode 100644
index 0000000..cea9ad6
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.tmj
@@ -0,0 +1,36 @@
+{ "compressionlevel":-1,
+ "height":5,
+ "infinite":false,
+ "layers":[
+ {
+ "data":[2147483650, 2, 2147483660, 2147483659, 0,
+ 1073741825, 12, 1, 3221225483, 0,
+ 2, 1, 0, 3221225473, 0,
+ 12, 11, 12, 2147483650, 0,
+ 0, 0, 0, 0, 0],
+ "height":5,
+ "id":1,
+ "name":"Tile Layer 1",
+ "opacity":1,
+ "type":"tilelayer",
+ "visible":true,
+ "width":5,
+ "x":0,
+ "y":0
+ }],
+ "nextlayerid":2,
+ "nextobjectid":1,
+ "orientation":"orthogonal",
+ "renderorder":"right-down",
+ "tiledversion":"1.11.0",
+ "tileheight":24,
+ "tilesets":[
+ {
+ "firstgid":1,
+ "source":"wangset-tileset.tsj"
+ }],
+ "tilewidth":24,
+ "type":"map",
+ "version":"1.10",
+ "width":5
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.tmx b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.tmx
new file mode 100644
index 0000000..656fddb
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.tmx
@@ -0,0 +1,13 @@
+
+
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/tileset.png b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/tileset.png
new file mode 100644
index 0000000..97c1fb3
Binary files /dev/null and b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/tileset.png differ
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/wangset-tileset.tsj b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/wangset-tileset.tsj
new file mode 100644
index 0000000..511641a
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/wangset-tileset.tsj
@@ -0,0 +1,69 @@
+{ "columns":10,
+ "grid":
+ {
+ "height":32,
+ "orientation":"orthogonal",
+ "width":32
+ },
+ "image":"tileset.png",
+ "imageheight":96,
+ "imagewidth":256,
+ "margin":0,
+ "name":"tileset",
+ "spacing":0,
+ "tilecount":48,
+ "tiledversion":"1.11.0",
+ "tileheight":24,
+ "tilewidth":24,
+ "transformations":
+ {
+ "hflip":true,
+ "preferuntransformed":false,
+ "rotate":false,
+ "vflip":true
+ },
+ "type":"tileset",
+ "version":"1.10",
+ "wangsets":[
+ {
+ "colors":[
+ {
+ "color":"#ff0000",
+ "name":"Water",
+ "probability":1,
+ "tile":0
+ },
+ {
+ "color":"#00ff00",
+ "name":"Grass",
+ "probability":1,
+ "tile":-1
+ },
+ {
+ "color":"#0000ff",
+ "name":"Stone",
+ "probability":1,
+ "tile":29
+ }],
+ "name":"test-terrain",
+ "tile":-1,
+ "type":"mixed",
+ "wangtiles":[
+ {
+ "tileid":0,
+ "wangid":[1, 1, 0, 0, 0, 1, 1, 1]
+ },
+ {
+ "tileid":1,
+ "wangid":[1, 1, 1, 1, 0, 0, 0, 1]
+ },
+ {
+ "tileid":10,
+ "wangid":[0, 0, 0, 1, 1, 1, 1, 1]
+ },
+ {
+ "tileid":11,
+ "wangid":[0, 1, 1, 1, 1, 1, 0, 0]
+ }]
+ }]
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/wangset-tileset.tsx b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/wangset-tileset.tsx
new file mode 100644
index 0000000..d2b8666
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/wangset-tileset.tsx
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.cs b/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.cs
new file mode 100644
index 0000000..8c3283e
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.cs
@@ -0,0 +1,68 @@
+using System.Globalization;
+
+namespace DotTiled.Tests;
+
+public partial class TestData
+{
+ public static Map MapWithCommonProps() => new Map
+ {
+ Class = "",
+ Orientation = MapOrientation.Isometric,
+ Width = 5,
+ Height = 5,
+ TileWidth = 32,
+ TileHeight = 16,
+ Infinite = false,
+ HexSideLength = null,
+ StaggerAxis = null,
+ StaggerIndex = null,
+ ParallaxOriginX = 0,
+ ParallaxOriginY = 0,
+ RenderOrder = RenderOrder.RightDown,
+ CompressionLevel = -1,
+ BackgroundColor = Color.Parse("#00ff00", CultureInfo.InvariantCulture),
+ Version = "1.10",
+ TiledVersion = "1.11.0",
+ NextLayerID = 2,
+ NextObjectID = 1,
+ Layers = [
+ new TileLayer
+ {
+ ID = 1,
+ Name = "Tile Layer 1",
+ Width = 5,
+ Height = 5,
+ Data = new Data
+ {
+ Encoding = DataEncoding.Csv,
+ Chunks = null,
+ Compression = null,
+ GlobalTileIDs = [
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0
+ ],
+ FlippingFlags = [
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
+ ]
+ }
+ }
+ ],
+ Properties = new Dictionary
+ {
+ ["boolprop"] = new BoolProperty { Name = "boolprop", Value = true },
+ ["colorprop"] = new ColorProperty { Name = "colorprop", Value = Color.Parse("#ff55ffff", CultureInfo.InvariantCulture) },
+ ["fileprop"] = new FileProperty { Name = "fileprop", Value = "file.txt" },
+ ["floatprop"] = new FloatProperty { Name = "floatprop", Value = 4.2f },
+ ["intprop"] = new IntProperty { Name = "intprop", Value = 8 },
+ ["objectprop"] = new ObjectProperty { Name = "objectprop", Value = 5 },
+ ["stringprop"] = new StringProperty { Name = "stringprop", Value = "This is a string, hello world!" }
+ }
+ };
+}
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.tmj b/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.tmj
new file mode 100644
index 0000000..c7182ef
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.tmj
@@ -0,0 +1,70 @@
+{ "backgroundcolor":"#00ff00",
+ "compressionlevel":-1,
+ "height":5,
+ "infinite":false,
+ "layers":[
+ {
+ "data":[0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0],
+ "height":5,
+ "id":1,
+ "name":"Tile Layer 1",
+ "opacity":1,
+ "type":"tilelayer",
+ "visible":true,
+ "width":5,
+ "x":0,
+ "y":0
+ }],
+ "nextlayerid":2,
+ "nextobjectid":1,
+ "orientation":"isometric",
+ "properties":[
+ {
+ "name":"boolprop",
+ "type":"bool",
+ "value":true
+ },
+ {
+ "name":"colorprop",
+ "type":"color",
+ "value":"#ff55ffff"
+ },
+ {
+ "name":"fileprop",
+ "type":"file",
+ "value":"file.txt"
+ },
+ {
+ "name":"floatprop",
+ "type":"float",
+ "value":4.2
+ },
+ {
+ "name":"intprop",
+ "type":"int",
+ "value":8
+ },
+
+ {
+ "name":"objectprop",
+ "type":"object",
+ "value":5
+ },
+ {
+ "name":"stringprop",
+ "type":"string",
+ "value":"This is a string, hello world!"
+ }],
+ "renderorder":"right-down",
+ "tiledversion":"1.11.0",
+ "tileheight":16,
+ "tilesets":[],
+ "tilewidth":32,
+ "type":"map",
+ "version":"1.10",
+ "width":5
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.tmx b/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.tmx
new file mode 100644
index 0000000..b4b36cd
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.tmx
@@ -0,0 +1,21 @@
+
+
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.cs b/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.cs
new file mode 100644
index 0000000..1343f62
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.cs
@@ -0,0 +1,122 @@
+using System.Globalization;
+
+namespace DotTiled.Tests;
+
+public partial class TestData
+{
+ public static Map MapWithCustomTypeProps() => new Map
+ {
+ Class = "",
+ Orientation = MapOrientation.Orthogonal,
+ Width = 5,
+ Height = 5,
+ TileWidth = 32,
+ TileHeight = 32,
+ Infinite = false,
+ HexSideLength = null,
+ StaggerAxis = null,
+ StaggerIndex = null,
+ ParallaxOriginX = 0,
+ ParallaxOriginY = 0,
+ RenderOrder = RenderOrder.RightDown,
+ CompressionLevel = -1,
+ BackgroundColor = Color.Parse("#00000000", CultureInfo.InvariantCulture),
+ Version = "1.10",
+ TiledVersion = "1.11.0",
+ NextLayerID = 2,
+ NextObjectID = 1,
+ Layers = [
+ new TileLayer
+ {
+ ID = 1,
+ Name = "Tile Layer 1",
+ Width = 5,
+ Height = 5,
+ Data = new Data
+ {
+ Encoding = DataEncoding.Csv,
+ Chunks = null,
+ Compression = null,
+ GlobalTileIDs = [
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0
+ ],
+ FlippingFlags = [
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None,
+ FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None
+ ]
+ }
+ }
+ ],
+ Properties = new Dictionary
+ {
+ ["customclassprop"] = new ClassProperty
+ {
+ Name = "customclassprop",
+ PropertyType = "CustomClass",
+ Properties = new Dictionary
+ {
+ ["boolinclass"] = new BoolProperty { Name = "boolinclass", Value = true },
+ ["colorinclass"] = new ColorProperty { Name = "colorinclass", Value = Color.Parse("#000000ff", CultureInfo.InvariantCulture) },
+ ["fileinclass"] = new FileProperty { Name = "fileinclass", Value = "" },
+ ["floatinclass"] = new FloatProperty { Name = "floatinclass", Value = 13.37f },
+ ["intinclass"] = new IntProperty { Name = "intinclass", Value = 0 },
+ ["objectinclass"] = new ObjectProperty { Name = "objectinclass", Value = 0 },
+ ["stringinclass"] = new StringProperty { Name = "stringinclass", Value = "This is a set string" }
+ }
+ }
+ }
+ };
+
+ // This comes from map-with-custom-type-props/propertytypes.json
+ public static IReadOnlyCollection MapWithCustomTypePropsCustomTypeDefinitions() => [
+ new CustomClassDefinition
+ {
+ Name = "CustomClass",
+ UseAs = CustomClassUseAs.Property,
+ Members = [
+ new BoolProperty
+ {
+ Name = "boolinclass",
+ Value = false
+ },
+ new ColorProperty
+ {
+ Name = "colorinclass",
+ Value = Color.Parse("#000000ff", CultureInfo.InvariantCulture)
+ },
+ new FileProperty
+ {
+ Name = "fileinclass",
+ Value = ""
+ },
+ new FloatProperty
+ {
+ Name = "floatinclass",
+ Value = 0f
+ },
+ new IntProperty
+ {
+ Name = "intinclass",
+ Value = 0
+ },
+ new ObjectProperty
+ {
+ Name = "objectinclass",
+ Value = 0
+ },
+ new StringProperty
+ {
+ Name = "stringinclass",
+ Value = ""
+ }
+ ]
+ }
+ ];
+}
diff --git a/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.tmj b/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.tmj
new file mode 100644
index 0000000..a8c7f43
--- /dev/null
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.tmj
@@ -0,0 +1,44 @@
+{ "compressionlevel":-1,
+ "height":5,
+ "infinite":false,
+ "layers":[
+ {
+ "data":[0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0],
+ "height":5,
+ "id":1,
+ "name":"Tile Layer 1",
+ "opacity":1,
+ "type":"tilelayer",
+ "visible":true,
+ "width":5,
+ "x":0,
+ "y":0
+ }],
+ "nextlayerid":2,
+ "nextobjectid":1,
+ "orientation":"orthogonal",
+ "properties":[
+ {
+ "name":"customclassprop",
+ "propertytype":"CustomClass",
+ "type":"class",
+ "value":
+ {
+ "boolinclass":true,
+ "floatinclass":13.37,
+ "stringinclass":"This is a set string"
+ }
+ }],
+ "renderorder":"right-down",
+ "tiledversion":"1.11.0",
+ "tileheight":32,
+ "tilesets":[],
+ "tilewidth":32,
+ "type":"map",
+ "version":"1.10",
+ "width":5
+}
\ No newline at end of file
diff --git a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx b/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.tmx
similarity index 50%
rename from DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx
rename to DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.tmx
index 5a14d94..c364577 100644
--- a/DotTiled.Tests/TmxSerializer/TestData/Map/empty-map-properties.tmx
+++ b/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.tmx
@@ -1,13 +1,13 @@