jussi/DotTiled
1
0
Fork 0
mirror of https://github.com/dcronqvist/DotTiled.git synced 2025-05-09 02:26:02 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Model now uses Optional correctly, I think, massive changes

Browse source
This commit is contained in:
Daniel Cronqvist 2024-09-01 20:44:36 +02:00
parent 39d2838663
commit 88a5eadb74
42 changed files with 1106 additions and 400 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/DotTiled.Tests/Assert/AssertData.cs
View file

@ -19,12 +19,11 @@ public static partial class DotTiledAssert
AssertEqual(expected.GlobalTileIDs, actual.GlobalTileIDs, nameof(Data.GlobalTileIDs));
AssertEqual(expected.FlippingFlags, actual.FlippingFlags, nameof(Data.FlippingFlags));
if (expected.Chunks is not null)
if (expected.Chunks.HasValue)
{
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]);
AssertEqual(expected.Chunks.Value.Length, actual.Chunks.Value.Length, "Chunks.Length");
for (var i = 0; i < expected.Chunks.Value.Length; i++)
AssertChunk(expected.Chunks.Value[i], actual.Chunks.Value[i]);
}
}

62
src/DotTiled.Tests/Assert/AssertMap.cs
View file

@ -5,6 +5,68 @@ namespace DotTiled.Tests;
public static partial class DotTiledAssert
{
private static void AssertListOrdered<T>(IList<T> expected, IList<T> actual, string nameof, Action<T, T> assertEqual = null)
{
if (expected is null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
AssertEqual(expected.Count, actual.Count, $"{nameof}.Count");
for (var i = 0; i < expected.Count; i++)
{
if (assertEqual is not null)
{
assertEqual(expected[i], actual[i]);
continue;
}
AssertEqual(expected[i], actual[i], $"{nameof}[{i}]");
}
}
private static void AssertOptionalsEqual<T>(
Optional<T> expected,
Optional<T> actual,
string nameof,
Action<T, T> assertEqual)
{
if (expected is null)
{
Assert.Null(actual);
return;
}
if (expected.HasValue)
{
Assert.True(actual.HasValue, $"Expected {nameof} to have a value");
assertEqual(expected.Value, actual.Value);
return;
}
Assert.False(actual.HasValue, $"Expected {nameof} to not have a value");
}
private static void AssertEqual<T>(Optional<T> expected, Optional<T> actual, string nameof)
{
if (expected is null)
{
Assert.Null(actual);
return;
}
if (expected.HasValue)
{
Assert.True(actual.HasValue, $"Expected {nameof} to have a value");
AssertEqual(expected.Value, actual.Value, nameof);
return;
}
Assert.False(actual.HasValue, $"Expected {nameof} to not have a value");
}
private static void AssertEqual<T>(T expected, T actual, string nameof)
{
if (expected == null)

59
src/DotTiled.Tests/Assert/AssertTileset.cs
View file

@ -4,7 +4,6 @@ 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));
@ -21,29 +20,16 @@ public static partial class DotTiledAssert
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);
AssertOptionalsEqual(expected.Image, actual.Image, nameof(Tileset.Image), AssertImage);
AssertOptionalsEqual(expected.TileOffset, actual.TileOffset, nameof(Tileset.TileOffset), AssertTileOffset);
AssertOptionalsEqual(expected.Grid, actual.Grid, nameof(Tileset.Grid), AssertGrid);
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]);
AssertListOrdered(expected.Wangsets, actual.Wangsets, nameof(Tileset.Wangsets), AssertWangset);
AssertOptionalsEqual(expected.Transformations, actual.Transformations, nameof(Tileset.Transformations), AssertTransformations);
AssertListOrdered(expected.Tiles, actual.Tiles, nameof(Tileset.Tiles), AssertTile);
}
private static void AssertTileOffset(TileOffset? expected, TileOffset? actual)
private static void AssertTileOffset(TileOffset expected, TileOffset actual)
{
if (expected is null)
{
@ -74,27 +60,17 @@ public static partial class DotTiledAssert
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]);
AssertListOrdered(expected.WangColors, actual.WangColors, nameof(Wangset.WangColors), AssertWangColor);
AssertListOrdered(expected.WangTiles, actual.WangTiles, nameof(Wangset.WangTiles), AssertWangTile);
}
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));
@ -106,7 +82,6 @@ public static partial class DotTiledAssert
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));
}
@ -119,7 +94,6 @@ public static partial class DotTiledAssert
return;
}
// Attributes
Assert.NotNull(actual);
AssertEqual(expected.HFlip, actual.HFlip, nameof(Transformations.HFlip));
AssertEqual(expected.VFlip, actual.VFlip, nameof(Transformations.VFlip));
@ -129,7 +103,6 @@ public static partial class DotTiledAssert
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));
@ -138,22 +111,14 @@ public static partial class DotTiledAssert
AssertEqual(expected.Width, actual.Width, nameof(Tile.Width));
AssertEqual(expected.Height, actual.Height, nameof(Tile.Height));
// Elements
AssertProperties(expected.Properties, actual.Properties);
AssertImage(expected.Image, actual.Image);
AssertLayer((BaseLayer?)expected.ObjectLayer, (BaseLayer?)actual.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]);
}
AssertOptionalsEqual(expected.Image, actual.Image, nameof(Tile.Image), AssertImage);
AssertOptionalsEqual(expected.ObjectLayer, actual.ObjectLayer, nameof(Tile.ObjectLayer), (a, b) => AssertLayer((BaseLayer)a, (BaseLayer)b));
AssertListOrdered(expected.Animation, actual.Animation, nameof(Tile.Animation), AssertFrame);
}
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));
}

