public void NegativeIndexUnevenShapedException()
{
// array -5 to 5, -5 to 3
CartesianArray<int> array = new CartesianArray<int>(11, 9, -5, -5);
FillArray(array);
Assert.AreEqual(array[15, 15], 0);
}
public static void FillArray(CartesianArray<int> array)
{
for (int x = array.XOffset; x < (array.XOffset + array.Width); x++)
{
for (int y = array.YOffset; y < (array.YOffset + array.Height); y++)
{
array[x, y] = x*y;
}
}
}
public void NegativeIndexUnevenShaped()
{
// array -5 to 5, -5 to 3
CartesianArray<int> array = new CartesianArray<int>(11, 9, -5, -5);
FillArray(array);
Assert.AreEqual(array[-5, -5], 25);
Assert.AreEqual(array[5, 3], 15);
Assert.AreEqual(array[0, 0], 0);
Assert.AreEqual(array[5, 1], 5);
Assert.AreEqual(array[3, 3], 9);
Assert.AreEqual(array[-5, 3], -15);
}
public void RotationTest()
{
CartesianArray<int> src = new CartesianArray<int>(11, 11, -5, -5);
CartesianArrayTester.FillArray(src);
PointRotator rotator = new PointRotator(90);
var result = rotator.Rotate(src);
Assert.AreEqual(result[-5, -5], -25);
Assert.AreEqual(result[3, -3], 9);
Assert.AreEqual(result[5, 5], -25);
Assert.AreEqual(result[5, -5], 25);
}
public void NegativeIndexTest()
{
// array -5 to 5
CartesianArray<int> array = new CartesianArray<int>(11, 11, -5, -5);
FillArray(array);
Assert.AreEqual(array[-5, -5], 25);
Assert.AreEqual(array[5, 5], 25);
Assert.AreEqual(array[0, 5], 0);
Assert.AreEqual(array[5, 0], 0);
Assert.AreEqual(array[1, 5], 5);
Assert.AreEqual(array[5, 1], 5);
Assert.AreEqual(array[0, 0], 0);
Assert.AreEqual(array[3, 2], 6);
}
public void RotationTestUnshapped()
{
CartesianArray<int> src = new CartesianArray<int>(11, 7, -5, -3);
CartesianArrayTester.FillArray(src);
src[5, -3] = int.MaxValue;
PointRotator rotator = new PointRotator(90);
var result = rotator.Rotate(src);
Assert.AreEqual(result.TopLeftCoordinate.X, -3);
Assert.AreEqual(result.TopLeftCoordinate.Y, 5);
Assert.AreEqual(result.BottomLeftCoordinate.X, -3);
Assert.AreEqual(result.BottomLeftCoordinate.Y, -5);
Assert.AreEqual(result.BottomRightCoordinate.X, 3);
Assert.AreEqual(result.BottomRightCoordinate.Y, -5);
Assert.AreEqual(src[2, 2], result[-2, 2]);
Assert.AreEqual(src[2, 3], result[-3, 2]);
}
private void SpawnShadow(CartesianArray<MapElementStatus> viewport, Point point, Area area, MapElementStatus elementType, double ratio, Modifiers modifier, bool increaseX)
{
int xdistance = 0;
int ydistance = 0;
bool first = true;
var curentPoint = new Point(point.X + xdistance, point.Y + ydistance);
Point lastPoint = null;
do
{
viewport[curentPoint] =
first ? elementType :
(viewport[curentPoint] == MapElementStatus.Undiscovered ? MapElementStatus.Shadowed: viewport[curentPoint] );
first = false;
if (increaseX)
{
xdistance += modifier.X;
ydistance = Convert.ToInt32(Math.Floor(ratio * xdistance * modifier.X * modifier.Y));
}
else
{
ydistance += modifier.Y;
xdistance = Convert.ToInt32(Math.Floor(ratio * ydistance * modifier.X * modifier.Y));
}
lastPoint = curentPoint;
curentPoint = new Point(point.X + xdistance, point.Y + ydistance);
if (Math.Abs(lastPoint.X - curentPoint.X) > 1 || Math.Abs(lastPoint.Y -curentPoint.Y) > 1)
{
}
} while (IsInbound(curentPoint, area));
}
private void SpawnShadow(CartesianArray<MapElementStatus> viewport, Point point, Area area, MapElementStatus elementType)
{
bool increaseX = Math.Abs(point.X) > Math.Abs(point.Y);
double ratio = 0.0;
var modifier = new Modifiers(point.X > 0 ? 1 : -1, point.Y > 0 ? 1 : -1);
if (point.X != 0 && point.Y != 0)
{
double x = Math.Abs(point.X);
double y = Math.Abs(point.Y);
ratio = Math.Abs(increaseX ? y / x : x / y);
}
SpawnShadow(viewport, point, area, elementType, ratio, modifier, increaseX);
}
private void SpawnShadow(CartesianArray<MapElementStatus> viewport, Point point, Area area, double direction)
{
double ratio = GetYRatio(direction);
bool increaseX = Math.Abs(ratio) < 1;
var modifier = GetModifiersForDirection(direction);
ratio = Math.Abs(increaseX ? ratio : 1/ratio);
SpawnShadow(viewport, point, area, MapElementStatus.Shadowed, ratio, modifier, increaseX);
}
private void HandlePoint(Queue<Point> queue, CartesianArray<MapElementStatus> viewport, Point point, Area area)
{
if (viewport[point] == MapElementStatus.Undiscovered)
{
queue.Enqueue(point);
viewport[point] = MapElementStatus.Discovered;
}
if (viewport[point] == MapElementStatus.Blocked || viewport[point] == MapElementStatus.Target)
{
SpawnShadow(viewport, point, area, GetStatusToSpawnFor(viewport[point]));
}
}
private void SetSensorAngleBoundaries(CartesianArray<MapElementStatus> map, Area area)
{
SpawnShadow(map, new Point(0, 0), area, (Robot.CartasianDirection + (Sight.Angle / 2)) % 360);
SpawnShadow(map, new Point(0, 0), area, (Robot.CartasianDirection - (Sight.Angle / 2)) % 360);
}
public CartesianArray<MapElementStatus> GetRobotCenteredMapCopy(Robot robot, CartesianArray<MapElementStatus> src)
{
var copy = src.Clone();
copy.XOffset = - robot.StartPosition.X;
copy.YOffset = - (src.Height - robot.StartPosition.Y);
return copy;
}
public void ToArray()
{
// [0] [2] [4]
// [0] [1] [2]
// [0] [0] [0]
var cartesianArray = new CartesianArray<int>(3, 3, 0, 0);
FillArray(cartesianArray);
var array = cartesianArray.ToArray();
Assert.AreEqual(array[0, 0], 0);
Assert.AreEqual(array[1, 0], 2);
Assert.AreEqual(array[2, 0], 4);
Assert.AreEqual(array[1, 1], 1);
Assert.AreEqual(array[2, 1], 2);
Assert.AreEqual(array[2, 2], 0);
Assert.AreEqual(array[0, 2], 0);
}
public void CloneTestUnlinked()
{
// X : -10 -> +14 ; Y : 10 -> 34
var cartesianArray = new CartesianArray<int>(25, 25, -10, 10);
var clonedArray = cartesianArray.Clone();
cartesianArray[-5, 10] = int.MaxValue;
clonedArray[5, 10] = int.MinValue;
Assert.AreNotEqual(cartesianArray[-5, 10], clonedArray[-5, 10]);
Assert.AreNotEqual(cartesianArray[5, 10], clonedArray[5, 10]);
cartesianArray.YOffset = 0;
clonedArray.XOffset = 0;
Assert.AreNotEqual(cartesianArray.YOffset, clonedArray.YOffset);
Assert.AreNotEqual(cartesianArray.XOffset, clonedArray.XOffset);
}
public void CloneTestMatching()
{
// X : -10 -> +14 ; Y : 10 -> 34
var cartesianArray = new CartesianArray<int>(25, 25, -10, 10);
var clonedArray = cartesianArray.Clone();
Assert.AreEqual(cartesianArray[-5, 15], clonedArray[-5, 15]);
Assert.AreEqual(cartesianArray[5, 25], clonedArray[5, 25]);
Assert.AreEqual(cartesianArray[10, 34], clonedArray[10, 34]);
Assert.AreEqual(cartesianArray[0, 10], clonedArray[0, 10]);
Assert.AreEqual(cartesianArray.BottomLeftCoordinate, clonedArray.BottomLeftCoordinate);
Assert.AreEqual(cartesianArray.BottomRightCoordinate, clonedArray.BottomRightCoordinate);
Assert.AreEqual(cartesianArray.TopLeftCoordinate, clonedArray.TopLeftCoordinate);
Assert.AreEqual(cartesianArray.TopRightCoordinate, clonedArray.TopRightCoordinate);
Assert.AreEqual(cartesianArray.YOffset, clonedArray.YOffset);
Assert.AreEqual(cartesianArray.XOffset, clonedArray.XOffset);
Assert.AreEqual(cartesianArray.Width, clonedArray.Width);
Assert.AreEqual(cartesianArray.Height, clonedArray.Height);
}
public static void StoreAsBitmap(string path, CartesianArray<MapElementStatus> data)
{
StoreAsBitmap(path, data.ToArray());
}
