public double GetIntersection(CubeCoordinates firstCubeCoordinates, CubeCoordinates secondCubeCoordinates)
{
var firstCube = _mapper.Map <CubeCoordinates, Cube>(firstCubeCoordinates);
var secondCube = _mapper.Map <CubeCoordinates, Cube>(secondCubeCoordinates);
return(firstCube.Intersection(secondCube));
}
public bool HaveCollision(CubeCoordinates firstCubeCoordinates, CubeCoordinates secondCubeCoordinates)
{
var firstCube = _mapper.Map <CubeCoordinates, Cube>(firstCubeCoordinates);
var secondCube = _mapper.Map <CubeCoordinates, Cube>(secondCubeCoordinates);
return(firstCube.Collides(secondCube));
}
public void If_Cubes_Only_Touch_Then_Intersection_Is_Zero()
{
//ARRANGE
var firstCube = new CubeCoordinates
{
X = 0,
Y = 0,
Z = 0,
Dimension = 1,
};
var secondCube = new CubeCoordinates
{
X = 1,
Y = 0,
Z = 0,
Dimension = 1,
};
//ACT
var result = _cubesAppService.GetIntersection(firstCube, secondCube);
//ASSERT
Assert.AreEqual(0, result);
}
public void TestDistance()
{
var v1 = new CubeCoordinates(1, -2, 1);
var v2 = new CubeCoordinates(2, -2, 0);
Assert.AreEqual(1, v1.Distance(v2));
}
public void Intersection_Is_Mutual()
{
//ARRANGE
var firstCube = new CubeCoordinates
{
X = 0,
Y = 0,
Z = 0,
Dimension = 1,
};
var secondCube = new CubeCoordinates
{
X = 1,
Y = 0,
Z = 0,
Dimension = 2,
};
//ACT
var firstCubeIntersection = _cubesAppService.GetIntersection(firstCube, secondCube);
var secondCubeIntersection = _cubesAppService.GetIntersection(firstCube, secondCube);
//ASSERT
Assert.AreEqual(firstCubeIntersection, secondCubeIntersection);
}
private static OddColumn CubeToOffset(CubeCoordinates cube)
{
var(x, _, z) = cube;
var row = z + (x - (x & 1)) / 2;
return(new OddColumn(row, x));
}
/// <summary>
/// Return offset coordinates of the neigboring tile in the specified direction.
/// </summary>
/// <param name="hex">Hex base.</param>
/// <param name="dir">Specified direction.</param>
/// <param name="pairs">Coordinate pairs.</param>
/// <returns></returns>
public static OffsetCoordinates GetNeighborFromDir(Hex hex, CubeDirections dir, OffsetCoordinates pairs)
{
CubeCoordinates cubePairs = OffsetToCube(hex, pairs.col, pairs.row);
switch (dir)
{
case CubeDirections.Left:
return(CubeToOffset(hex, cubePairs.x - 1, cubePairs.y + 1, cubePairs.z));
case CubeDirections.Right:
return(CubeToOffset(hex, cubePairs.x + 1, cubePairs.y - 1, cubePairs.z));
case CubeDirections.TopLeft:
return(CubeToOffset(hex, cubePairs.x, cubePairs.y + 1, cubePairs.z - 1));
case CubeDirections.BottomRight:
return(CubeToOffset(hex, cubePairs.x, cubePairs.y - 1, cubePairs.z + 1));
case CubeDirections.TopRight:
return(CubeToOffset(hex, cubePairs.x + 1, cubePairs.y, cubePairs.z - 1));
case CubeDirections.BottomLeft:
return(CubeToOffset(hex, cubePairs.x - 1, cubePairs.y, cubePairs.z + 1));
default:
Debug.LogError("Some unknown CubeDirections enum received.");
return(new OffsetCoordinates(-1, -1));
}
}
/// <summary>
/// Calculate distance between two tiles.
/// </summary>
/// <param name="hex">Hex base.</param>
/// <param name="a">Tile A.</param>
/// <param name="b">Tile B.</param>
/// <returns></returns>
public static int Distance(Hex hex, Tile a, Tile b)
{
CubeCoordinates ca = OffsetToCube(hex, a.Position.x, a.Position.y);
CubeCoordinates cb = OffsetToCube(hex, b.Position.x, b.Position.y);
return(Mathf.Max(Mathf.Abs(ca.x - cb.x), Mathf.Abs(ca.y - cb.y), Mathf.Abs(ca.z - cb.z)));
}
public void Not_Collision_Is_Mutual()
{
//ARRANGE
var firstCube = new CubeCoordinates
{
X = 0,
Y = 0,
Z = 0,
Dimension = 1,
};
var secondCube = new CubeCoordinates
{
X = 3,
Y = 3,
Z = 3,
Dimension = 1,
};
//ACT
var firstCubeCollision = _cubesAppService.HaveCollision(firstCube, secondCube);
var secondCubeCollision = _cubesAppService.HaveCollision(firstCube, secondCube);
//ASSERT
Assert.IsFalse(firstCubeCollision);
Assert.IsFalse(secondCubeCollision);
}
public void TestExplicitCast()
{
EvenColumn ec = new CubeCoordinates(1, 0, -1);
OddColumn oc = new CubeCoordinates(1, 0, -1);
EvenRow er = new CubeCoordinates(1, 0, -1);
OddRow or = new CubeCoordinates(1, 0, -1);
ec = (EvenColumn)er;
ec = (EvenColumn)or;
ec = (EvenColumn)oc;
er = (EvenRow)ec;
er = (EvenRow)or;
er = (EvenRow)oc;
or = (OddRow)ec;
or = (OddRow)er;
or = (OddRow)oc;
oc = (OddColumn)ec;
oc = (OddColumn)er;
oc = (OddColumn)or;
}
public void If_Cubes_Touch_Then_Not_Collide()
{
//ARRANGE
var firstCube = new CubeCoordinates
{
X = 0,
Y = 0,
Z = 0,
Dimension = 2,
};
var secondCube = new CubeCoordinates
{
X = 2,
Y = 0,
Z = 0,
Dimension = 2,
};
//ACT
var result = _cubesAppService.HaveCollision(firstCube, secondCube);
//ASSERT
Assert.IsFalse(result);
}
private static EvenRow CubeToOffset(CubeCoordinates cube)
{
var(x, _, z) = cube;
var col = x + (z + (z & 1)) / 2;
return(new EvenRow(z, col));
}
public void TestDynamicArrayStorage()
{
var storage = new DynamicArrayStorage <CubeCoordinates>();
var cc = new CubeCoordinates(0, 0, 0);
storage.Add(cc);
Assert.AreEqual(cc, storage.Get(0, 0));
cc = new CubeCoordinates(1, -2, 1);
storage.Add(cc);
Assert.AreEqual(cc, storage.Get(1, 1));
Assert.ThrowsException <ArgumentException>(() => storage.Add(cc));
storage.Clear();
for (int x = -99; x < 100; x++)
{
for (int y = -99; y < 100; y++)
{
for (int z = -99; z < 100; z++)
{
if (x + y + z != 0)
{
continue;
}
cc = new CubeCoordinates(x, y, z);
storage.Add(cc);
Assert.AreEqual(cc, storage.Get(x, z));
Assert.AreEqual(cc, storage[x, z]);
}
}
}
}
public void If_Cubes_Have_Same_Center_Then_Intersection_Equals_Smaller_Cube_Volume()
{
//ARRANGE
var firstCube = new CubeCoordinates
{
X = 0,
Y = 0,
Z = 0,
Dimension = 1,
};
var secondCube = new CubeCoordinates
{
X = 0,
Y = 0,
Z = 0,
Dimension = 2,
};
//ACT
var result = _cubesAppService.GetIntersection(firstCube, secondCube);
//ASSERT
Assert.AreEqual(GetCubeVolume(firstCube.Dimension), result);
Assert.AreNotEqual(GetCubeVolume(secondCube.Dimension), result);
}
public void EqualHex(string name, CubeCoordinates a, CubeCoordinates b)
{
if (!(a.Q == b.Q && a.S == b.S && a.R == b.R))
{
Assert.Fail(name);
}
}
public void FlipHexAt(string path)
{
using (StringReader reader = new StringReader(path))
{
char prev = char.MinValue;
int i;
CubeCoordinates coords = new CubeCoordinates();
while ((i = reader.Read()) >= 0)
{
char c = (char)i;
switch (c)
{
case 'e':
if (prev == 's')
{
coords = coords.SouthEast;
}
else if (prev == 'n')
{
coords = coords.NorthEast;
}
else
{
coords = coords.East;
}
prev = 'e';
break;
case 'w':
if (prev == 's')
{
coords = coords.SouthWest;
}
else if (prev == 'n')
{
coords = coords.NorthWest;
}
else
{
coords = coords.West;
}
prev = 'w';
break;
case 's':
prev = 's';
break;
case 'n':
prev = 'n';
break;
default:
throw new FormatException();
}
}
this[coords].Flip();
}
}
public void TestGetters()
{
var v1 = new CubeCoordinates(1, -2, 1);
Assert.AreEqual(1, v1.q);
Assert.AreEqual(-2, v1.r);
Assert.AreEqual(1, v1.s);
}
public void TestPlus()
{
var v1 = new CubeCoordinates(1, 0, -1);
var v2 = new CubeCoordinates(1, -1, 0);
var v3 = v1 + v2;
Assert.AreEqual(new CubeCoordinates(2, -1, -1), v3);
}
void HandleInput()
{
Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(inputRay, out RaycastHit hit))
{
EditCell(hexGrid.GetCell(CubeCoordinates.FromPosition(hit.point)));
}
}
public void Equals_Should_BeFalse_WhenComparingDifferentObjectsWithDifferentValues()
{
// Arrange
var firstCoordinate = new CubeCoordinates(1, 2, 0);
var secondCoordinate = new CubeCoordinates(1, 1, 0);
// Act & Assert
Assert.False(firstCoordinate.Equals(secondCoordinate));
}
public void Ctor_Works(int x, int y, int z)
{
// Arrange & Act
var coordinate = new CubeCoordinates(x, y, z);
// Assert
Assert.Equal(x, coordinate.X);
Assert.Equal(y, coordinate.Y);
Assert.Equal(z, coordinate.Z);
}
public void ImplicitCast_Works(int x, int y, int z)
{
// Arrange & Act
CubeCoordinates coordinate = (x, y, z);
// Assert
Assert.Equal(x, coordinate.X);
Assert.Equal(y, coordinate.Y);
Assert.Equal(z, coordinate.Z);
}
[InlineData(1, 1, 0)] // center
public void AddThreeCornerPiece_ThrowsArgumentException_WhenCoordinateIsInvalid(int x, int y, int z)
{
// Arrange
var builder = CubeBuilder.CreateEmpty();
var coordinate = new CubeCoordinates(x, y, z);
// Act & Assert
Assert.Throws <ArgumentException>(
() => builder.AddPiece(coordinate, Pieces.RedBlueWhite));
}
public void TestEqualityCube()
{
var v1 = new CubeCoordinates(0, 0, 0);
var v2 = new CubeCoordinates(0, 0, 0);
Assert.AreEqual(v1, v1);
Assert.AreEqual(v1, v2);
Assert.IsTrue(v1 == v2);
Assert.IsFalse(v1 != v2);
}
public void TestLayout()
{
CubeCoordinates h = new CubeCoordinates(3, 4, -7);
var flat = HexLayoutFactory.CreateFlatHexLayout(new Point(10, 15), new Point(35, 71), Offset.Even);
EqualHex("layout", h, flat.PixelToHex(flat.HexToPixel(h)).Round());
var pointy = HexLayoutFactory.CreatePointyHexLayout(new Point(10, 15), new Point(35, 71), Offset.Even);
EqualHex("layout", h, pointy.PixelToHex(pointy.HexToPixel(h)).Round());
}
public void TestCastVec3()
{
var v1 = new CubeCoordinates(1, -1, 0);
var v2 = (Vector3)v1;
var v3 = new Vector3(1, -1, 0);
var(q, r, s) = (CubeCoordinates)v3;
Assert.AreEqual((int)v2.X, q);
Assert.AreEqual((int)v2.Y, r);
Assert.AreEqual((int)v2.Z, s);
}
public void TestToString()
{
var v1 = new CubeCoordinates(1, -1, 0);
#if NET471
var v2 = (1, -1, 0);
#elif NETCOREAPP
var v2 = new Vector3(1, -1, 0);
#endif
Assert.AreEqual(v2.ToString(), v1.ToString());
}
public static CubeCoordinates MoveToCubeDiagonals(CubeCoordinates coordinates, int direction)
{
Dictionary <int, int[]> diagonals = new Dictionary <int, int[]>
{
{ 0, new int[] { 2, -1, -1 } }, { 1, new int[] { 1, 1, -2 } }, { 2, new int[] { -1, 2, -1 } },
{ 3, new int[] { -2, 1, 1 } }, { 4, new int[] { -1, -1, 2 } }, { 5, new int[] { 1, -2, 1 } }
};
int[] d = diagonals[direction];
return(new CubeCoordinates(coordinates.X + d[0], coordinates.Y + d[1], coordinates.Z + d[2]));
}
public void TestRotation()
{
var v1 = new CubeCoordinates(1, -2, 1);
var vl = v1.RotateLeft;
var vr = v1.RotateRight;
var vlA = new CubeCoordinates(-1, -1, 2);
var vrA = new CubeCoordinates(2, -1, -1);
Assert.AreEqual(vlA, vl);
Assert.AreEqual(vrA, vr);
}
public HexCell GetCell(CubeCoordinates coordinates)
{
int x = OffsetCoordinates.FromCubeCoordinates(coordinates).X;
int z = OffsetCoordinates.FromCubeCoordinates(coordinates).Z;
if (z < 0 || z > cellCountZ - 1 || x < 0 || x > cellCountX - 1)
{
return(null);
}
return(cells[x, z]);
}