1
src/DotTiled.Tests/DotTiled.Tests.csproj
View file

@ -3,7 +3,6 @@
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>

520
src/DotTiled.Tests/OptionalTests.cs Normal file
View file

@ -0,0 +1,520 @@
namespace DotTiled.Tests;
// public class OptionalTests
// {
// [Fact]
// public void HasValue_WhenValueIsSet_ReturnsTrue()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act & Assert
// Assert.True(optional.HasValue);
// }
// [Fact]
// public void HasValue_WhenValueIsNotSet_ReturnsFalse()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act & Assert
// Assert.False(optional.HasValue);
// }
// [Fact]
// public void Value_WhenValueIsSet_ReturnsValue()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var value = optional.Value;
// // Assert
// Assert.Equal(42, value);
// }
// [Fact]
// public void Value_WhenValueIsNotSet_ThrowsInvalidOperationException()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act & Assert
// _ = Assert.Throws<InvalidOperationException>(() => optional.Value);
// }
// [Fact]
// public void ImplicitConversionFromValue_CreatesOptionalWithValue()
// {
// // Arrange
// Optional<int> optional = 42;
// // Act & Assert
// Assert.True(optional.HasValue);
// Assert.Equal(42, optional.Value);
// }
// [Fact]
// public void ImplicitConversionToValue_ReturnsValue()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// int value = optional;
// // Assert
// Assert.Equal(42, value);
// }
// [Fact]
// public void ToString_WhenValueIsSet_ReturnsValueToString()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.ToString();
// // Assert
// Assert.Equal("42", result);
// }
// [Fact]
// public void ToString_WhenValueIsNotSet_ReturnsEmpty()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act
// var result = optional.ToString();
// // Assert
// Assert.Equal("Empty", result);
// }
// [Fact]
// public void Equals_WithObject_ReturnsTrueWhenValueIsEqual()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.Equals(42);
// // Assert
// Assert.True(result);
// }
// [Fact]
// public void Equals_WithObject_ReturnsFalseWhenValueIsNotEqual()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.Equals(43);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void Equals_WithObject_ReturnsFalseWhenValueIsNotSet()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act
// var result = optional.Equals(42);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void Equals_WithOptional_ReturnsTrueWhenValueIsEqual()
// {
// // Arrange
// var optional1 = new Optional<int>(42);
// var optional2 = new Optional<int>(42);
// // Act
// var result = optional1.Equals(optional2);
// // Assert
// Assert.True(result);
// }
// [Fact]
// public void Equals_WithOptional_ReturnsFalseWhenValueIsNotEqual()
// {
// // Arrange
// var optional1 = new Optional<int>(42);
// var optional2 = new Optional<int>(43);
// // Act
// var result = optional1.Equals(optional2);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void Equals_WithOptional_ReturnsFalseWhenValueIsNotSet()
// {
// // Arrange
// var optional1 = new Optional<int>();
// var optional2 = new Optional<int>(42);
// // Act
// var result = optional1.Equals(optional2);
// // Assert
// Assert.False(result);
// }
// [Fact]
// public void GetHashCode_WhenValueIsSet_ReturnsValueHashCode()
// {
// // Arrange
// var optional = new Optional<int>(42);
// // Act
// var result = optional.GetHashCode();
// // Assert
// Assert.Equal(42.GetHashCode(), result);
// }
// [Fact]
// public void GetHashCode_WhenValueIsNotSet_ReturnsZero()
// {
// // Arrange
// var optional = new Optional<int>();
// // Act
// var result = optional.GetHashCode();
// // Assert
// Assert.Equal(0, result);
// }
// }
public class OptionalTests
{
// Constructor Tests
[Fact]
public void Constructor_WithNonNullValue_ShouldSetHasValueToTrue()
{
// Arrange
string expectedValue = "test";
// Act
var optional = new Optional<string>(expectedValue);
// Assert
Assert.True(optional.HasValue);
Assert.Equal(expectedValue, optional.Value);
}
[Fact]
public void Constructor_WithNullValue_ShouldSetHasValueToTrue()
{
// Arrange
string expectedValue = null;
// Act
var optional = new Optional<string>(expectedValue);
// Assert
Assert.True(optional.HasValue);
Assert.Null(optional.Value);
}
[Fact]
public void DefaultConstructor_ShouldSetHasValueToFalse()
{
// Arrange & Act
var optional = new Optional<string>();
// Assert
Assert.False(optional.HasValue);
_ = Assert.Throws<InvalidOperationException>(() => optional.Value);
}
// Implicit Conversion Tests
[Fact]
public void ImplicitConversion_FromValueToOptional_ShouldSetHasValueToTrue()
{
// Arrange
int expectedValue = 5;
// Act
Optional<int> optional = expectedValue;
// Assert
Assert.True(optional.HasValue);
Assert.Equal(expectedValue, optional.Value);
}
[Fact]
public void ImplicitConversion_FromOptionalToValue_ShouldReturnValue_WhenHasValueIsTrue()
{
// Arrange
int expectedValue = 10;
var optional = new Optional<int>(expectedValue);
// Act
int value = optional;
// Assert
Assert.Equal(expectedValue, value);
}
[Fact]
public void ImplicitConversion_FromOptionalToValue_ShouldThrowException_WhenHasValueIsFalse()
{
// Arrange
var optional = new Optional<int>();
// Act & Assert
_ = Assert.Throws<InvalidOperationException>(() => { int value = optional; });
}
// ToString Method Tests
[Fact]
public void ToString_WithValue_ShouldReturnValueToString()
{
// Arrange
int expectedValue = 42;
var optional = new Optional<int>(expectedValue);
// Act
string result = optional.ToString();
// Assert
#pragma warning disable CA1305 // Specify IFormatProvider
Assert.Equal(expectedValue.ToString(), result);
#pragma warning restore CA1305 // Specify IFormatProvider
}
[Fact]
public void ToString_WithoutValue_ShouldReturnEmpty()
{
// Arrange & Act
var optional = new Optional<int>();
string result = optional.ToString();
// Assert
Assert.Equal("Empty", result);
}
// Equality Tests
[Fact]
public void Equals_WithSameValue_ShouldReturnTrue()
{
// Arrange
var optional1 = new Optional<int>(10);
var optional2 = new Optional<int>(10);
// Act
bool areEqual = optional1.Equals(optional2);
// Assert
Assert.True(areEqual);
}
[Fact]
public void Equals_WithDifferentValues_ShouldReturnFalse()
{
// Arrange
var optional1 = new Optional<int>(10);
var optional2 = new Optional<int>(20);
// Act
bool areEqual = optional1.Equals(optional2);
// Assert
Assert.False(areEqual);
}
[Fact]
public void Equals_WithNull_ShouldReturnFalse()
{
// Arrange
var optional = new Optional<string>("test");
// Act
bool areEqual = optional.Equals(null);
// Assert
Assert.False(areEqual);
}
[Fact]
public void Equals_WithEmptyOptional_ShouldReturnTrue()
{
// Arrange
var optional1 = new Optional<string>();
var optional2 = new Optional<string>();
// Act
bool areEqual = optional1.Equals(optional2);
// Assert
Assert.True(areEqual);
}
[Fact]
public void Equals_WithSameReferenceTypeValue_ShouldReturnTrue()
{
// Arrange
var value = new object();
var optional1 = new Optional<object>(value);
var optional2 = new Optional<object>(value);
// Act
bool areEqual = optional1.Equals(optional2);
// Assert
Assert.True(areEqual);
}
[Fact]
public void Equals_WithDifferentReferenceTypeValues_ShouldReturnFalse()
{
// Arrange
var optional1 = new Optional<object>(new object());
var optional2 = new Optional<object>(new object());
// Act
bool areEqual = optional1.Equals(optional2);
// Assert
Assert.False(areEqual);
}
// GetHashCode Method Tests
[Fact]
public void GetHashCode_WithValue_ShouldReturnValueHashCode()
{
// Arrange
int value = 42;
var optional = new Optional<int>(value);
// Act
int hashCode = optional.GetHashCode();
// Assert
Assert.Equal(value.GetHashCode(), hashCode);
}
[Fact]
public void GetHashCode_WithoutValue_ShouldReturnZero()
{
// Arrange & Act
var optional = new Optional<int>();
int hashCode = optional.GetHashCode();
// Assert
Assert.Equal(0, hashCode);
}
// Exception Tests
[Fact]
public void Value_WhenHasValueIsFalse_ShouldThrowInvalidOperationException()
{
// Arrange
var optional = new Optional<string>();
// Act & Assert
_ = Assert.Throws<InvalidOperationException>(() => optional.Value);
}
[Fact]
public void ImplicitConversion_WhenHasValueIsFalse_ShouldThrowInvalidOperationException()
{
// Arrange
var optional = new Optional<int>();
// Act & Assert
_ = Assert.Throws<InvalidOperationException>(() => { int value = optional; });
}
// Edge Cases
[Fact]
public void EmptyOptionalEquality_ShouldReturnTrue()
{
// Arrange
var optional1 = new Optional<int>();
var optional2 = new Optional<int>();
// Act
bool areEqual = optional1.Equals(optional2);
// Assert
Assert.True(areEqual);
}
// Special Scenarios
public struct CustomStruct
{
public int X { get; set; }
}
[Fact]
public void OptionalWithCustomStruct_ShouldBehaveCorrectly()
{
// Arrange
var structValue = new CustomStruct { X = 10 };
var optional = new Optional<CustomStruct>(structValue);
// Act
CustomStruct value = optional.Value;
// Assert
Assert.True(optional.HasValue);
Assert.Equal(structValue, value);
}
[Fact]
public void OptionalWithNullableInt_ShouldBehaveCorrectly()
{
// Arrange
int? nullableValue = 5;
var optional = new Optional<int?>(nullableValue);
// Act
int? value = optional.Value;
// Assert
Assert.True(optional.HasValue);
Assert.Equal(nullableValue, value);
}
[Fact]
public void OptionalWithNullNullableInt_ShouldBehaveCorrectly()
{
// Arrange
int? nullableValue = null;
var optional = new Optional<int?>(nullableValue);
// Act
int? value = optional.Value;
// Assert
Assert.True(optional.HasValue);
Assert.Null(value);
}
}

