IsometricRhombicCoordinates.cs

using System.Drawing;
using Gondwana.Scenes;
 
namespace Gondwana.Drawing.Coordinates;

internal sealed class IsometricRhombicCoordinates : ISceneLayerCoordinates
{
    public Point GetAnchorPixelAtSceneLayerCoordinates(SceneLayer sceneLayer, PointF gp)
    {
        int W = sceneLayer.TileWidth;
        int H = sceneLayer.TileHeight;
 
        int originX = sceneLayer.OriginPx.X;
        int originY = sceneLayer.OriginPx.Y;
 
        // gp is in grid-space (x,y) already.
        float dx = gp.X;
        float dy = gp.Y;
 
        float px = (dx - dy) * (W / 2f) - originX;
        float py = (dx + dy) * (H / 2f) - originY;
 
        return new Point((int)Math.Floor(px), (int)Math.Floor(py));
    }

    public PointF GetSceneLayerCoordinatesAtPixel(SceneLayer sceneLayer, PointF pixelPt)
    {
        int W = sceneLayer.TileWidth;
        int H = sceneLayer.TileHeight;
 
        int originX = sceneLayer.OriginPx.X;
        int originY = sceneLayer.OriginPx.Y;
 
        float a = (pixelPt.X + originX) / (W / 2f);
        float b = (pixelPt.Y + originY) / (H / 2f);
 
        float dx = (a + b) / 2f;
        float dy = (b - a) / 2f;
 
        return new PointF(dx, dy);
    }

    public List<SceneLayerTile> GetSceneLayerTilesInPixelRange(SceneLayer sceneLayer, Rectangle worldPixelRange, bool includeOverhang)
    {
        var result = new List<SceneLayerTile>();
        var candidateRange = TileBounds.GetTransformedTileCandidateRange(sceneLayer, worldPixelRange, includeOverhang);
        var ul = GetSceneLayerCoordinatesAtPixel(sceneLayer, new PointF(candidateRange.Left, candidateRange.Top));
        var ur = GetSceneLayerCoordinatesAtPixel(sceneLayer, new PointF(candidateRange.Right, candidateRange.Top));
        var ll = GetSceneLayerCoordinatesAtPixel(sceneLayer, new PointF(candidateRange.Left, candidateRange.Bottom));
        var lr = GetSceneLayerCoordinatesAtPixel(sceneLayer, new PointF(candidateRange.Right, candidateRange.Bottom));
 
        int minX = (int)Math.Floor(new[] { ul.X, ur.X, ll.X, lr.X }.Min()) - 1;
        int maxX = (int)Math.Ceiling(new[] { ul.X, ur.X, ll.X, lr.X }.Max()) + 1;
        int minY = (int)Math.Floor(new[] { ul.Y, ur.Y, ll.Y, lr.Y }.Min()) - 1;
        int maxY = (int)Math.Ceiling(new[] { ul.Y, ur.Y, ll.Y, lr.Y }.Max()) + 1;
 
        for (int y = minY; y <= maxY; y++)
        {
            for (int x = minX; x <= maxX; x++)
            {
                var gp = sceneLayer[x, y];
                if (gp == null) continue;
                var r = GetPixelRangeForTile(gp, includeOverhang);
                if (r.IntersectsWith(worldPixelRange)) result.Add(gp);
            }
        }
        return result;
    }

    public Rectangle GetPixelRangeForTile(Tile tile, bool includeOverhang)
    {
        var top = GetAnchorPixelAtSceneLayerCoordinates(tile.SceneLayer, tile.SceneLayerCoordinates);
        int W = tile.SceneLayer.TileWidth; int H = tile.SceneLayer.TileHeight;
        var rect = new Rectangle(top.X - W / 2, top.Y, W, H);
        return TileBounds.ApplyTileGeometry(rect, tile, includeOverhang);
    }

    public Rectangle GetPixelRangeForTileList(List<Tile> tileList, bool includeOverhang)
    {
        Rectangle ret = Rectangle.Empty;
        foreach (var t in tileList)
        {
            var r = GetPixelRangeForTile(t, includeOverhang);
            ret = ret.IsEmpty ? r : Rectangle.Union(ret, r);
        }
        return ret;
    }

    public SceneLayerTile GetAdjacentSceneLayerTile(SceneLayerTile gp, CardinalDirections dir)
    {
        var m = gp.SceneLayer; int x = gp.GridCoordinatesAbs.X; int y = gp.GridCoordinatesAbs.Y;
        return dir switch
        {
            CardinalDirections.N => m.ResolveWrappedTile(x, y - 1),
            CardinalDirections.S => m.ResolveWrappedTile(x, y + 1),
            CardinalDirections.E => m.ResolveWrappedTile(x + 1, y),
            CardinalDirections.W => m.ResolveWrappedTile(x - 1, y),
            CardinalDirections.NE => m.ResolveWrappedTile(x + 1, y - 1),
            CardinalDirections.NW => m.ResolveWrappedTile(x - 1, y - 1),
            CardinalDirections.SE => m.ResolveWrappedTile(x + 1, y + 1),
            CardinalDirections.SW => m.ResolveWrappedTile(x - 1, y + 1),
            _ => null
        };
    }

    public Point[] GetPolygonPts(Tile tile, bool includeOverhang)
    {
        var top = GetAnchorPixelAtSceneLayerCoordinates(tile.SceneLayer, tile.SceneLayerCoordinates);
        int W = tile.SceneLayer.TileWidth; int H = tile.SceneLayer.TileHeight;
        var oh = includeOverhang ? tile.Overhang : Spacing.None;
 
        return new[]
        {
                new Point(top.X, top.Y - oh.Top),
                new Point(top.X + W/2 + oh.Right, top.Y + H/2),
                new Point(top.X, top.Y + H + oh.Bottom),
                new Point(top.X - W/2 - oh.Left, top.Y + H/2)
            };
    }

    public PointF FindEquivalentSceneLayerCoordinates(PointF valColRow, int xUpperBound, int yUpperBound)
    {
        float modX = valColRow.X % (xUpperBound + 1);
        float modY = valColRow.Y % (yUpperBound + 1);
        if (modX < 0) modX += xUpperBound + 1;
        if (modY < 0) modY += yUpperBound + 1;
        return new PointF(modX, modY);
    }
}