GodotComponentTest/tests/HexCellTests.cs

using Godot;
using GoDotTest;
using System.Diagnostics;
using System.Linq;
using Xunit;

public class HexCellTests : TestClass
{
    public HexCellTests(Node testScene) : base(testScene)
    {
    }

    [Test]
    public void TestHexCellSimple()
    {
        HexCell cell = new HexCell();
        Debug.Assert(cell.CubeCoords == new Vector3(0, 0, 0));
    }

    [Test]
    public void TestHexCellEqualityInequality()
    {
        HexCell cellA = new HexCell();
        HexCell cellB = new HexCell();

        cellA.AxialCoords = new Vector2(2, 3);
        cellB.AxialCoords = new Vector2(2, 3);
        Assert.Equal(cellA, cellB);
        bool result = cellA == cellB;
        Assert.True(cellA == cellB);
        Assert.False(cellA != cellB);

        cellB.AxialCoords = new Vector2(3, 2);
        Assert.NotEqual(cellA, cellB);
        Assert.False(cellA == cellB);
        Assert.True(cellA != cellB);
    }

    [Test]
    public void TestAxialCoords()
    {
        HexCell cell = new HexCell(1, 1, -2);
        Debug.Assert(cell.AxialCoords == new Vector2(1, 1));

        cell = new HexCell(1, -1);
        Debug.Assert(cell.AxialCoords == new Vector2(1, -1));

        cell = new HexCell(new Vector3(-1, 2, -1));
        HexCell otherCell = cell;
        Debug.Assert(otherCell.AxialCoords == new Vector2(-1, 2));
    }

    [Test]
    public void TestAxialCoordsRounded()
    {
        HexCell cell = new HexCell(new Vector2(-0.1f, 0.6f));
        Debug.Assert(cell.CubeCoords == new Vector3(0, 1, -1));

        cell = new HexCell(new Vector2(4.2f, -5.5f));
        Debug.Assert(cell.CubeCoords == new Vector3(4, -5, 1));
    }

    [Test]
    public void TestConversion()
    {
        HexCell cell = new HexCell();
        Debug.Assert(cell.AxialToCubeCoords(new Vector2(2, 1)) == new Vector3(2, 1, -3));
        Debug.Assert(cell.AxialToCubeCoords(new Vector2(-1, -1)) == new Vector3(-1, -1, 2));
    }

    [Test]
    public void TestRounding()
    {
        HexCell cell = new HexCell();
        Debug.Assert(cell.RoundCoords(new Vector3(0.1f, 0.5f, -0.6f)) == new Vector3(0, 1, -1));
        Debug.Assert(cell.RoundCoords(new Vector3(-0.4f, -1.3f, 1.7f)) == new Vector3(-1, -1, 2));

        Debug.Assert(cell.RoundCoords(new Vector2(-0.1f, 0.6f)) == new Vector3(0, 1, -1));
        Debug.Assert(cell.RoundCoords(new Vector2(4.2f, -5.5f)) == new Vector3(4, -5, 1));
    }

    [Test]
    public void TestCoords()
    {
        HexCell cell = new HexCell();

        // from cubic positive
        cell.CubeCoords = new Vector3(2, 1, -3);
        Debug.Assert(cell.CubeCoords == new Vector3(2, 1, -3));
        Debug.Assert(cell.AxialCoords == new Vector2(2, 1));
        Debug.Assert(cell.OffsetCoords == new Vector2(2, 2));

        // from offset positive
        cell.OffsetCoords = new Vector2(2, 2);
        Debug.Assert(cell.CubeCoords == new Vector3(2, 1, -3));
        Debug.Assert(cell.AxialCoords == new Vector2(2, 1));
        Debug.Assert(cell.OffsetCoords == new Vector2(2, 2));

        // from offset negative
        cell.OffsetCoords = new Vector2(-1, -2);
        Debug.Assert(cell.CubeCoords == new Vector3(-1, -1, 2));
        Debug.Assert(cell.AxialCoords == new Vector2(-1, -1));
        Debug.Assert(cell.OffsetCoords == new Vector2(-1, -2));
    }