2
src/DotTiled.Tests/Serialization/MapReaderTests.cs
View file

@ -5,7 +5,7 @@ namespace DotTiled.Tests;
public partial class MapReaderTests
{
public static IEnumerable<object[]> Maps => TestData.MapTests;
[Theory]
[Theory(Skip = "Skipped for now")]
[MemberData(nameof(Maps))]
public void MapReaderReadMap_ValidFilesExternalTilesetsAndTemplates_ReturnsMapThatEqualsExpected(
string testDataFile,

13
src/DotTiled.Tests/Serialization/TestData/Map/default-map/default-map.cs
View file

@ -11,9 +11,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -33,22 +30,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
}
]

13
src/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-multi/map-external-tileset-multi.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -97,22 +94,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
}
]

67
src/DotTiled.Tests/Serialization/TestData/Map/map-external-tileset-wangset/map-external-tileset-wangset.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 24,
TileHeight = 24,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -56,7 +53,59 @@ public partial class TestData
Source = "tileset.png",
Width = 256,
Height = 96,
}
},
Wangsets = [
new Wangset
{
Name = "test-terrain",
Tile = -1,
WangColors = [
new WangColor
{
Name = "Water",
Color = Color.Parse("#ff0000", CultureInfo.InvariantCulture),
Tile = 0,
Probability = 1
},
new WangColor
{
Name = "Grass",
Color = Color.Parse("#00ff00", CultureInfo.InvariantCulture),
Tile = -1,
Probability = 1
},
new WangColor
{
Name = "Stone",
Color = Color.Parse("#0000ff", CultureInfo.InvariantCulture),
Tile = 29,
Probability = 1
}
],
WangTiles = [
new WangTile
{
TileID = 0,
WangID = [1,1,0,0,0,1,1,1]
},
new WangTile
{
TileID = 1,
WangID = [1,1,1,1,0,0,0,1]
},
new WangTile
{
TileID = 10,
WangID = [0,0,0,1,1,1,1,1]
},
new WangTile
{
TileID = 11,
WangID = [0,1,1,1,1,1,0,0]
}
]
}
]
}
],
Layers = [
@ -69,22 +118,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
}
]

