private void OffsetPointToBlankTile(ref WrappingScreenGrid grid, MineField mineField, ref Point coordinates)
{
var searchCoordinates = coordinates;
var maskIndex = mineField.GetMaskIndex(coordinates);
var tileFound = false;
for (var maxAdjacents = 1; maxAdjacents < 9; maxAdjacents++)
{
do
{
searchCoordinates.X++;
if (searchCoordinates.X >= mineField.Width)
{
searchCoordinates.X = 0;
searchCoordinates.Y++;
if (searchCoordinates.Y >= mineField.Height)
{
searchCoordinates.Y = 0;
}
if (searchCoordinates.Y % BitMaskGrid.Size == 0)
{
maskIndex += mineField.MasksPerRow;
}
}
if (searchCoordinates.X % BitMaskGrid.Size == 0)
{
maskIndex++;
if (maskIndex >= mineField.MaskAmount)
{
maskIndex = 0;
}
}
if (!mineField.MineMasks[maskIndex][searchCoordinates.X, searchCoordinates.Y] &&
CalculateAdjacents(mineField, searchCoordinates) < maxAdjacents)
{
var offset = coordinates - searchCoordinates; // Swap?
grid.ShiftObserver(offset, out var wrappedBorder);
coordinates = searchCoordinates;
tileFound = true;
break;
}
} while (searchCoordinates != coordinates);
if (tileFound)
{
break;
}
}
}
//private void ShiftFrames(ref ScreenTextureGrid grid, int shiftX, int shiftY)
//{
// int directionX, directionY;
// int gridStartX, gridStartY, gridEndX, gridEndY;
// if (shiftX <= 0)
// {
// directionX = 1;
// gridStartX = 0;
// gridEndX = grid.Width + shiftX;
// }
// else
// {
// directionX = -1;
// gridStartX = grid.Width - 1;
// gridEndX = shiftX - 1;
// }
// if (shiftY <= 0)
// {
// directionY = 1;
// gridStartY = 0;
// gridEndY = grid.Height + shiftY;
// }
// else
// {
// directionY = -1;
// gridStartY = grid.Height - 1;
// gridEndY = shiftY - 1;
// }
// for (int x = gridStartX; x != gridEndX; x += directionX)
// {
// for (int y = gridStartY; y != gridEndY; y += directionY)
// {
// grid[x, y] = grid[x - shiftX, y - shiftY];
// }
// }
//}
private void BufferSearchVertical(ArrayGrid <Sprite> grid, MineField mineField, Vector2 cameraPosition,
int shiftX, int shiftY)
{
int startX, endX;
if (shiftX <= 0)
{
startX = grid.Width - 1;
endX = startX + shiftX;
}
else
{
startX = 0;
endX = shiftX;
}
var searchBuffer = new bool[9];
var bufferHead = 0;
var mineMasks = mineField.MineMasks;
var revealMasks = mineField.RevealMasks;
var startCoordinate = ((-mineField.Position + cameraPosition) / grid.TileSize).ToPoint();
startCoordinate.X %= mineField.Width;
startCoordinate.Y %= mineField.Height;
var bufferTopLeftCoordinate = startCoordinate - new Point(1);
if (bufferTopLeftCoordinate.X < 0)
{
bufferTopLeftCoordinate.X += mineField.Width;
}
if (bufferTopLeftCoordinate.Y < 0)
{
bufferTopLeftCoordinate.Y += mineField.Height;
}
var maskIndex =
mineField.GetMaskIndex(
bufferTopLeftCoordinate); // The index of the mask our start tile is in (top left corner of buffer).
for (var x = 0; x < shiftX; x++) // For all (now) empty columns
{
var mineCount = 0;
// First, we put the six tiles above our first sample tile into the buffer.
var bufferCoordinate = startCoordinate;
for (var bufferY = -1; bufferY < 1;)
{
bufferCoordinate.Y = startCoordinate.Y + bufferY;
if (bufferCoordinate.Y < 0)
{
bufferCoordinate.Y += mineField.Height;
}
else if (bufferCoordinate.Y >= mineField.Height)
{
bufferCoordinate.Y -= mineField.Height;
}
var line = mineMasks[maskIndex][bufferCoordinate.Y % BitMaskGrid.Size];
var resetMaskIndex = false;
for (var bufferX = 0; bufferX < 3;)
{
bufferCoordinate.X = bufferTopLeftCoordinate.X + bufferX;
if (bufferCoordinate.X >= mineField.Width)
{
bufferCoordinate.X -= mineField.Width;
}
var isMine =
(line & (BitMaskGrid.MostSignificantBitOnly >> (bufferCoordinate.X % BitMaskGrid.Size))) !=
0;
searchBuffer[bufferHead++] = isMine;
if (isMine)
{
mineCount++;
}
if ((++bufferX + startCoordinate.X) % BitMaskGrid.Size == 0)
{
maskIndex++;
if (maskIndex % mineField.MasksPerRow == 0)
{
maskIndex -= mineField.MasksPerRow;
}
resetMaskIndex = true;
}
}
if (resetMaskIndex)
{
if (maskIndex % mineField.MasksPerRow == 0)
{
maskIndex += mineField.MasksPerRow;
}
maskIndex--;
}
if ((++bufferY + startCoordinate.Y) % BitMaskGrid.Size == 0)
{
maskIndex += mineField.MasksPerRow;
if (maskIndex >= mineField.MaskAmount)
{
maskIndex %= mineField.MasksPerRow;
}
}
}
bufferCoordinate.Y = startCoordinate.Y;
for (var y = 0; y < grid.Height;)
{
var line = mineMasks[maskIndex][bufferCoordinate.Y];
var resetMaskIndex = false;
for (var lineX = 0; lineX < 3;)
{
bufferCoordinate.X = startCoordinate.X + lineX;
if (bufferCoordinate.X < 0)
{
bufferCoordinate.X += mineField.Width;
}
else if (bufferCoordinate.X >= mineField.Width)
{
bufferCoordinate.X -= mineField.Width;
}
var isMine = (line & (BitMaskGrid.MostSignificantBitOnly >>
((startCoordinate.X + lineX) % BitMaskGrid.Size))) != 0;
if (isMine ^ searchBuffer[bufferHead])
{
if (isMine)
{
mineCount++;
}
else
{
mineCount--;
}
}
searchBuffer[bufferHead++] = isMine;
if (bufferHead > 8)
{
bufferHead = 0;
}
if ((++lineX + startCoordinate.X) % BitMaskGrid.Size == 0)
{
maskIndex++;
if (maskIndex % mineField.MasksPerRow == 0)
{
maskIndex -= mineField.MasksPerRow;
}
resetMaskIndex = true;
}
}
var orig = grid[x, y];
orig.SetFrames(mineField.IsRevealed(bufferCoordinate) ? mineCount : 12, 0);
grid[x, y] = orig;
if (mineCount == 0)
{
}
if (resetMaskIndex)
{
if (maskIndex % mineField.MasksPerRow == 0)
{
maskIndex += mineField.MasksPerRow;
}
maskIndex--;
}
if (++y + startCoordinate.Y % BitMaskGrid.Size == 0)
{
maskIndex += mineField.MasksPerRow;
if (maskIndex >= mineField.MaskAmount)
{
maskIndex %= mineField.MasksPerRow;
}
}
bufferCoordinate.Y++;
if (bufferCoordinate.Y >= mineField.Height)
{
bufferCoordinate.Y -= mineField.Height;
}
}
}
}