    [Test]
    public void TestNearby()
    {
        HexCell cell = new HexCell(new Vector2(1, 2));

        // adjacent
        HexCell otherCell = cell.GetAdjacent(HexCell.DIR_N);
        Debug.Assert(otherCell.AxialCoords == new Vector2(1, 3));
        otherCell = cell.GetAdjacent(HexCell.DIR_NE);
        Debug.Assert(otherCell.AxialCoords == new Vector2(2, 2));
        otherCell = cell.GetAdjacent(HexCell.DIR_SE);
        Debug.Assert(otherCell.AxialCoords == new Vector2(2, 1));
        otherCell = cell.GetAdjacent(HexCell.DIR_S);
        Debug.Assert(otherCell.AxialCoords == new Vector2(1, 1));
        otherCell = cell.GetAdjacent(HexCell.DIR_SW);
        Debug.Assert(otherCell.AxialCoords == new Vector2(0, 2));
        otherCell = cell.GetAdjacent(HexCell.DIR_NW);
        Debug.Assert(otherCell.AxialCoords == new Vector2(0, 3));

        // not really adjacent
        otherCell = cell.GetAdjacent(new Vector3(-3, -3, 6));
        Debug.Assert(otherCell.AxialCoords == new Vector2(-2, -1));
    }

    [Test]
    public void TestDistance()
    {
        HexCell cell = new HexCell();
        cell.OffsetCoords = new Vector2(1, 2);

        Debug.Assert(cell.DistanceTo(new HexCell(new Vector2(0, 0))) == 3);
        Debug.Assert(cell.DistanceTo(new HexCell(new Vector2(3, 4))) == 4);
        Debug.Assert(cell.DistanceTo(new HexCell(new Vector2(-1, -1))) == 5);
    }


    [Test]
    public void TestLineTo()
    {
        HexCell cell = new HexCell();
        cell.OffsetCoords = new Vector2(1, 2);

        HexCell[] path = cell.LineTo(new HexCell(5, 2));

        HexCell[] pathExpected =
        {
            new HexCell(1, 2),
            new HexCell(2, 2),
            new HexCell(3, 2),
            new HexCell(4, 2),
            new HexCell(5, 2)
        };

        Debug.Assert(path.Length == pathExpected.Length);

        foreach (int index in Enumerable.Range(0, path.Length))
        {
            Debug.Assert(path[index].AxialCoords == pathExpected[index].AxialCoords);
        }
    }


    [Test]
    public void TestLineToAngled()
    {
        HexCell cell = new HexCell();
        cell.OffsetCoords = new Vector2(1, 2);

        HexCell[] path = cell.LineTo(new HexCell(5, 4));

        HexCell[] pathExpected =
        {
            new HexCell(1, 2),
            new HexCell(2, 2),
            new HexCell(2, 3),
            new HexCell(3, 3),
            new HexCell(4, 3),
            new HexCell(4, 4),
            new HexCell(5, 4)
        };

        Debug.Assert(path.Length == pathExpected.Length);

        foreach (int index in Enumerable.Range(0, path.Length))
        {
            Debug.Assert(path[index].AxialCoords == pathExpected[index].AxialCoords);
        }
    }


    [Test]
    public void TestLineEdge()
    {
        HexCell cell = new HexCell();
        cell.OffsetCoords = new Vector2(1, 2);

        HexCell[] path = cell.LineTo(new HexCell(3, 4));

        HexCell[] pathExpected =
        {
            new HexCell(1, 2),
            new HexCell(2, 2),
            new HexCell(2, 3),
            new HexCell(2, 4),
            new HexCell(3, 4)
        };

        Debug.Assert(path.Length == pathExpected.Length);

        foreach (int index in Enumerable.Range(0, path.Length))
        {
            Debug.Print("index: " + index + " path: " + path[index].AxialCoords + " expected: " +
                        pathExpected[index].AxialCoords);
            Debug.Assert(path[index].AxialCoords == pathExpected[index].AxialCoords);
        }
    }

