No more TmxSerializer, now different readers for each file format

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);
+    Assert.Equal(expected.Encoding, actual.Encoding);
+    Assert.Equal(expected.Compression, actual.Compression);
+
+    // Data
+    Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs);
+    Assert.Equal(expected.FlippingFlags, actual.FlippingFlags);
+
+    if (expected.Chunks is not null)
+    {
+      Assert.NotNull(actual.Chunks);
+      Assert.Equal(expected.Chunks.Length, actual.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
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+
+    // Data
+    Assert.Equal(expected.GlobalTileIDs, actual.GlobalTileIDs);
+    Assert.Equal(expected.FlippingFlags, actual.FlippingFlags);
+  }
+}

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);
+    Assert.Equal(expected.Format, actual.Format);
+    Assert.Equal(expected.Source, actual.Source);
+    Assert.Equal(expected.TransparentColor, actual.TransparentColor);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+  }
+}

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);
+    Assert.Equal(expected.ID, actual.ID);
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.Opacity, actual.Opacity);
+    Assert.Equal(expected.Visible, actual.Visible);
+    Assert.Equal(expected.TintColor, actual.TintColor);
+    Assert.Equal(expected.OffsetX, actual.OffsetX);
+    Assert.Equal(expected.OffsetY, actual.OffsetY);
+    Assert.Equal(expected.ParallaxX, actual.ParallaxX);
+    Assert.Equal(expected.ParallaxY, actual.ParallaxY);
+
+    AssertProperties(expected.Properties, actual.Properties);
+    AssertLayer((dynamic)expected, (dynamic)actual);
+  }
+
+  private static void AssertLayer(TileLayer expected, TileLayer actual)
+  {
+    // Attributes
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+
+    Assert.NotNull(actual.Data);
+    AssertData(expected.Data, actual.Data);
+  }
+
+  private static void AssertLayer(ObjectLayer expected, ObjectLayer actual)
+  {
+    // Attributes
+    Assert.Equal(expected.DrawOrder, actual.DrawOrder);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+
+    Assert.NotNull(actual.Objects);
+    Assert.Equal(expected.Objects.Count, actual.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
+    Assert.Equal(expected.RepeatX, actual.RepeatX);
+    Assert.Equal(expected.RepeatY, actual.RepeatY);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+
+    Assert.NotNull(actual.Image);
+    AssertImage(expected.Image, actual.Image);
+  }
+
+  private static void AssertLayer(Group expected, Group actual)
+  {
+    // Attributes
+    Assert.NotNull(actual.Layers);
+    Assert.Equal(expected.Layers.Count, actual.Layers.Count);
+    for (var i = 0; i < expected.Layers.Count; i++)
+      AssertLayer(expected.Layers[i], actual.Layers[i]);
+  }
+}

DotTiled.Tests/Assert/AssertMap.cs

@@ -0,0 +1,40 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+  internal static void AssertMap(Map expected, Map actual)
+  {
+    // Attributes
+    Assert.Equal(expected.Version, actual.Version);
+    Assert.Equal(expected.TiledVersion, actual.TiledVersion);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.Orientation, actual.Orientation);
+    Assert.Equal(expected.RenderOrder, actual.RenderOrder);
+    Assert.Equal(expected.CompressionLevel, actual.CompressionLevel);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+    Assert.Equal(expected.TileWidth, actual.TileWidth);
+    Assert.Equal(expected.TileHeight, actual.TileHeight);
+    Assert.Equal(expected.HexSideLength, actual.HexSideLength);
+    Assert.Equal(expected.StaggerAxis, actual.StaggerAxis);
+    Assert.Equal(expected.StaggerIndex, actual.StaggerIndex);
+    Assert.Equal(expected.ParallaxOriginX, actual.ParallaxOriginX);
+    Assert.Equal(expected.ParallaxOriginY, actual.ParallaxOriginY);
+    Assert.Equal(expected.BackgroundColor, actual.BackgroundColor);
+    Assert.Equal(expected.NextLayerID, actual.NextLayerID);
+    Assert.Equal(expected.NextObjectID, actual.NextObjectID);
+    Assert.Equal(expected.Infinite, actual.Infinite);
+
+    AssertProperties(actual.Properties, expected.Properties);
+
+    Assert.NotNull(actual.Tilesets);
+    Assert.Equal(expected.Tilesets.Count, actual.Tilesets.Count);
+    for (var i = 0; i < expected.Tilesets.Count; i++)
+      AssertTileset(actual.Tilesets[i], expected.Tilesets[i]);
+
+    Assert.NotNull(actual.Layers);
+    Assert.Equal(expected.Layers.Count, actual.Layers.Count);
+    for (var i = 0; i < expected.Layers.Count; i++)
+      AssertLayer(actual.Layers[i], expected.Layers[i]);
+  }
+}

DotTiled.Tests/Assert/AssertObject.cs

