public void SolverCanWinGamesButNotAll(string title, int rowStart, int colStart, GameState finalState, int rows, int cols, int[] minedCellsPositions)
{
var minedCells = new List<MineCell>();
for (int i = 0; i < minedCellsPositions.Length; i += 2)
{
minedCells.Add(new MineCell(minedCellsPositions[i], minedCellsPositions[i + 1]));
}
var mineField = new MineField(rows, cols, minedCells.ToArray());
var solver = new Solver(mineField);
mineField.UncoverCell(rowStart, colStart);
solver.UncoverGrid();
Assert.Equal(mineField.GameState, finalState);
mineField.Reset(true);
mineField.UncoverCell(rowStart, colStart);
for (var i = 0; i < 100 && mineField.GameState == GameState.InProgress; i++)
{
solver.PlayNextStep();
}
Assert.Equal(finalState, mineField.GameState);
}
public int PutMines(MineField mineField, int clickCellX, int clickCellY, Random random)
{
var x = clickCellX;
var y = clickCellY;
var generatedMines = 0;
bool CheckAround(int i, int j) =>
j != x && i != y && // Same as clicked
j - 1 != x && j + 1 != x && // X offsets
i + 1 != y && j - 1 != y; // Y offsets
while (generatedMines < mineField.TotalMines)
{
for (int i = 0; i < mineField.Height; i++)
{
for (int j = 0; j < mineField.Width; j++)
{
if (generatedMines >= mineField.TotalMines)
{
continue;
}
if (CheckAround(i, j) &&
mineField.Cells[i, j].Type != FieldCellType.Mine && random.Next(1, mineField.Height * mineField.Width) == 1)
{
mineField.Cells[i, j].Type = FieldCellType.Mine;
mineField.Cells[i, j].IsOpen = true;
generatedMines++;
}
}
}
}
return(generatedMines);
}
public void DontWinfAllFlagArePlacedOnBombAndCellNotRevelated()
{
var game = MineField.Create(5, 10);
game.OfType <UndiscoveredCell>().Where(a => a.HasBomb).ForEach(cell => game.PoseFlag(cell));
game.Win.Should().BeFalse();
}
//flag a button on a right mouse click
public void FlagButton(KeyValuePair <int, Button> button, MineField mineField)
{
Button currentButton = button.Value;
//get the space we are working with
Space space = new Space();
foreach (KeyValuePair <int, Space> currentSpace in mineField.Spaces)
{
if (currentSpace.Key == button.Key)
{
space = currentSpace.Value;
}
}
if (space.Flagged)
{
currentButton.Image = null;
space.Flagged = false;
mineField.ReturnFlag();
}
else
{
if (mineField.GetFlag() >= 1)
{
currentButton.Image = Resource1.Flag;
space.Flagged = true;
}
}
}
public Tile(MineField mf, int x, int y, bool hasBomb)
{
this.x = x;
this.y = y;
this.hasBomb = hasBomb;
mineField = mf;
}
private void ApplyCommand(int commandOrder, string command)
{
string[] commandArgs = command.Split(' ');
switch (commandOrder)
{
case 0: // Initialize MineField
MineField = _mineFieldService.Initialize(commandArgs);
break;
case 1: // Initialize Mines
_mineService.Initialize(commandArgs).ForEach(x =>
{
MineField.ValidateCoordinates(new Coordinate(x.X, x.Y));
MineField.SetItemCoordinates(new Coordinate(x.X, x.Y), x);
});
break;
case 2: // Initialize Exit
var mine = _exitService.Initialize(commandArgs);
MineField.ValidateCoordinates(new Coordinate(mine.X, mine.Y));
MineField.SetItemCoordinates(new Coordinate(mine.X, mine.Y), mine);
break;
case 3: // Initialize Turtle
Turtle = _turtleService.Initialize(commandArgs);
MineField.ValidateCoordinates(new Coordinate(Turtle.Point.X, Turtle.Point.Y));
break;
case 4: // Series of Move - Rotate Actions
_gameService.StartGame(MineField, Turtle, commandArgs);
break;
}
}
internal virtual void ValidateExit(MineField mineField, Tile exit)
{
Throw.If <MineFieldInitializationException>(() =>
exit.PositionX < 0 || exit.PositionY < 0 || exit.TileType != TileType.Exit);
Throw.If <MineFieldInitializationException>(() =>
exit.PositionX >= mineField.TilesX || exit.PositionY >= mineField.TilesY);
}
//recursively clear buttons that contain minefield spaces with a zero mineCount
public void ClearZeroMineCounts(Space currentSpace, MineField mineField)
{
if (currentSpace.GetMineCount() == 0)
{
foreach (KeyValuePair <int, Point> location in currentSpace.parameter)
{
KeyValuePair <int, Space> adjacentSpace = mineField.GetSpace(location.Value);
if (adjacentSpace.Value != null && buttonMap[adjacentSpace.Key].Enabled)
{
buttonMap[adjacentSpace.Key].Enabled = false;
buttonMap[adjacentSpace.Key].BackColor = Color.Chocolate;
mineField.MoveCloserToWinCondition();
if (adjacentSpace.Value.GetMineCount() != 0)
{
buttonMap[adjacentSpace.Key].Text = adjacentSpace.Value.GetMineCount().ToString();
}
if (adjacentSpace.Value.GetMineCount() == 0)
{
//recursive call
ClearZeroMineCounts(adjacentSpace.Value, mineField);
}
}
}
}
}
public int PutMines(MineField mineField, int clickCellX, int clickCellY, Random random)
{
var generatedMines = 0;
while (generatedMines < mineField.TotalMines)
{
for (int i = 0; i < mineField.Height; i++)
{
for (int j = 0; j < mineField.Width; j++)
{
if (generatedMines >= mineField.TotalMines)
{
continue;
}
if (j != clickCellX && i != clickCellY &&
mineField.Cells[i, j].Type != FieldCellType.Mine && random.Next(1, mineField.Height * mineField.Width) == 1)
{
mineField.Cells[i, j].Type = FieldCellType.Mine;
generatedMines++;
}
}
}
}
return(generatedMines);
}
public void PoseFlagOnUndiscoveredCell()
{
var game = MineField.Create(5, 10);
game.PoseFlag(1, 1);
game[1, 1].Should().BeAssignableTo <FlaggedCell>();
}
public void SolverCanWinGamesButNotAll(string title, int rowStart, int colStart, GameState finalState, int rows, int cols, int[] minedCellsPositions)
{
var minedCells = new List <MineCell>();
for (int i = 0; i < minedCellsPositions.Length; i += 2)
{
minedCells.Add(new MineCell(minedCellsPositions[i], minedCellsPositions[i + 1]));
}
var mineField = new MineField(rows, cols, minedCells.ToArray());
var solver = new Solver(mineField);
mineField.UncoverCell(rowStart, colStart);
solver.UncoverGrid();
Assert.Equal(mineField.GameState, finalState);
mineField.Reset(true);
mineField.UncoverCell(rowStart, colStart);
for (var i = 0; i < 100 && mineField.GameState == GameState.InProgress; i++)
{
solver.PlayNextStep();
}
Assert.Equal(finalState, mineField.GameState);
}
public void ShowGameState()
{
var game = MineField.Create(5, 10);
game.Should().HaveCount(25);
game.Should().AllBeAssignableTo <UndiscoveredCell>();
}
public void DontThrowErrorIfRevealIsOutOfIndex(int row, int columns)
{
var game = MineField.Create(5, 10);
game.Reveal(row, columns);
game.Should().AllBeAssignableTo <UndiscoveredCell>();
}
public void Construct()
{
// Arrange
var sut = new MineField(4, 4);
// Assert
sut.Cells.Length.Should().Be(4 * 4);
}
public GameServiceTests()
{
_gameService = new GameService();
MineField = new MineField(1, 2);
MineField.ItemCoordinates.Add("[0,2]", new Exit(0, 2));
MineField.ItemCoordinates.Add("[1,1]", new Mine(1, 1));
Turtle = new Turtle(0, 0, Direction.N);
}
public void DontPoseMoreFlagsThanBombs()
{
var game = MineField.Create(5, 10);
game.ForEach(cell => game.PoseFlag(cell));
game.FlaggedCellCount.Should().Be(10);
}
public void SetBombs([Range(3, 5)] int bombCount)
{
// Arrange
var sut = new MineField(4, 4, bombCount);
// Assert
sut.Cells.Where(x => x.IsBomb).Count().Should().Be(bombCount);
}
public void RevealEmptyCell()
{
var game = MineField.Create(5, 10);
var emptyCell = game.OfType <UndiscoveredCell>().First(a => !a.HasBomb);
game.Reveal(emptyCell);
game[emptyCell].Should().BeAssignableTo <EmptyCell>();
}
public void WinfOnlyIfAllFlagArePlacedOnBombAndCellRevelated()
{
var game = MineField.Create(5, 10);
game.OfType <UndiscoveredCell>().Where(a => a.HasBomb).ForEach(cell => game.PoseFlag(cell));
game.OfType <UndiscoveredCell>().Where(a => !a.HasBomb).ForEach(cell => game.Reveal(cell));
game.Win.Should().BeTrue();
}
public void CreateFirstLevel()
{
var game = new Game();
MineField board = game.Start();
board.ZoneSize.Should().Be(3);
board.BombCount.Should().Be(1);
}
public void CreateMineField_WithListOfStringsAllEqualLength_IsCreated()
{
var testField = new MineField(new List <string> {
"..*", "...", ".*."
});
Assert.That(testField, Is.Not.Null);
}
public void MineField_SimpleLayout_GeneratesCorrectHintString()
{
var expectedHint = "01*1221*1";
var actualHint = new MineField(3, "..*....*.").GenerateHintString();
Assert.AreEqual(expectedHint, actualHint);
}
public void RevealABomb()
{
var game = MineField.Create(5, 10);
var trappedCell = game.OfType <UndiscoveredCell>().First(a => a.HasBomb);
game.Reveal(trappedCell);
game.Fail.Should().BeTrue();
}
public MineFieldScreen(Game game)
: base(game)
{
_field = new MineField(9, 9, 15, true, MinePutterDifficulty.Easy);
_gameStateManager = new GameStateManager();
_gameTimeHandler = new GameTimeHandler(_gameStateManager);
_scoreHandler = new ScoreHandlerTextFile("scores.json");
}
public void it_should_contain_elements()
{
var field = new MineField(3, 4, new List <string> {
"*...", "*.*.", "...."
});
var sweeper = new MineSweeper(field);
Assert.AreEqual(true, sweeper.GenerateSolution().Any());
}
public async Task LoadGameAsync(String path)
{
if (_dataAccess == null)
{
throw new InvalidOperationException("No data access is provided.");
}
_Field = await _dataAccess.LoadAsync(path);
}
public GameEngine(Settings settings)
{
_settings = settings;
var(width, height, turtleDirection, turtlePosition, exit, mines) = _settings;
var mineField = new MineField(width, height, mines, exit);
_turtle = new Turtle(turtlePosition, turtleDirection, mineField);
}
void Start()
{
int numberOfBombs = Mathf.FloorToInt((width * height) * bombsMultiplier);
Debug.Log("Number of bombs is: Floor(" + width + " * " + height + " * " + bombsMultiplier + ") = " + numberOfBombs);
field = new MineField(width, height, numberOfBombs);
field.RegisterTileChanged(OnTileChanged);
UpdateRemainingBombsText();
}
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;
}
}
}
protected void OnMineFieldCreated(MineField mineField)
{
if (SectorControllers != null)
{
DestroyMineField();
}
MineField = mineField;
BuildMineField();
}
private void StartNewGame()
{
_mineField = new MineField(_settings);
_mineField.OnGameOver += OnGameOver;
_mineField.OnGameWon += OnGameWon;
SetFace(_skin.DefaultFace);
flagsLeftLabel.Text = _mineField.FlagsLeft.ToString();
ResizeForm();
pictureBox1.DrawField(_mineField, _skin);
}
public void FirstMoveWithFlagUncoverTheFirstCell()
{
var firstMove = new MineCell(4, 4);
var minefield = new MineField(9, 9, 10);
minefield.UncoverCell(firstMove.Row, firstMove.Col);
Assert.Equal(GameState.InProgress, minefield.GameState);
var uncoveredCell = minefield.GetCell(firstMove.Row, firstMove.Col);
Assert.Equal(MineState.Uncovered, uncoveredCell.GetState());
Assert.Equal(0, uncoveredCell.NeighbourhoodMineCount);
}
public void UncoverMineCauseDefeat()
{
var minefield = new MineField(2, 2, new MineCell(1, 1));
minefield.UncoverCell(0, 0);
Assert.Equal(GameState.InProgress, minefield.GameState);
minefield.ToggleFlagOnCell(0, 1);
minefield.UncoverNeighbours(0, 0);
Assert.Equal(GameState.Defeat, minefield.GameState);
Assert.Equal(MineState.IncorrectlyFlagged, minefield.GetCell(0, 1).GetState());
Assert.Equal(MineState.MineDetonated, minefield.GetCell(1, 1).GetVisibleState(false));
}
public void TestInit()
{
_mineField = new MineField(5, 5);
}