    [Test]
    public void TestCellDirections()
    {
        HexCell cell = new HexCell();

        HexCell cellN = HexCell.FromOffsetCoords(new Vector2(0, 1));
        HexCell cellNW = HexCell.FromOffsetCoords(new Vector2(-1, 0));
        HexCell cellSW = HexCell.FromOffsetCoords(new Vector2(-1, -1));
        HexCell cellS = HexCell.FromOffsetCoords(new Vector2(0, -1));
        HexCell cellSE = HexCell.FromOffsetCoords(new Vector2(1, -1));
        HexCell cellNE = HexCell.FromOffsetCoords(new Vector2(1, 0));

        HexCell neighbour = cell.GetAdjacent(HexCell.DIR_N);
        Assert.Equal(cellN, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_NW);
        Assert.Equal(cellNW, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_SW);
        Assert.Equal(cellSW, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_S);
        Assert.Equal(cellS, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_SE);
        Assert.Equal(cellSE, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_NW);
        Assert.Equal(cellNW, neighbour);
    }

    [Test]
    public void TestCellDirectionsNonzeroReference()
    {
        HexCell cell = HexCell.FromOffsetCoords(new Vector2(-4, -3));

        HexCell cellN = HexCell.FromOffsetCoords(new Vector2(-4, -2));
        HexCell cellNW = HexCell.FromOffsetCoords(new Vector2(-5, -3));
        HexCell cellSW = HexCell.FromOffsetCoords(new Vector2(-5, -4));
        HexCell cellS = HexCell.FromOffsetCoords(new Vector2(-4, -4));
        HexCell cellSE = HexCell.FromOffsetCoords(new Vector2(-3, -4));
        HexCell cellNE = HexCell.FromOffsetCoords(new Vector2(-3, -3));

        HexCell neighbour = cell.GetAdjacent(HexCell.DIR_N);
        Assert.Equal(cellN, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_NW);
        Assert.Equal(cellNW, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_SW);
        Assert.Equal(cellSW, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_S);
        Assert.Equal(cellS, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_SE);
        Assert.Equal(cellSE, neighbour);

        neighbour = cell.GetAdjacent(HexCell.DIR_NW);
        Assert.Equal(cellNW, neighbour);
    }

    [Test]
    public void TestNextCellAlongLine()
    {
        HexCell cell = new HexCell();
        HexCell cellN = HexCell.FromOffsetCoords(new Vector2(0, 1));
        HexCell cellNE = HexCell.FromOffsetCoords(new Vector2(1, 0));
        HexCell cellSE = HexCell.FromOffsetCoords(new Vector2(1, -1));
        HexCell cellS = HexCell.FromOffsetCoords(new Vector2(0, -1));
        HexCell cellSW = HexCell.FromOffsetCoords(new Vector2(-1, -1));
        HexCell cellNW = HexCell.FromOffsetCoords(new Vector2(-1, 0));

        HexCell nextCell = cell.NextCellAlongLine(new Vector2(0, 0), new Vector2(0, 1));
        Assert.Equal(cellS, nextCell);

        nextCell = cell.NextCellAlongLine(new Vector2(0, 0), new Vector2(1, 1).Normalized());
        Assert.Equal(cellSE, nextCell);

        nextCell = cell.NextCellAlongLine(new Vector2(0, 0), new Vector2(1, -1).Normalized());
        Assert.Equal(cellNE, nextCell);

        nextCell = cell.NextCellAlongLine(new Vector2(0, 0), new Vector2(0, -1));
        Assert.Equal(cellN, nextCell);

        nextCell = cell.NextCellAlongLine(new Vector2(0, 0), new Vector2(-1, -1).Normalized());
        Assert.Equal(cellNW, nextCell);

        nextCell = cell.NextCellAlongLine(new Vector2(0, 0), new Vector2(-1, 1).Normalized());
        Assert.Equal(cellSW, nextCell);
    }
}