public void Rotate(Dir4 dir, int n, Dir4 expected, bool exception = false)
{
if (exception)
{
Assert.Throws <ArgumentOutOfRangeException>(() => { dir.Rotate(n); });
}
else
{
Assert.That(dir.Rotate(n), Is.EqualTo(expected));
}
}
private static IEnumerable <Point> PointsAtChebyshevDistanceInternal(
this Point source, int distance, bool clockwise, bool orderByEuclideanDistance, Dir8 startDir)
{
if (distance == 0)
{
yield return(source);
yield break;
}
if (orderByEuclideanDistance)
{
Dir4 orthoDir = (Dir4)startDir; // If this bool is true, startDir must be orthogonal
foreach (Point p in source.StartingPointsAtChebyshevDistance(distance, clockwise, orthoDir))
{
yield return(p);
}
if (distance > 1)
{
var enumerators = new IEnumerator <Point> [4];
Dir4 currentDir = orthoDir;
for (int i = 0; i < 4; ++i)
{
enumerators[i] = source.MiddlePointsAtChebyshevDistance(distance, clockwise, currentDir).GetEnumerator();
currentDir = currentDir.Rotate(clockwise);
}
// MiddlePointsAtChebyshevDistance *must* provide pairs, so 2 points are yielded for each, per iteration:
while (enumerators[0].MoveNext() && enumerators[1].MoveNext() && enumerators[2].MoveNext() && enumerators[3].MoveNext())
{
for (int i = 0; i < 4; ++i)
{
yield return(enumerators[i].Current);
enumerators[i].MoveNext();
yield return(enumerators[i].Current);
}
}
}
foreach (Point p in source.FinalPointsAtChebyshevDistance(distance, clockwise, orthoDir))
{
yield return(p);
}
}
else
{
Dir8 currentDir = startDir;
for (int i = 0; i < 8; ++i)
{
foreach (Point p in source.PointsInOctantAtChebyshevDistance(distance, clockwise, currentDir))
{
yield return(p);
}
currentDir = currentDir.Rotate(clockwise);
}
}
}
public static Dir4 AddAngles(Dir4 dir1, Dir4 dir2)
{
// dir1 is validated by Dir4.Rotate
if (!dir2.Validate())
{
throw new ArgumentOutOfRangeException(nameof(dir2), dir2, "Invalid enum value.");
}
if (dir1 == Dir4.None || dir2 == Dir4.None)
{
return(Dir4.None);
}
return(dir1.Rotate((int)dir2));
}
public static IEnumerable <Dir4> Enumerate(bool clockwise, bool includeNeutral, Dir4 startDir = Dir4.N)
{
if (includeNeutral)
{
yield return(Dir4.Neutral);
}
for (int i = 0; i < 4; ++i)
{
yield return(startDir);
startDir = startDir.Rotate(clockwise);
}
}
public static Dir4 Rotate(this Dir4 dir, bool clockwise, int times)
{
if (dir == Dir4.Neutral)
{
return(Dir4.Neutral);
}
if (times < 0)
{
times = -times;
clockwise = !clockwise;
}
for (int i = 0; i < times; ++i)
{
dir = dir.Rotate(clockwise);
}
return(dir);
}
private static IEnumerable <Point> PointsAtManhattanDistanceInternal(
this Point source, int distance, bool clockwise, Dir4 startDir)
{
if (distance == 0)
{
yield return(source);
yield break;
}
Dir4 currentDir = startDir;
for (int i = 0; i < 4; ++i)
{
foreach (Point p in source.PointsInQuadrantAtManhattanDistance(distance, clockwise, currentDir))
{
yield return(p);
}
currentDir = currentDir.Rotate(clockwise);
}
}
private static IEnumerable <Point> StartingPointsAtChebyshevDistance(
this Point source, int distance, bool clockwise, Dir4 startDir)
{
Dir4 currentDir = startDir;
for (int i = 0; i < 4; ++i)
{
switch (currentDir)
{
case Dir4.N: yield return(new Point(source.X, source.Y + distance)); break;
case Dir4.E: yield return(new Point(source.X + distance, source.Y)); break;
case Dir4.S: yield return(new Point(source.X, source.Y - distance)); break;
case Dir4.W: yield return(new Point(source.X - distance, source.Y)); break;
}
currentDir = currentDir.Rotate(clockwise);
}
}
private static IEnumerable <Point> FinalPointsAtChebyshevDistance(
this Point source, int distance, bool clockwise, Dir4 startDir)
{
// Get the appropriate corner:
Dir8 diagDir = ((Dir8)startDir).Rotate(clockwise);
Dir4 currentDir = (Dir4)diagDir; // Use 4-way rotation around the diagonals
for (int i = 0; i < 4; ++i)
{
switch ((Dir8)currentDir)
{
case Dir8.NE: yield return(new Point(source.X + distance, source.Y + distance)); break;
case Dir8.SE: yield return(new Point(source.X + distance, source.Y - distance)); break;
case Dir8.SW: yield return(new Point(source.X - distance, source.Y - distance)); break;
case Dir8.NW: yield return(new Point(source.X - distance, source.Y + distance)); break;
}
currentDir = currentDir.Rotate(clockwise);
}
}