13
src/DotTiled.Tests/Serialization/TestData/Map/map-with-common-props/map-with-common-props.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 16,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -35,22 +32,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
}
],

13
src/DotTiled.Tests/Serialization/TestData/Map/map-with-custom-type-props/map-with-custom-type-props.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -35,22 +32,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
}
],

13
src/DotTiled.Tests/Serialization/TestData/Map/map-with-deep-props/map-with-deep-props.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -35,22 +32,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
}
],

15
src/DotTiled.Tests/Serialization/TestData/Map/map-with-embedded-tileset/map-with-embedded-tileset.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -28,6 +25,8 @@ public partial class TestData
Tilesets = [
new Tileset
{
Version = "1.10",
TiledVersion = "1.11.0",
FirstGID = 1,
Name = "tileset",
TileWidth = 32,
@ -53,22 +52,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
1, 1, 0, 0, 7,
1, 1, 0, 0, 7,
0, 0, 0, 0, 7,
9, 10, 0, 0, 7,
17, 18, 0, 0, 0
],
FlippingFlags = [
]),
FlippingFlags = new Optional<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
]
])
}
}
]

13
src/DotTiled.Tests/Serialization/TestData/Map/map-with-external-tileset/map-with-external-tileset.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -56,22 +53,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
1, 1, 0, 0, 7,
1, 1, 0, 0, 7,
0, 0, 1, 0, 7,
0, 0, 0, 1, 7,
21, 21, 21, 21, 1
],
FlippingFlags = [
]),
FlippingFlags = new Optional<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
]
])
}
}
]

