Monogame-Extended/tests/MonoGame.Extended.Tests/Tilemaps/TilemapTileDataTests.cs

using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using MonoGame.Extended.Tests.Fixtures;
using MonoGame.Extended.Tilemaps;

namespace MonoGame.Extended.Tests
{
    [Collection("GraphicsTest")]
    public sealed class TilemapTileDataTests
    {
        private readonly GraphicsTestFixture _graphicsFixture;

        public TilemapTileDataTests(GraphicsTestFixture graphicsTestFixture)
        {
            _graphicsFixture = graphicsTestFixture;
        }

        [Fact]
        public void Constructor_SetsLocalId()
        {
            var tileData = new TilemapTileData(42);
            Assert.Equal(42, tileData.LocalId);
        }

        [Fact]
        public void Constructor_InitializesDefaultValues()
        {
            var tileData = new TilemapTileData(1);

            Assert.Equal(string.Empty, tileData.Class);
            Assert.Equal(1.0f, tileData.Probability);
            Assert.NotNull(tileData.Properties);
            Assert.Null(tileData.Animation);
            Assert.NotNull(tileData.CollisionObjects);
            Assert.Empty(tileData.CollisionObjects);
            Assert.Null(tileData.CustomImage);
        }

        [Fact]
        public void Class_CanBeSet()
        {
            var tileData = new TilemapTileData(1);

            tileData.Class = "Water";

            Assert.Equal("Water", tileData.Class);
        }

        [Theory]
        [InlineData(0.0f)]
        [InlineData(0.5f)]
        [InlineData(1.0f)]
        [InlineData(2.0f)]
        public void Probability_CanBeSet(float probability)
        {
            var tileData = new TilemapTileData(1);

            tileData.Probability = probability;

            Assert.Equal(probability, tileData.Probability);
        }

        [Fact]
        public void Properties_CanStoreCustomData()
        {
            var tileData = new TilemapTileData(1);

            tileData.Properties["damage"] = TilemapPropertyValue.CreateInt(10);
            tileData.Properties["slippery"] = TilemapPropertyValue.CreateBool(true);

            Assert.Equal(10, tileData.Properties.GetInt("damage"));
            Assert.True(tileData.Properties.GetBool("slippery"));
        }


        [Fact]
        public void Animation_CanBeSet()
        {
            var tileData = new TilemapTileData(1);
            var frames = new TilemapTileAnimationFrame[]
            {
                new(0, 0.1f),
                new(1, 0.1f)
            };
            var animation = new TilemapTileAnimation(frames);

            tileData.Animation = animation;

            Assert.NotNull(tileData.Animation);
            Assert.Equal(animation, tileData.Animation);
        }

        [Fact]
        public void CollisionObjects_CanAddObjects()
        {
            var tileData = new TilemapTileData(1);
            var obj1 = new TilemapRectangleObject(1, new Vector2(0, 0), new Vector2(16, 16));
            var obj2 = new TilemapRectangleObject(2, new Vector2(16, 0), new Vector2(16, 16));

            tileData.CollisionObjects.Add(obj1);
            tileData.CollisionObjects.Add(obj2);

            Assert.Equal(2, tileData.CollisionObjects.Count);
            Assert.Contains(obj1, tileData.CollisionObjects);
            Assert.Contains(obj2, tileData.CollisionObjects);
        }

        [Fact]
        public void CollisionObjects_CanContainDifferentObjectTypes()
        {
            var tileData = new TilemapTileData(1);
            var rect = new TilemapRectangleObject(1, Vector2.Zero, new Vector2(32, 32));
            var polygon = new TilemapPolygonObject(2, Vector2.Zero, new[]
            {
                new Vector2(0, 0),
                new Vector2(32, 0),
                new Vector2(16, 32)
            });

            tileData.CollisionObjects.Add(rect);
            tileData.CollisionObjects.Add(polygon);

            Assert.Equal(2, tileData.CollisionObjects.Count);
            Assert.IsType<TilemapRectangleObject>(tileData.CollisionObjects[0]);
            Assert.IsType<TilemapPolygonObject>(tileData.CollisionObjects[1]);
        }

        [Fact]
        public void CustomImage_CanBeSet()
        {
            var texture = _graphicsFixture.CreatePixelTexture();

            try
            {
                var tileData = new TilemapTileData(1);

                tileData.CustomImage = texture;

                Assert.Equal(texture, tileData.CustomImage);
            }
            finally
            {
                texture.Dispose();
            }
        }

        [Fact]
        public void CustomImage_DefaultsToNull()
        {
            var tileData = new TilemapTileData(1);

            Assert.Null(tileData.CustomImage);
        }

    }
}