public void StaticSpiralOutward()
{
CubicHexCoord cubic = new CubicHexCoord(1, 0, -1);
CubicHexCoord[] spiral = CubicHexCoord.SpiralOutward(cubic, 2, DirectionEnum.W);
Assert.That(spiral, Is.EquivalentTo(new CubicHexCoord[19] {
// Center
new CubicHexCoord(1, 0, -1),
// Distance 1
new CubicHexCoord(0, 1, -1),
new CubicHexCoord(1, 1, -2),
new CubicHexCoord(2, 0, -2),
new CubicHexCoord(2, -1, -1),
new CubicHexCoord(1, -1, 0),
new CubicHexCoord(0, 0, 0),
// Distance 2
new CubicHexCoord(-1, 2, -1),
new CubicHexCoord(0, 2, -2),
new CubicHexCoord(1, 2, -3),
new CubicHexCoord(2, 1, -3),
new CubicHexCoord(3, 0, -3),
new CubicHexCoord(3, -1, -2),
new CubicHexCoord(3, -2, -1),
new CubicHexCoord(2, -2, 0),
new CubicHexCoord(1, -2, 1),
new CubicHexCoord(0, -1, 1),
new CubicHexCoord(-1, 0, 1),
new CubicHexCoord(-1, 1, 0)
}));
}
public void ToOffset()
{
OffsetHexCoord offset = new CubicHexCoord(0, -2, 2).ToOffset();
Assert.That(offset.q, Is.EqualTo(1));
Assert.That(offset.r, Is.EqualTo(2));
}
public override List <Tile> Action(Board <Piece> board, Piece piece, Tile tile)
{
var validTiles = new List <Tile>();
if (piece == null || tile == null)
{
return(validTiles);
}
validTiles.Add(tile);
var playerTile = board.TileOf(piece);
CubicHexCoord clockwisePosition = CubicHexCoord.RotateOnceLeft(playerTile.Position, tile.Position);
Tile clockwiseTile = board.TileAt(clockwisePosition);
while (clockwiseTile == null)
{
clockwisePosition = CubicHexCoord.RotateOnceLeft(playerTile.Position, clockwisePosition);
clockwiseTile = board.TileAt(clockwisePosition);
}
CubicHexCoord counterClockwisePosition = CubicHexCoord.RotateOnceRight(playerTile.Position, tile.Position);
Tile counterClockwiseTile = board.TileAt(counterClockwisePosition);
while (counterClockwiseTile == null)
{
counterClockwisePosition = CubicHexCoord.RotateOnceRight(playerTile.Position, counterClockwisePosition);
counterClockwiseTile = board.TileAt(counterClockwisePosition);
}
validTiles.Add(clockwiseTile);
validTiles.Add(counterClockwiseTile);
return(validTiles);
}
public void ToAxial()
{
AxialHexCoord axial = new CubicHexCoord(1, 2, 3).ToAxial();
Assert.That(axial.q, Is.EqualTo(1));
Assert.That(axial.r, Is.EqualTo(3));
}
public void StaticArea()
{
CubicHexCoord cubic = new CubicHexCoord(1, 0, -1);
CubicHexCoord[] area = CubicHexCoord.Area(cubic, 2);
// Center
Assert.Contains(new CubicHexCoord(1, 0, -1), area);
// Distance 1
Assert.Contains(new CubicHexCoord(0, 1, -1), area);
Assert.Contains(new CubicHexCoord(1, 1, -2), area);
Assert.Contains(new CubicHexCoord(2, 0, -2), area);
Assert.Contains(new CubicHexCoord(2, -1, -1), area);
Assert.Contains(new CubicHexCoord(1, -1, 0), area);
Assert.Contains(new CubicHexCoord(0, 0, 0), area);
// Distance 2
Assert.Contains(new CubicHexCoord(-1, 2, -1), area);
Assert.Contains(new CubicHexCoord(0, 2, -2), area);
Assert.Contains(new CubicHexCoord(1, 2, -3), area);
Assert.Contains(new CubicHexCoord(2, 1, -3), area);
Assert.Contains(new CubicHexCoord(3, 0, -3), area);
Assert.Contains(new CubicHexCoord(3, -1, -2), area);
Assert.Contains(new CubicHexCoord(3, -2, -1), area);
Assert.Contains(new CubicHexCoord(2, -2, 0), area);
Assert.Contains(new CubicHexCoord(1, -2, 1), area);
Assert.Contains(new CubicHexCoord(0, -1, 1), area);
Assert.Contains(new CubicHexCoord(-1, 0, 1), area);
Assert.Contains(new CubicHexCoord(-1, 1, 0), area);
}
public void StaticDirectionDiff()
{
CubicHexCoord cubic = CubicHexCoord.DirectionDiff(DirectionEnum.E);
Assert.That(cubic.x, Is.EqualTo(1));
Assert.That(cubic.y, Is.EqualTo(-1));
Assert.That(cubic.z, Is.EqualTo(0));
}
public void ConstructorParameterless()
{
CubicHexCoord cubic = new CubicHexCoord();
Assert.That(cubic.x, Is.EqualTo(0));
Assert.That(cubic.y, Is.EqualTo(0));
Assert.That(cubic.z, Is.EqualTo(0));
}
public void Neighbor()
{
CubicHexCoord cubic = new CubicHexCoord(1, 2, 3).Neighbor(DirectionEnum.E);
Assert.That(cubic.x, Is.EqualTo(2));
Assert.That(cubic.y, Is.EqualTo(1));
Assert.That(cubic.z, Is.EqualTo(3));
}
public void DistanceTo()
{
CubicHexCoord cubic1 = new CubicHexCoord(0, 0, 0);
CubicHexCoord cubic2 = cubic1.Neighbor(DirectionEnum.E).Neighbor(DirectionEnum.SE);
int distance = cubic1.DistanceTo(cubic2);
Assert.That(distance, Is.EqualTo(2));
}
public void ConstructorXYZ()
{
CubicHexCoord cubic = new CubicHexCoord(1, 2, 3);
Assert.That(cubic.x, Is.EqualTo(1));
Assert.That(cubic.y, Is.EqualTo(2));
Assert.That(cubic.z, Is.EqualTo(3));
}
public void OperatorOverloadPlus()
{
CubicHexCoord cubic = new CubicHexCoord(1, 2, 3) + new CubicHexCoord(4, 5, 6);
Assert.That(cubic.x, Is.EqualTo(5));
Assert.That(cubic.y, Is.EqualTo(7));
Assert.That(cubic.z, Is.EqualTo(9));
}
public void OperatorOverloadMinus()
{
CubicHexCoord cubic = new CubicHexCoord(6, 5, 4) - new CubicHexCoord(1, 2, 3);
Assert.That(cubic.x, Is.EqualTo(5));
Assert.That(cubic.y, Is.EqualTo(3));
Assert.That(cubic.z, Is.EqualTo(1));
}
public static Vector3 BoardToWorldPosition(CubicHexCoord boardPos)
{
var worldPos = boardPos.ToAxial().ToPixel();
return(new Vector3 {
x = worldPos.x, z = worldPos.y
});
}
public void OperatorOverloadNotEquals()
{
bool isTrue = new CubicHexCoord(1, 2, 3) != new CubicHexCoord(4, 5, 6);
bool isFalse = new CubicHexCoord(1, 2, 3) != new CubicHexCoord(1, 2, 3);
Assert.That(isTrue, Is.True);
Assert.That(isFalse, Is.False);
}
public void Diagonal()
{
CubicHexCoord cubic = new CubicHexCoord(1, 2, 3).Diagonal(DiagonalEnum.ESE);
Assert.That(cubic.x, Is.EqualTo(2));
Assert.That(cubic.y, Is.EqualTo(0));
Assert.That(cubic.z, Is.EqualTo(4));
}
public void StaticDiagonalDiff()
{
CubicHexCoord cubic = CubicHexCoord.DiagonalDiff(DiagonalEnum.ESE);
Assert.That(cubic.x, Is.EqualTo(1));
Assert.That(cubic.y, Is.EqualTo(-2));
Assert.That(cubic.z, Is.EqualTo(1));
}
public void Scale()
{
CubicHexCoord cubic = CubicHexCoord.DirectionDiff(DirectionEnum.SE);
CubicHexCoord scaled = cubic.Scale(3);
Assert.That(scaled.x, Is.EqualTo(3 * cubic.x));
Assert.That(scaled.y, Is.EqualTo(3 * cubic.y));
Assert.That(scaled.z, Is.EqualTo(3 * cubic.z));
}
public void Round()
{
FloatCubic floatCubic = new FloatAxial(1.2f, 2.2f).ToFloatCubic();
CubicHexCoord rounded = floatCubic.Round();
AxialHexCoord axial = rounded.ToAxial();
Assert.That(axial.q, Is.EqualTo(1));
Assert.That(axial.r, Is.EqualTo(2));
}
public Tile TileAt(CubicHexCoord position)
{
if (_tiles.TryGetValue(position, out var tile))
{
return(tile);
}
return(null);
}
public void StaticLine()
{
CubicHexCoord startCubic = new CubicHexCoord(1, 0, -1);
CubicHexCoord endCubic = new CubicHexCoord(-2, 2, 0);
CubicHexCoord[] line = CubicHexCoord.Line(startCubic, endCubic);
Assert.That(line, Is.EquivalentTo(new CubicHexCoord[4] {
new CubicHexCoord(1, 0, -1),
new CubicHexCoord(0, 1, -1),
new CubicHexCoord(-1, 1, 0),
new CubicHexCoord(-2, 2, 0)
}));
}
public void Diagonals()
{
CubicHexCoord cubic = new CubicHexCoord(1, 2, 3);
CubicHexCoord[] diagonals = cubic.Diagonals();
Assert.That(diagonals, Is.EquivalentTo(new CubicHexCoord[6] {
cubic.Diagonal(DiagonalEnum.ESE),
cubic.Diagonal(DiagonalEnum.S),
cubic.Diagonal(DiagonalEnum.WSW),
cubic.Diagonal(DiagonalEnum.WNW),
cubic.Diagonal(DiagonalEnum.N),
cubic.Diagonal(DiagonalEnum.ENE)
}));
}
public void Neighbors()
{
CubicHexCoord cubic = new CubicHexCoord(1, 2, 3);
CubicHexCoord[] neighbors = cubic.Neighbors();
Assert.That(neighbors, Is.EquivalentTo(new CubicHexCoord[6] {
cubic.Neighbor(DirectionEnum.E),
cubic.Neighbor(DirectionEnum.SE),
cubic.Neighbor(DirectionEnum.SW),
cubic.Neighbor(DirectionEnum.W),
cubic.Neighbor(DirectionEnum.NW),
cubic.Neighbor(DirectionEnum.NE)
}));
}
public void StaticRing()
{
CubicHexCoord cubic = new CubicHexCoord(1, 0, -1);
CubicHexCoord[] ring = CubicHexCoord.Ring(cubic, 2, DirectionEnum.W);
Assert.That(ring, Is.EquivalentTo(new CubicHexCoord[12] {
new CubicHexCoord(-1, 2, -1),
new CubicHexCoord(0, 2, -2),
new CubicHexCoord(1, 2, -3),
new CubicHexCoord(2, 1, -3),
new CubicHexCoord(3, 0, -3),
new CubicHexCoord(3, -1, -2),
new CubicHexCoord(3, -2, -1),
new CubicHexCoord(2, -2, 0),
new CubicHexCoord(1, -2, 1),
new CubicHexCoord(0, -1, 1),
new CubicHexCoord(-1, 0, 1),
new CubicHexCoord(-1, 1, 0)
}));
}
public MovementHelper Collect(CubicHexCoord offset, int step = int.MaxValue, params Validator[] validators)
{
Tile lastTile = _tile;
if (_piece != null)
{
lastTile = _board.TileOf(_piece);
}
for (int count = 1; count <= step; count++)
{
Tile tile = lastTile;
var pos = tile.Position - offset;
tile = _board.TileAt(pos);
if (tile == null)
{
break;
}
lastTile = tile;
var pawn = _board.PieceAt(tile);
//if (pawn != null && pawn.PlayerID == _piece.PlayerID) continue;
var valid = validators.All(v => v(_board, _piece, tile));
if (pawn == null || valid)
{
_validTile.Add(tile);
}
if (!valid)
{
break;
}
}
return(this);
}
public void PlaceRandomEnemies()
{
var spots = new List <CubicHexCoord>()
{
new CubicHexCoord()
};
var board = BoardPositionHelper.GenerateBoard(_boardSize);
while (spots.Count <= _enemyAmount)
{
var go = Instantiate(_enemyPrefab);
CubicHexCoord spot = GetRandomSpot(board);
while (spots.Contains(spot))
{
spot = GetRandomSpot(board);
}
go.transform.position = BoardPositionHelper.BoardToWorldPosition(spot);
spots.Add(spot);
}
}
public override List <Tile> Action(Board <Piece> board, Piece piece, Tile tile)
{
if (piece == null || tile == null)
{
return(new List <Tile>());
}
var playerTile = board.TileOf(piece);
var dir = playerTile.Position - tile.Position;
dir = new CubicHexCoord(Mathf.Clamp(dir.x, -1, 1), Mathf.Clamp(dir.y, -1, 1), Mathf.Clamp(dir.z, -1, 1));
if (dir.Equals(new CubicHexCoord()))
{
return(new List <Tile>());
}
var validTiles = new MovementHelper(board, piece)
.Collect(dir)
.Generate();
return(validTiles);
}
public void PointToCubic()
{
HexGrid grid = new HexGrid(3f);
float hexRadius = grid.HexRadius;
CubicHexCoord cubic = grid.PointToCubic(new Vec2D(10f, 10f));
float rExpected = 10f / ((3f / 2f) * hexRadius);
float qExpected = 10f / (SQRT_3 * hexRadius * (1f + 0.5f * rExpected));
Console.WriteLine("Axial: q: " + qExpected + ", r: " + rExpected);
float xExpected = qExpected;
float zExpected = rExpected;
float yExpected = -xExpected - zExpected;
Console.WriteLine("Cubic: x: " + xExpected + ", y: " + yExpected + ", z: " + zExpected);
// Now that I'm close enough to guess, I'll just do that rather than trying to emulate
// the rounding all the way through. Not accurate, but good enough for government work.
Assert.That(cubic.x, Is.EqualTo(1));
Assert.That(cubic.y, Is.EqualTo(-3));
Assert.That(cubic.z, Is.EqualTo(2));
}
public MovementHelper Diagonal(DiagonalEnum direction, params Validator[] validators)
{
return(Collect(CubicHexCoord.DiagonalDiff(direction), validators: validators));
}
