StitchATon2/Domain/TileManager.cs

using System.Buffers;
using System.Runtime.CompilerServices;
using StitchATon2.Infra;
using StitchATon2.Infra.Buffers;

namespace StitchATon2.Domain;

public sealed class TileManager
{
    private readonly Tile[] _tiles;
    
    public Configuration Configuration { get; }

    public TileManager(Configuration config)
    {
        Configuration = config;
        _tiles = new Tile[Configuration.TileCount];
        for (var id = 0; id < config.TileCount; id++)
            _tiles[id] = CreateTile(id);
        
        Console.WriteLine("Tile manager created");
    }

    private Tile CreateTile(int id)
    {
        var (row, column) = int.DivRem(id, Configuration.Columns);
        var coordinate = $"{Utils.GetSbsNotationRow(++row)}{++column}";
        return new Tile
        {
            Id = id,
            Row = row,
            Column = column,
            Coordinate = coordinate,
            Integral = new ImageIntegral(
                imagePath: Configuration.GetAssetPath($"{coordinate}.png"),
                outputDirectory: Configuration.CachePath,
                width: Configuration.Width,
                height: Configuration.Height
                ),
        };
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private int GetId(int column, int row) => column - 1 + (row - 1) * Configuration.Columns;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Tile GetTile(int id) => _tiles[id];

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Tile GetTile(int column, int row) => GetTile(GetId(column, row));

    public Tile GetTile(string coordinate)
    {
        var (column, row) = Utils.GetSbsNotationCoordinate(coordinate);
        return GetTile(column, row);
    }
    
    public Tile? TryGetAdjacent(Tile tile, int columnOffset, int rowOffset)
    {
        var column = tile.Column + columnOffset;
        if(column <= 0 || column > Configuration.Columns)
            return null;
        
        var row = tile.Row + rowOffset;
        if(row <= 0 || row > Configuration.Rows)
            return null;
        
        return GetTile(column, row);
    }

    public (Tile TopLeft, Tile BottomRight) GetTilePair(string coordinatePair)
    {
        var index = coordinatePair.IndexOf(':');
        var topLeft = GetTile(coordinatePair[..index++]);
        var bottomRight = GetTile(coordinatePair[index..]);
        
        return (topLeft, bottomRight);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Tile GetAdjacent(Tile tile, int columnOffset, int rowOffset)
    {
        return GetTile(tile.Column + columnOffset, tile.Row + rowOffset);
    }

    public GridSection CreateSection(
        string coordinatePair,
        float cropX,
        float cropY,
        float cropWidth,
        float cropHeight)
        => new(
            this,
            coordinatePair,
            cropX,
            cropY,
            cropWidth,
            cropHeight);
}