public void Test_HasMinesLeftShouldReturnTrueWhenMinesCountGreaterThanZero()
{
var field = new GameField(10);
field.MinesCount = 2;
var result = field.HasMinesLeft();
Assert.AreEqual(true, result);
}
public void Test_HasMinesLeftShouldReturnFalseWhenMinesCountLessThanZero()
{
var field = new GameField(10);
field.MinesCount = -2;
var result = field.HasMinesLeft();
Assert.AreEqual(false, result);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameWindow" /> class
/// </summary>
/// <param name="fieldSize">The size of the game field</param>
/// <param name="isExplosionChained">Used to determine if explosions will chain</param>
public GameWindow(int fieldSize, bool isExplosionChained)
{
this.InitializeComponent();
ICellDamageHandler damageHandler = new DefaultDamageHandler();
var renderer = new WpfRenderer(this);
var engine = new Engine(renderer, damageHandler);
this.engine = engine;
var field = new GameField(fieldSize, isExplosionChained);
this.engine.Init(field);
}
public void Test_EngineReturnsCorrectGameDataObjectToBeStoredInCaretaker()
{
var mockedRenderer = new Mock<IRenderer>();
var mockedDamageHandler = new Mock<ICellDamageHandler>();
var gameField = new GameField(5);
var engine = new Engine(mockedRenderer.Object, mockedDamageHandler.Object);
engine.Init(gameField);
var caretaker = new GameDataCaretaker();
caretaker.GameData = engine.CreateMemento();
Assert.AreSame(caretaker.GameData.DamageHandler, mockedDamageHandler.Object, "Engine damage handler is not the same as the stored in memento");
Assert.AreSame(caretaker.GameData.GameField, gameField, "Engine game field is not the same as the stored in memento");
Assert.AreEqual(caretaker.GameData.MovesCount, engine.MovesCount, "Engine moves count is not equal to the stored in memento");
}
/// <summary>
/// Starts a new game.
/// </summary>
public void Start()
{
this.renderer.ShowWelcome();
this.renderer.ShowFieldSizePrompt();
int fieldSize = this.inputProvider.GetFieldSize();
GameField field = new GameField(fieldSize);
this.engine.Init(field);
this.renderer.ShowNamePrompt();
string playerName = this.inputProvider.GetPlayerName();
HighscoreLogger.Instance.AddHighscore(playerName, this.engine.MovesCount);
this.renderer.ShowHighscores();
}
public void Test_EngineUpdateFieldWithInvalidPositionShouldCallRendererShowError()
{
var firstPosition = new Position(0, 0);
var setOfPosition = new HashSet<Position>();
setOfPosition.Add(firstPosition);
var mockedRenderer = new Mock<IRenderer>();
var mockedDamageHandler = new Mock<ICellDamageHandler>();
var mockedRandomGenerator = new Mock<IRandomGenerator>();
mockedRandomGenerator.Setup(x => x.GetUniquePointsBetween(It.IsAny<int>(), It.IsAny<Position>(), It.IsAny<Position>())).Returns(setOfPosition);
mockedRandomGenerator.Setup(x => x.GetRandomBetween(It.IsAny<int>(), It.IsAny<int>())).Returns(1);
var gameField = new GameField(mockedRandomGenerator.Object, new RandomMineFactory(), 8);
var engine = new Engine(mockedRenderer.Object, mockedDamageHandler.Object);
engine.Init(gameField);
engine.UpdateField(new Position(0, 1));
mockedRenderer.Verify(x => x.ShowErrorMessage(It.IsAny<string>()), Times.Once());
}
public void Test_EngineRestoresGameDataFromMemento()
{
var mockedRenderer = new Mock<IRenderer>();
var mockedDamageHandler = new Mock<ICellDamageHandler>();
var mockedDamageHandlerToBeReplaced = new Mock<ICellDamageHandler>();
var gameField = new GameField(5);
var gameFieldToBeReplaced = new GameField(4);
int movesCount = 10;
var gameData = new GameData(gameField, movesCount, mockedDamageHandler.Object);
var engine = new Engine(mockedRenderer.Object, mockedDamageHandlerToBeReplaced.Object);
engine.Init(gameFieldToBeReplaced);
engine.SetMemento(gameData);
var newGameData = engine.CreateMemento();
Assert.AreSame(newGameData.DamageHandler, mockedDamageHandler.Object, "Engine damage handler is not the same as the stored in memento");
Assert.AreSame(newGameData.GameField, gameField, "Engine game field is not the same as the stored in memento");
Assert.AreEqual(newGameData.MovesCount, 10, "Engine moves count is not equal to the stored in memento");
}
public void Test_IsInRangeShouldReturnTrueWithValidPosition()
{
var field = new GameField(10);
var result = field.IsInRange(new Position(0, 0));
Assert.AreEqual(true, result);
}
public void Test_IsInRangeShouldReturnFalseWithInvalidPositionPositiveRowCol()
{
var field = new GameField(10);
var result = field.IsInRange(new Position(11, 11));
Assert.AreEqual(false, result);
}
public void Test_GameFieldShouldThrowWithInvalidCoordinates(int X, int Y)
{
var field = new GameField(5);
var cell = field[X, Y];
}
public void Test_GameFieldShouldReturnCellWithValidCoordinates(int X, int Y)
{
var field = new GameField(5);
var cell = field[X, Y];
Assert.IsInstanceOf<Cell>(cell, "Game field does not return a valid cell object");
}
/// <summary>
/// Updates the UI grid component
/// </summary>
/// <param name="field">Object containing the information about the cell content</param>
public void RefreshGameField(GameField field)
{
this.UpdateField(this.grid, field);
}
/// <summary>
/// Updates the background images of the <see cref="CellButton" /> in the grid
/// </summary>
/// <param name="grid">Object containing instances of <see cref="CellButton" /></param>
/// <param name="field">Object containing information about the cell content</param>
private void UpdateField(Grid grid, GameField field)
{
for (int row = 0; row < field.RowsCount; row++)
{
for (int col = 0; col < field.ColumnsCount; col++)
{
this.UpdateCellStatus(grid, row, col, field[row, col].IsDestroyed);
}
}
}
/// <summary>
/// Initializes grid element and populates it with <see cref="CellButton" />
/// </summary>
/// <param name="field">Object containing the information about the cell content</param>
/// <param name="gridWidth">Value that specifies the max width of the grid element</param>
/// <param name="gridHeigth">Value that specifies the max height of the grid element</param>
/// <returns>Window grid element</returns>
private Grid CreateGridElement(GameField field, int gridWidth, int gridHeigth)
{
var fieldRowCount = field.RowsCount;
var fieldColCount = field.ColumnsCount;
var grid = new Grid();
grid.MaxWidth = gridWidth;
grid.MaxHeight = gridHeigth;
for (int i = 0; i < fieldRowCount; i++)
{
RowDefinition rowdef = new RowDefinition();
grid.RowDefinitions.Add(rowdef);
}
for (int i = 0; i < fieldColCount; i++)
{
ColumnDefinition coldef = new ColumnDefinition();
grid.ColumnDefinitions.Add(coldef);
}
CellButton cell;
for (int row = 0; row < fieldRowCount; row++)
{
for (int col = 0; col < fieldColCount; col++)
{
if (field[row, col] is Mine)
{
cell = new CellButton(row, col, CellStatus.WithMine);
var mineType = this.GetMineRepresentaion(field[row, col]);
cell.Background = this.brush.GetBrush(mineType);
}
else
{
cell = new CellButton(row, col, CellStatus.Normal);
cell.Background = this.brush.GetBrush("Dirt");
}
cell.Click += new RoutedEventHandler(this.HandleMouseDown);
grid.Children.Add(cell);
Grid.SetRow(cell, row);
Grid.SetColumn(cell, col);
}
}
return grid;
}
/// <summary>
/// Initializes grid element and appends it to the window
/// </summary>
/// <param name="field">Object containing the information about the cell content</param>
public void ShowGameField(GameField field)
{
Border border = new Border();
border.BorderThickness = new Thickness(10);
border.BorderBrush = Brushes.White;
this.grid = this.CreateGridElement(field, GridWidth, GridHeight);
border.Child = this.grid;
this.window.Content = border;
}
