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); }