public override void OnAddComponent(ref WrappingScreenGrid grid, int owner, GameState gameState)
{
var mineField =
((MineFieldSystem)gameState.ComponentSystems[typeof(MineFieldSystem)])
.GetComponents()[0]; // Bad, fix this someday.
RecalculateAll(ref grid, mineField);
}
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 RecalculateAll(ref WrappingScreenGrid grid, MineField mineField)
{
for (var x = 0; x < grid.Width; x++)
{
for (var y = 0; y < grid.Height; y++)
{
var fieldCoordinate = new Point(x % mineField.Width, y % mineField.Height);
grid.FrameGrid[x, y] = mineField.IsMine(fieldCoordinate)
? (byte)MineFrame.Mine
: (byte)CalculateAdjacents(mineField, fieldCoordinate);
}
}
}
private void RecalculateFrames(ref WrappingScreenGrid grid, MineField mineField, Point shift,
Vector2 cameraPosition)
{
grid.ShiftObserver(shift, out var wrappedBorder);
if (shift.X != 0)
{
RecalculateHorizontalFrames(ref grid, mineField, shift.X, wrappedBorder);
}
if (shift.Y != 0)
{
RecalculateVerticalFrames(ref grid, mineField, shift.Y, wrappedBorder);
}
}
private void RevealAdjacents(ref WrappingScreenGrid grid, MineField mineField, Point mineFieldTile,
Point screenTile)
{
for (var x = mineFieldTile.X - 1; x < mineFieldTile.X + 2; x++)
{
for (var y = mineFieldTile.Y - 1; y < mineFieldTile.Y + 2; y++)
{
if (x == mineFieldTile.X && y == mineFieldTile.Y)
{
continue;
}
if (mineField.WrapAround)
{
var xIndex = x % mineField.Width;
var yIndex = y % mineField.Height;
if (xIndex < 0)
{
xIndex += mineField.Width;
}
if (yIndex < 0)
{
yIndex += mineField.Height;
}
if (!mineField.IsRevealed(xIndex, yIndex))
{
var newScreenTile = screenTile + new Point(xIndex, yIndex) - mineFieldTile;
newScreenTile.X %= grid.Width;
newScreenTile.Y %= grid.Height;
if (newScreenTile.X < 0)
{
newScreenTile.X += grid.Width;
}
if (newScreenTile.Y < 0)
{
newScreenTile.Y += grid.Height;
}
RevealCell(ref grid, mineField, new Point(xIndex, yIndex), newScreenTile);
}
}
}
}
}
private void RevealCell(ref WrappingScreenGrid grid, MineField mineField, Point mineFieldTile, Point screenTile)
{
if (mineField.IsMine(mineFieldTile))
{
//Sprite mine = grid[screenTile.X, screenTile.Y];
//mine.SetFrames(10, 0);
//grid[screenTile.X, screenTile.Y] = mine;
//return;
}
var adjacentMines = CalculateAdjacents(mineField, mineFieldTile);
mineField.RevealCell(mineFieldTile);
//grid[screenTile.X, screenTile.Y].SetFrames(adjacentMines, 0);
//Sprite orig = grid[screenTile.X, screenTile.Y];
//orig.SetFrames(adjacentMines, 0);
//grid[screenTile.X, screenTile.Y] = orig;
if (adjacentMines == 0)
{
RevealAdjacents(ref grid, mineField, mineFieldTile, screenTile);
}
//int adjacentMines = CalculateAdjacents(tile, coordinates);
//for (int i = 0; i < cellComponents.Length; i++)
//{
// if (cellComponents[i] is Sprite)
// {
// ((Sprite)cellComponents[i]).SetFrames(adjacentMines, 0);
// }
//}
//if (adjacentMines == 0)
//{
// RevealAdjacents(ref tile, coordinates);
//}
}
private void RecalculateVerticalFrames(ref WrappingScreenGrid grid, MineField mineField, int yShift,
bool wrappedBorder)
{
if (yShift > 0)
{
// This means tiles on the bottom end side of the screen need to be recalculated.
// yScreenTile is the first tile that will need to be recalculated.
var yScreenTile = grid.YHead - yShift;
if (yScreenTile < 0)
{
yScreenTile = yScreenTile % grid.Height + grid.Height;
}
// The minefield tile index corresponding to this first screen tile.
var offset = wrappedBorder ? grid.YOffsetNorth : grid.YOffsetSouth;
var yMineTile = (offset + yScreenTile) % mineField.Height;
yScreenTile--;
yMineTile--;
for (var y = 0; y < yShift; y++)
{
if (++yMineTile >= mineField.Height)
{
yMineTile = 0;
}
if (++yScreenTile >= grid.Height)
{
yScreenTile = 0;
}
for (var x = 0; x < grid.Width; x++)
{
grid.FrameGrid[x, yScreenTile] = mineField.IsMine(x % mineField.Width, yMineTile)
? (byte)MineFrame.Mine
: (byte)CalculateAdjacents(mineField, new Point(x, yMineTile));
}
}
}
else if (yShift < 0)
{
var yScreenTile = grid.YHead;
// This is always YOffsetNorth for some stupid reason I don't understand.
var offset = grid.YOffsetNorth;
var yMineTile = (offset + yScreenTile) % mineField.Height;
yScreenTile++;
yMineTile++;
for (var y = 0; y > yShift; y--)
{
if (--yMineTile < 0)
{
yMineTile = mineField.Height - 1;
}
if (--yScreenTile < 0)
{
Debug.Assert(!wrappedBorder);
yScreenTile = grid.Height - 1;
}
for (var x = 0; x < grid.Width; x++)
{
grid.FrameGrid[x, yScreenTile] = mineField.IsMine(x % mineField.Width, yMineTile)
? (byte)MineFrame.Mine
: (byte)CalculateAdjacents(mineField, new Point(x, yMineTile));
}
}
}
}
private void RecalculateHorizontalFrames(ref WrappingScreenGrid grid, MineField mineField, int xShift,
bool wrappedBorder)
{
if (xShift > 0)
{
// This means tiles on the right end side of the screen need to be recalculated.
// xScreenTile is the first tile that will need to be recalculated.
var xScreenTile = grid.XHead - xShift;
if (xScreenTile < 0)
{
xScreenTile = xScreenTile % grid.Width + grid.Width;
}
// The minefield tile index corresponding to this first screen tile.
var offset = wrappedBorder ? grid.XOffsetWest : grid.XOffsetEast;
var xMineTile = (offset + xScreenTile) % mineField.Width;
xScreenTile--;
xMineTile--;
for (var x = 0; x < xShift; x++)
{
if (++xMineTile >= mineField.Width)
{
xMineTile = 0;
}
if (++xScreenTile >= grid.Width)
{
xScreenTile = 0;
}
for (var y = 0; y < grid.Height; y++)
{
grid.FrameGrid[xScreenTile, y] = mineField.IsMine(xMineTile, y % mineField.Height)
? (byte)MineFrame.Mine
: (byte)CalculateAdjacents(mineField, new Point(xMineTile, y));
}
}
}
else if (xShift < 0)
{
var xScreenTile = grid.XHead;
// This is always XOffsetWest for some stupid reason I don't understand.
var offset = grid.XOffsetWest;
var xMineTile = (offset + xScreenTile) % mineField.Width;
xScreenTile++;
xMineTile++;
for (var x = 0; x > xShift; x--)
{
if (--xMineTile < 0)
{
xMineTile = mineField.Width - 1;
}
if (--xScreenTile < 0)
{
Debug.Assert(!wrappedBorder);
xScreenTile = grid.Width - 1;
}
for (var y = 0; y < grid.Height; y++)
{
grid.FrameGrid[xScreenTile, y] = mineField.IsMine(xMineTile, y % mineField.Height)
? (byte)MineFrame.Mine
: (byte)CalculateAdjacents(mineField, new Point(xMineTile, y));
}
}
}
}
protected override void UpdateComponent(ref WrappingScreenGrid grid, int index, UpdateInfo updateInfo)
{
// Recalculate frames if necessary.
var cameraPosition = (Vector2)updateInfo.State.CameraPosition;
var oldCoordinates = (oldCameraPosition / grid.CellSize).ToPoint();
var newCoordinates = (cameraPosition / grid.CellSize).ToPoint();
var coordinateShift = newCoordinates - oldCoordinates;
var mineField = ((MineFieldSystem)updateInfo.State.ComponentSystems[typeof(MineFieldSystem)])
.GetComponents()[0]; // Bad, fix this someday.
if (coordinateShift.X % mineField.Width != 0 || coordinateShift.Y % mineField.Height != 0)
{
RecalculateFrames(ref grid, mineField, coordinateShift, cameraPosition);
}
oldCameraPosition = cameraPosition;
//
var input = updateInfo.Input;
var cursorMineFieldTile = GetCursorTile(grid.Position, grid.CellSize,
(Vector2)updateInfo.State.CameraPosition, input.MouseScreenPosition);
var cursorScreenTile =
((input.MouseScreenPosition + grid.Position) / grid.CellSize)
.ToPoint(); // Not exactly right, will do for now.
if (mineField.WrapAround)
{
if (cursorMineFieldTile.X < 0)
{
cursorMineFieldTile.X += grid.Width;
}
if (cursorMineFieldTile.Y < 0)
{
cursorMineFieldTile.Y += grid.Height;
}
cursorMineFieldTile.X %= mineField.Width;
cursorMineFieldTile.Y %= mineField.Height;
}
if (false && input.IsMousePressed(MouseButtons.LMB))
{
if (safeClick)
{
OffsetPointToBlankTile(ref grid, mineField, ref cursorMineFieldTile);
safeClick = false;
}
if (!mineField.IsRevealed(cursorMineFieldTile))
{
RevealCell(ref grid, mineField, cursorMineFieldTile, cursorScreenTile);
}
}
if (input.IsMousePressed(MouseButtons.RMB))
{
Console.WriteLine(cursorMineFieldTile);
}
//Sprite orig = grid[cursorMineFieldTile.X, cursorMineFieldTile.Y];
//orig.SetFrames(orig.FrameX == 11 ? 12 : 11, 0);
// MineFrame frame = (MineFrame)mineGrid.Cells[cursorTile.X, cursorTile.Y].Batch.GetComponent<Sprite>().FrameX;
// if (frame == MineFrame.Unknown)
// {
// mineGrid.Cells[cursorTile.X, cursorTile.Y].Batch.GetComponent<Sprite>().SetFrames((int)MineFrame.Flag, 0);
// }
// else if (frame == MineFrame.Flag)
// {
// mineGrid.Cells[cursorTile.X, cursorTile.Y].Batch.GetComponent<Sprite>().SetFrames((int)MineFrame.Unknown, 0);
// }
base.UpdateComponent(ref grid, index, updateInfo);
}