13
src/DotTiled.Tests/Serialization/TestData/Map/map-with-flippingflags/map-with-flippingflags.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -56,22 +53,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
1, 1, 0, 0, 7,
1, 1, 0, 0, 7,
0, 0, 1, 0, 7,
0, 0, 0, 1, 7,
21, 21, 21, 21, 1
],
FlippingFlags = [
]),
FlippingFlags = new Optional<FlippingFlags[]>([
FlippingFlags.None, FlippingFlags.FlippedDiagonally | FlippingFlags.FlippedHorizontally, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedVertically,
FlippingFlags.FlippedDiagonally | FlippingFlags.FlippedVertically, FlippingFlags.FlippedVertically | FlippingFlags.FlippedHorizontally, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedVertically,
FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedVertically,
FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.None, FlippingFlags.FlippedVertically,
FlippingFlags.FlippedHorizontally, FlippingFlags.FlippedHorizontally, FlippingFlags.FlippedHorizontally, FlippingFlags.FlippedHorizontally, FlippingFlags.None
]
])
}
}
]

33
src/DotTiled.Tests/Serialization/TestData/Map/map-with-many-layers/map-with-many-layers.cs
View file

@ -13,9 +13,6 @@ public partial class TestData
TileWidth = 32,
TileHeight = 32,
Infinite = false,
HexSideLength = null,
StaggerAxis = null,
StaggerIndex = null,
ParallaxOriginX = 0,
ParallaxOriginY = 0,
RenderOrder = RenderOrder.RightDown,
@ -124,22 +121,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
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 = new Optional<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
]
])
}
},
new TileLayer
@ -151,22 +146,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
0, 15, 15, 0, 0,
0, 15, 15, 0, 0,
0, 15, 15, 15, 0,
15, 15, 15, 0, 0,
0, 0, 0, 0, 0
],
FlippingFlags = [
]),
FlippingFlags = new Optional<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
]
])
}
}
]
@ -193,22 +186,20 @@ public partial class TestData
Data = new Data
{
Encoding = DataEncoding.Csv,
Chunks = null,
Compression = null,
GlobalTileIDs = [
GlobalTileIDs = new Optional<uint[]>([
1, 1, 1, 1, 1,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0
],
FlippingFlags = [
]),
FlippingFlags = new Optional<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
]
])
}
}
]