@@ -0,0 +1,66 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+  internal static void AssertObject(Object expected, Object actual)
+  {
+    // Attributes
+    Assert.Equal(expected.ID, actual.ID);
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Type, actual.Type);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+    Assert.Equal(expected.Rotation, actual.Rotation);
+    Assert.Equal(expected.GID, actual.GID);
+    Assert.Equal(expected.Visible, actual.Visible);
+    Assert.Equal(expected.Template, actual.Template);
+
+    AssertProperties(actual.Properties, expected.Properties);
+    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)
+  {
+    Assert.Equal(expected.Points, actual.Points);
+  }
+
+  private static void AssertObject(PolylineObject expected, PolylineObject actual)
+  {
+    Assert.Equal(expected.Points, actual.Points);
+  }
+
+  private static void AssertObject(TextObject expected, TextObject actual)
+  {
+    // Attributes
+    Assert.Equal(expected.FontFamily, actual.FontFamily);
+    Assert.Equal(expected.PixelSize, actual.PixelSize);
+    Assert.Equal(expected.Wrap, actual.Wrap);
+    Assert.Equal(expected.Color, actual.Color);
+    Assert.Equal(expected.Bold, actual.Bold);
+    Assert.Equal(expected.Italic, actual.Italic);
+    Assert.Equal(expected.Underline, actual.Underline);
+    Assert.Equal(expected.Strikeout, actual.Strikeout);
+    Assert.Equal(expected.Kerning, actual.Kerning);
+    Assert.Equal(expected.HorizontalAlignment, actual.HorizontalAlignment);
+    Assert.Equal(expected.VerticalAlignment, actual.VerticalAlignment);
+
+    Assert.Equal(expected.Text, actual.Text);
+  }
+}

DotTiled.Tests/Assert/AssertProperties.cs

@@ -0,0 +1,69 @@
+namespace DotTiled.Tests;
+
+public static partial class DotTiledAssert
+{
+  internal static void AssertProperties(Dictionary<string, IProperty>? expected, Dictionary<string, IProperty>? actual)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    Assert.NotNull(actual);
+    Assert.Equal(expected.Count, actual.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 actual, IProperty expected)
+  {
+    Assert.Equal(expected.Type, actual.Type);
+    Assert.Equal(expected.Name, actual.Name);
+    AssertProperties((dynamic)actual, (dynamic)expected);
+  }
+
+  private static void AssertProperty(StringProperty actual, StringProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(IntProperty actual, IntProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(FloatProperty actual, FloatProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(BoolProperty actual, BoolProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(ColorProperty actual, ColorProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(FileProperty actual, FileProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(ObjectProperty actual, ObjectProperty expected)
+  {
+    Assert.Equal(expected.Value, actual.Value);
+  }
+
+  private static void AssertProperty(ClassProperty actual, ClassProperty expected)
+  {
+    Assert.Equal(expected.PropertyType, actual.PropertyType);
+    AssertProperties(actual.Properties, expected.Properties);
+  }
+}

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
+    Assert.Equal(expected.Version, actual.Version);
+    Assert.Equal(expected.TiledVersion, actual.TiledVersion);
+    Assert.Equal(expected.FirstGID, actual.FirstGID);
+    Assert.Equal(expected.Source, actual.Source);
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.TileWidth, actual.TileWidth);
+    Assert.Equal(expected.TileHeight, actual.TileHeight);
+    Assert.Equal(expected.Spacing, actual.Spacing);
+    Assert.Equal(expected.Margin, actual.Margin);
+    Assert.Equal(expected.TileCount, actual.TileCount);
+    Assert.Equal(expected.Columns, actual.Columns);
+    Assert.Equal(expected.ObjectAlignment, actual.ObjectAlignment);
+    Assert.Equal(expected.RenderSize, actual.RenderSize);
+    Assert.Equal(expected.FillMode, actual.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);
+      Assert.Equal(expected.Wangsets.Count, actual.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);
+    Assert.Equal(expected.Tiles.Count, actual.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);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+  }
+
+  private static void AssertGrid(Grid? expected, Grid? actual)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.Orientation, actual.Orientation);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.Height);
+  }
+
+  private static void AssertWangset(Wangset expected, Wangset actual)
+  {
+    // Attributes
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.Tile, actual.Tile);
+
+    // At most one of
+    AssertProperties(expected.Properties, actual.Properties);
+    if (expected.WangColors is not null)
+    {
+      Assert.NotNull(actual.WangColors);
+      Assert.Equal(expected.WangColors.Count, actual.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
+    Assert.Equal(expected.Name, actual.Name);
+    Assert.Equal(expected.Class, actual.Class);
+    Assert.Equal(expected.Color, actual.Color);
+    Assert.Equal(expected.Tile, actual.Tile);
+    Assert.Equal(expected.Probability, actual.Probability);
+
+    AssertProperties(expected.Properties, actual.Properties);
+  }
+
+  private static void AssertWangTile(WangTile expected, WangTile actual)
+  {
+    // Attributes
+    Assert.Equal(expected.TileID, actual.TileID);
+    Assert.Equal(expected.WangID, actual.WangID);
+  }
+
+  private static void AssertTransformations(Transformations? expected, Transformations? actual)
+  {
+    if (expected is null)
+    {
+      Assert.Null(actual);
+      return;
+    }
+
+    // Attributes
+    Assert.NotNull(actual);
+    Assert.Equal(expected.HFlip, actual.HFlip);
+    Assert.Equal(expected.VFlip, actual.VFlip);
+    Assert.Equal(expected.Rotate, actual.Rotate);
+    Assert.Equal(expected.PreferUntransformed, actual.PreferUntransformed);
+  }
+
+  private static void AssertTile(Tile expected, Tile actual)
+  {
+    // Attributes
+    Assert.Equal(expected.ID, actual.ID);
+    Assert.Equal(expected.Type, actual.Type);
+    Assert.Equal(expected.Probability, actual.Probability);
+    Assert.Equal(expected.X, actual.X);
+    Assert.Equal(expected.Y, actual.Y);
+    Assert.Equal(expected.Width, actual.Width);
+    Assert.Equal(expected.Height, actual.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);
+      Assert.Equal(expected.Animation.Count, actual.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
+    Assert.Equal(expected.TileID, actual.TileID);
+    Assert.Equal(expected.Duration, actual.Duration);
+  }
+}