TileTransform.cs

using System.Drawing;
using Gondwana.Physics.Collisions;
 
namespace Gondwana.Drawing;

public enum TileTransform
{
    Identity,
    Rotate90,
    Rotate180,
    Rotate270,
    FlipHorizontal,
    FlipVertical,
    FlipDiagonal,
    FlipAntiDiagonal
}

public static class TileTransformGeometry
{
    public static PointF TransformPoint(PointF point, TileTransform transform) => transform switch
    {
        TileTransform.Identity => point,
        TileTransform.Rotate90 => new(-point.Y, point.X),
        TileTransform.Rotate180 => new(-point.X, -point.Y),
        TileTransform.Rotate270 => new(point.Y, -point.X),
        TileTransform.FlipHorizontal => new(-point.X, point.Y),
        TileTransform.FlipVertical => new(point.X, -point.Y),
        TileTransform.FlipDiagonal => new(point.Y, point.X),
        TileTransform.FlipAntiDiagonal => new(-point.Y, -point.X),
        _ => throw new ArgumentOutOfRangeException(nameof(transform))
    };

    public static Size TransformSize(Size size, TileTransform transform)
    {
        var point = TransformPoint(new(size.Width, size.Height), transform);
        return new((int)Math.Abs(point.X), (int)Math.Abs(point.Y));
    }

    public static Spacing TransformSpacing(Spacing value, TileTransform transform) => transform switch
    {
        TileTransform.Identity => value,
        TileTransform.Rotate90 => new(value.Bottom, value.Left, value.Top, value.Right),
        TileTransform.Rotate180 => new(value.Right, value.Bottom, value.Left, value.Top),
        TileTransform.Rotate270 => new(value.Top, value.Right, value.Bottom, value.Left),
        TileTransform.FlipHorizontal => new(value.Right, value.Top, value.Left, value.Bottom),
        TileTransform.FlipVertical => new(value.Left, value.Bottom, value.Right, value.Top),
        TileTransform.FlipDiagonal => new(value.Top, value.Left, value.Bottom, value.Right),
        TileTransform.FlipAntiDiagonal => new(value.Bottom, value.Right, value.Top, value.Left),
        _ => throw new ArgumentOutOfRangeException(nameof(transform))
    };

    public static CollisionAdjust TransformCollisionAdjust(CollisionAdjust value, TileTransform transform)
    {
        var edges = TransformSpacing(new(value.Left, value.Top, value.Right, value.Bottom), transform);
        return new(edges.Top, edges.Bottom, edges.Left, edges.Right);
    }

    public static TileTransform Compose(TileTransform current, TileTransform operation)
    {
        var x = TransformPoint(TransformPoint(new(1, 0), current), operation);
        var y = TransformPoint(TransformPoint(new(0, 1), current), operation);
        foreach (var candidate in Enum.GetValues<TileTransform>())
            if (TransformPoint(new(1, 0), candidate) == x && TransformPoint(new(0, 1), candidate) == y)
                return candidate;
        throw new InvalidOperationException("Orthogonal transforms must be closed under composition.");
    }

    public static Rectangle GetVisualBounds(Rectangle cell, Spacing sourceOverhang, TileTransform transform)
    {
        var size = TransformSize(cell.Size, transform);
        int x = cell.X + (int)Math.Floor((cell.Width - size.Width) / 2d);
        int y = cell.Y + (int)Math.Floor((cell.Height - size.Height) / 2d);
        var edges = TransformSpacing(sourceOverhang, transform);
        return Rectangle.FromLTRB(x - edges.Left, y - edges.Top, x + size.Width + edges.Right, y + size.Height + edges.Bottom);
    }

    public static PointF MapToDestination(PointF normalizedPoint, RectangleF destination, TileTransform transform)
    {
        var point = TransformPoint(new(normalizedPoint.X - .5f, normalizedPoint.Y - .5f), transform);
        return new(destination.X + (point.X + .5f) * destination.Width,
            destination.Y + (point.Y + .5f) * destination.Height);
    }
}