public static void ThrowsExceptionIfSectorSizeIsOutOfBounds(
Array2D <byte> source,
byte[,] destination,
Bounds2D sectorSize,
Index2D destIndex)
=> Assert.Throws <ArgumentOutOfRangeException>(
() => source.CopyTo(destination, sectorSize, destIndex));
public static void ThrowsExceptionIfSourceIndexIsOutOfBounds(
Array2D <byte> src, Index2D srcIndex)
=> Assert.Throws <ArgumentOutOfRangeException>(
() => src.CopyTo(
srcIndex,
new byte[src.Rows, src.Columns],
new Bounds2D(),
new Index2D()));
public static void ThrowsExceptionIfSectorSizeIsOutOfBounds <T>(
Array2D <T> src,
Index2D srcIndex,
Array2D <T> dest,
Bounds2D sectorSize,
Index2D destIndex)
=> Assert.Throws <ArgumentOutOfRangeException>(
() => src.CopyTo(srcIndex, dest, sectorSize, destIndex));
public static void Test(
Array2D <int> src,
int[,] dest,
Bounds2D sectorSize,
Index2D destIndex,
int[,] expected)
{
src.CopyTo(dest, sectorSize, destIndex);
CollectionAssert.AreEqual(expected, dest);
}
public static void Test <T>(
Array2D <T> src,
Array2D <T> dest,
Bounds2D sectorSize,
Index2D destIndex,
Array2D <T> expected)
{
src.CopyTo(dest, sectorSize, destIndex);
CollectionAssert.AreEqual(expected, dest);
}
public static void Test(Array2D <int> src, int[,] dest, int[,] expected)
{
src.CopyTo(dest);
CollectionAssert.AreEqual(expected, dest);
}
public static void ThrowsExceptionIfDestArrayCannotAccommodateAllElements(
Array2D <byte> source, byte[,] destination)
=> Assert.Throws <ArgumentException>(() => source.CopyTo(destination));
private Level GenerateLevelBlob(State state, int size, Array2D<Cell> designData, Array2D<bool> designFixed, out int designRow, out int designColumn)
{
// Inflate size for extra cells to be subtracted.
int blobSize = size * (density + 100) / 100;
// Create larger work array and corresponding fixed map.
Array2D<Cell> array = new Array2D<Cell>(2 * size, 2 * size);
array.SetAll(Cell.Outside);
Array2D<bool> arrayFixed = new Array2D<bool>(array.Height, array.Width);
// Adjust design data so that outside or undefined cells are empty.
Array2D<Cell> designDataCopy = new Array2D<Cell>(designData);
designDataCopy.Replace(Cell.Outside, Cell.Empty);
designDataCopy.Replace(Cell.Undefined, Cell.Empty);
// Copy design into middle of work array.
designRow = size;
designColumn = size;
designDataCopy.CopyTo(array, designRow + 1, designColumn + 1, 1, 1, designData.Height - 2, designData.Width - 2);
designFixed.CopyTo(arrayFixed, designRow + 1, designColumn + 1, 1, 1, designData.Height - 2, designData.Width - 2);
// Set intial boundaries.
int rowMin = array.Height;
int colMin = array.Width;
int rowMax = -1;
int colMax = -1;
int count = 0;
foreach (Coordinate2D coord in array.Coordinates)
{
if (!Level.IsOutside(array[coord]))
{
rowMin = Math.Min(rowMin, coord.Row);
colMin = Math.Min(colMin, coord.Column);
rowMax = Math.Max(rowMax, coord.Row);
colMax = Math.Max(colMax, coord.Column);
count++;
}
}
while (count < blobSize)
{
// Choose an edge at random.
int edge = state.Random.Next(4);
int row = 0;
int column = 0;
int limit = 0;
int hIncr = 0;
int vIncr = 0;
switch (edge)
{
case 0:
row = rowMin - 1;
column = colMin + state.Random.Next(colMax - colMin + 1);
limit = rowMax - rowMin + 1;
vIncr = 1;
hIncr = 0;
break;
case 1:
row = rowMax + 1;
column = colMin + state.Random.Next(colMax - colMin + 1);
limit = rowMax - rowMin + 1;
vIncr = -1;
hIncr = 0;
break;
case 2:
row = rowMin + state.Random.Next(rowMax - rowMin + 1);
column = colMin - 1;
limit = colMax - colMin + 1;
vIncr = 0;
hIncr = 1;
break;
case 3:
row = rowMin + state.Random.Next(rowMax - rowMin + 1);
column = colMax + 1;
limit = colMax - colMin + 1;
vIncr = 0;
hIncr = -1;
break;
}
// Search along a line until we hit a empty or fixed cell.
bool found = false;
for (int i = 0; i < limit; i++)
{
if (array[row + vIncr, column + hIncr] != Cell.Outside || arrayFixed[row + vIncr, column + hIncr])
{
if (!arrayFixed[row, column])
{
found = true;
}
break;
}
row += vIncr;
column += hIncr;
}
// If we didn't find anything, try again.
if (!found)
{
continue;
}
// Don't allow the level to grow outside the array.
if (row < 1 || row >= array.Height - 1 || column < 1 || column >= array.Width - 1)
{
continue;
}
// Add the new square and update the boundaries.
array[row, column] = Cell.Empty;
rowMin = Math.Min(rowMin, row);
colMin = Math.Min(colMin, column);
rowMax = Math.Max(rowMax, row);
colMax = Math.Max(colMax, column);
count++;
}
int attemptsLeft = 2 * (count - size);
while (count > size && attemptsLeft > 0)
{
// Choose a new square at random.
int row = rowMin + state.Random.Next(rowMax - rowMin + 1);
int column = colMin + state.Random.Next(colMax - colMin + 1);
Coordinate2D coord = new Coordinate2D(row, column);
if (!array.IsValid(coord))
{
continue;
}
// Avoid existing walls and outside areas.
if (!Level.IsInside(array[coord]))
{
continue;
}
// We might get into an infinite loop.
attemptsLeft--;
// Avoid fixed cells.
if (arrayFixed[coord])
{
continue;
}
// Avoid cells on the perimeter.
bool isAdjacent = false;
foreach (Coordinate2D neighbor in coord.EightNeighbors)
{
if (array[neighbor] == Cell.Outside)
{
isAdjacent = true;
break;
}
}
if (isAdjacent)
{
continue;
}
// Remove the cell.
array[coord] = Cell.Wall;
count--;
}
// Extract the constructed level.
Array2D<Cell> subarray = array.GetSubarray(rowMin - 1, colMin - 1, rowMax - rowMin + 3, colMax - colMin + 3);
subarray.Replace(Cell.Outside, Cell.Wall);
Level level = new Level(subarray);
// Adjust design coordinate.
designRow -= rowMin - 1;
designColumn -= colMin - 1;
return level;
}
private Level GenerateLevelBuckshot(State state, int size, Array2D<Cell> designData, Array2D<bool> designFixed, out int designRow, out int designColumn)
{
// Create larger work array and corresponding fixed map.
Array2D<Cell> array = new Array2D<Cell>(2 * size + designData.Height, 2 * size + designData.Width);
array.SetAll(Cell.Wall);
Array2D<bool> arrayFixed = new Array2D<bool>(array.Height, array.Width);
// Adjust design data so that undefined cells are walls.
Array2D<Cell> designDataCopy = new Array2D<Cell>(designData);
designDataCopy.Replace(Cell.Undefined, Cell.Wall);
// Copy design into middle of work array.
designRow = size;
designColumn = size;
designDataCopy.CopyTo(array, designRow, designColumn, 0, 0, designData.Height, designData.Width);
designFixed.CopyTo(arrayFixed, designRow, designColumn, 0, 0, designData.Height, designData.Width);
// Set intial boundaries.
int rowMin = array.Height;
int colMin = array.Width;
int rowMax = -1;
int colMax = -1;
int count = 0;
foreach (Coordinate2D coord in array.Coordinates)
{
if (!Level.IsWall(array[coord]))
{
rowMin = Math.Min(rowMin, coord.Row);
colMin = Math.Min(colMin, coord.Column);
rowMax = Math.Max(rowMax, coord.Row);
colMax = Math.Max(colMax, coord.Column);
count++;
}
}
while (count < size)
{
// Choose a new square at random.
int row = rowMin - growth + state.Random.Next(rowMax - rowMin + 1 + 2 * growth);
int column = colMin - growth + state.Random.Next(colMax - colMin + 1 + 2 * growth);
Coordinate2D coord = new Coordinate2D(row, column);
if (!array.IsValid(coord))
{
continue;
}
// Avoid fixed cells.
if (arrayFixed[coord])
{
continue;
}
// Avoid existing squares.
if (!Level.IsWall(array[coord]))
{
continue;
}
// Ensure the new square is adjacent to an existing square.
bool isAdjacent = false;
foreach (Coordinate2D neighbor in coord.FourNeighbors)
{
if (!Level.IsWall(array[neighbor]))
{
isAdjacent = true;
break;
}
}
if (!isAdjacent)
{
continue;
}
// Add the new square and update the boundaries.
array[coord] = Cell.Empty;
rowMin = Math.Min(rowMin, row);
colMin = Math.Min(colMin, column);
rowMax = Math.Max(rowMax, row);
colMax = Math.Max(colMax, column);
count++;
}
// Extract the constructed level.
Array2D<Cell> subarray = array.GetSubarray(rowMin - 1, colMin - 1, rowMax - rowMin + 3, colMax - colMin + 3);
Level level = new Level(subarray);
// Adjust design coordinate.
designRow -= rowMin - 1;
designColumn -= colMin - 1;
return level;
}
public static void Test <T>(
Array2D <T> src, Array2D <T> dest, Array2D <T> expected)
{
src.CopyTo(dest);
CollectionAssert.AreEqual(expected, dest);
}
public static void ThrowsExceptionIfDestArrayCannotAccommodateAllElements <T>(
Array2D <T> source, Array2D <T> destination, Index2D destIndex)
=> Assert.Throws <ArgumentException>(
() => source.CopyTo(destination, destIndex));
public static void ThrowsExceptionIfSectorSizeIsOutOfBounds <T>(
Array2D <T> source, Array2D <T> destination, Bounds2D sectorSize)
=> Assert.Throws <ArgumentOutOfRangeException>(
() => source.CopyTo(destination, sectorSize));
