507 lines
17 KiB
C#
507 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using static MinesweeperControl.GameDescription;
|
|
|
|
namespace MinesweeperControl {
|
|
/*
|
|
* This class describes a game of minesweeper
|
|
*/
|
|
public class MinesweeperGame {
|
|
|
|
public enum ActionType { Clear, Flag, Chord, Dead };
|
|
public enum GameStatus { NotStarted, InPlay, Won, Lost };
|
|
public enum ResultType { Cleared, Flagged, Hidden, Exploded, Mine, FlaggedWrong };
|
|
|
|
// describes the actions being perform in the gane
|
|
public class GameAction {
|
|
|
|
public readonly int x;
|
|
public readonly int y;
|
|
public readonly ActionType action;
|
|
|
|
public GameAction(int x, int y, ActionType action) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.action = action;
|
|
}
|
|
|
|
public String AsText() {
|
|
return "(" + x + "," + y + ") " + action;
|
|
}
|
|
}
|
|
|
|
// describes the result of the actions on the game
|
|
public class GameResult {
|
|
|
|
public readonly GameStatus status;
|
|
public readonly List<ActionResult> actionResults;
|
|
|
|
public GameResult(GameStatus status, List<ActionResult> actionResults) {
|
|
this.status = status;
|
|
this.actionResults = actionResults;
|
|
}
|
|
|
|
}
|
|
|
|
// describes the result of actions being perform in the gane
|
|
public class ActionResult {
|
|
|
|
public readonly int x;
|
|
public readonly int y;
|
|
public readonly ResultType resultType;
|
|
public readonly int value;
|
|
|
|
internal ActionResult(int x, int y, ResultType resultType) : this(x, y, resultType, 0) {
|
|
}
|
|
|
|
internal ActionResult(int x, int y, ResultType resultType, int value) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.resultType = resultType;
|
|
this.value = value;
|
|
}
|
|
}
|
|
|
|
|
|
// game variables
|
|
public readonly GameDescription description;
|
|
public readonly int seed; // seed to use to build the game
|
|
|
|
private readonly int[] adjacentOffset = new int[8];
|
|
|
|
private GameStatus gameStatus = GameStatus.NotStarted;
|
|
private int tilesLeft;
|
|
private MinesweeperTile[] tiles;
|
|
private int minesLeft;
|
|
|
|
private readonly bool hardcore;
|
|
private int deaths = 0;
|
|
|
|
public MinesweeperGame(GameDescription description, int seed) : this(description, seed, true) {
|
|
}
|
|
|
|
public MinesweeperGame(GameDescription description, int seed, bool hardcore) {
|
|
|
|
if (seed == 0) {
|
|
this.seed = new Random().Next(1, Int32.MaxValue);
|
|
} else {
|
|
this.seed = seed;
|
|
}
|
|
|
|
this.description = description;
|
|
this.hardcore = hardcore;
|
|
|
|
// create adjacent offsets
|
|
adjacentOffset[0] = -description.width - 1;
|
|
adjacentOffset[1] = -description.width;
|
|
adjacentOffset[2] = -description.width + 1;
|
|
adjacentOffset[3] = -1;
|
|
adjacentOffset[4] = 1;
|
|
adjacentOffset[5] = +description.width - 1;
|
|
adjacentOffset[6] = +description.width;
|
|
adjacentOffset[7] = +description.width + 1;
|
|
|
|
tilesLeft = this.description.height * this.description.width - this.description.mines;
|
|
minesLeft = description.mines;
|
|
|
|
// create all the tiles. the mines get placed at the first clear.
|
|
CreateTiles();
|
|
|
|
}
|
|
|
|
public int GetMinesLeft() {
|
|
return minesLeft;
|
|
}
|
|
|
|
public int GetDeaths() {
|
|
return deaths;
|
|
}
|
|
|
|
public GameStatus GetGameStatus() {
|
|
return this.gameStatus;
|
|
}
|
|
|
|
public GameResult ProcessActions<T>(IList<T> actions) where T : GameAction { // accept any Array of classes extending GameAction
|
|
|
|
//long start = DateTime.Now.Ticks;
|
|
|
|
List<ActionResult> actionResults = new List<ActionResult>();
|
|
|
|
foreach (GameAction action in actions) {
|
|
|
|
if (gameStatus != GameStatus.Lost && gameStatus != GameStatus.Won) { // only process actions while the game is in play
|
|
if (action.action == ActionType.Clear) {
|
|
actionResults.AddRange(ClearTile(action));
|
|
} else if (action.action == ActionType.Flag) {
|
|
actionResults.AddRange(FlagTile(action));
|
|
} else if (action.action == ActionType.Chord) {
|
|
actionResults.AddRange(ChordTile(action));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
GameStatus finalStatus = gameStatus; // take the game status for the game
|
|
|
|
if (gameStatus == GameStatus.Lost) {
|
|
|
|
for (var i = 0; i < this.tiles.Length; i++) {
|
|
MinesweeperTile tile = this.tiles[i];
|
|
if (tile.IsMine() && !tile.IsFlagged() && !tile.GetExploded()) {
|
|
actionResults.Add(new ActionResult(tile.GetX(), tile.GetY(), ResultType.Mine)); // show remaining mines
|
|
}
|
|
if (!tile.IsMine() && tile.IsFlagged()) {
|
|
actionResults.Add(new ActionResult(tile.GetX(), tile.GetY(), ResultType.FlaggedWrong)); // show flags placed wrong
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//Write("Game processing actions took " + (DateTime.Now.Ticks - start) + " ticks");
|
|
|
|
return new GameResult(finalStatus, actionResults);
|
|
|
|
}
|
|
|
|
private List<ActionResult> FlagTile(GameAction action) {
|
|
|
|
List<ActionResult> actionResults = new List<ActionResult>();
|
|
|
|
int index = GetIndex(action.x, action.y);
|
|
|
|
MinesweeperTile tile = this.tiles[index];
|
|
|
|
// if the tile is covered then toggle the flag and return it's new state
|
|
if (tile.IsCovered()) {
|
|
tile.ToggleFlagged();
|
|
if (tile.IsFlagged()) {
|
|
actionResults.Add(new ActionResult(action.x, action.y, ResultType.Flagged));
|
|
minesLeft--;
|
|
} else {
|
|
if (tile.GetExploded()) {
|
|
actionResults.Add(new ActionResult(action.x, action.y, ResultType.Exploded));
|
|
} else {
|
|
actionResults.Add(new ActionResult(action.x, action.y, ResultType.Hidden));
|
|
}
|
|
|
|
minesLeft++;
|
|
}
|
|
}
|
|
|
|
return actionResults;
|
|
|
|
}
|
|
|
|
|
|
// clicks the assigned tile and returns an object containing a list of tiles cleared
|
|
private List<ActionResult> ClearTile(GameAction action) {
|
|
|
|
List<ActionResult> actionResults = new List<ActionResult>();
|
|
|
|
int index = GetIndex(action.x, action.y);
|
|
|
|
// if this is the first click then create the tiles and place the mines
|
|
if (this.gameStatus == GameStatus.NotStarted) {
|
|
PlaceMines(index);
|
|
}
|
|
|
|
MinesweeperTile tile = this.tiles[index];
|
|
|
|
// are we clicking on a flag
|
|
if (tile.IsFlagged()) {
|
|
Write("Unable to Clear: Clicked on a Flag");
|
|
|
|
} else if (tile.GetExploded()) {
|
|
Write("Unable to Clear: Clicked on an exploded Mine");
|
|
|
|
} else if (tile.IsMine()) {
|
|
//Write("Gameover: Clicked on a mine");
|
|
|
|
deaths++;
|
|
if (hardcore) {
|
|
this.gameStatus = GameStatus.Lost;
|
|
}
|
|
tile.SetExploded(true);
|
|
actionResults.Add(new ActionResult(action.x, action.y, ResultType.Exploded));
|
|
|
|
} else {
|
|
if (tile.IsCovered()) { // make sure the tile is clickable
|
|
|
|
List<MinesweeperTile> tilesToReveal = new List<MinesweeperTile>();
|
|
tilesToReveal.Add(tile);
|
|
|
|
actionResults.AddRange(Reveal(tilesToReveal));
|
|
|
|
}
|
|
}
|
|
|
|
return actionResults;
|
|
|
|
}
|
|
|
|
// chord the assigned tile and returns an object containing a list of tiles cleared
|
|
private List<ActionResult> ChordTile(GameAction action) {
|
|
|
|
List<ActionResult> actionResults = new List<ActionResult>();
|
|
|
|
int index = GetIndex(action.x, action.y);
|
|
|
|
// if this is the first click then create the tiles and place the mines
|
|
if (this.gameStatus == GameStatus.NotStarted) {
|
|
PlaceMines(index);
|
|
}
|
|
|
|
MinesweeperTile tile = this.tiles[index];
|
|
|
|
int flagCount = 0;
|
|
int hiddenCount = 0;
|
|
foreach (int adjIndex in GetAdjacentIndex(index)) {
|
|
if (tiles[adjIndex].IsFlagged()) {
|
|
flagCount++;
|
|
} else if (tiles[adjIndex].IsCovered()) {
|
|
hiddenCount++;
|
|
}
|
|
}
|
|
|
|
// If the hidden count is zero then there is nothing to do
|
|
if (hiddenCount == 0) {
|
|
Write("Unable to Chord: Nothing to clear");
|
|
return actionResults;
|
|
}
|
|
|
|
// nothing to do if the tile is not yet surrounded by the correct number of flags
|
|
if (tile.GetValue() != flagCount) {
|
|
Write("Unable to Chord: value=" + tile.GetValue() + " flags=" + flagCount);
|
|
return actionResults;
|
|
}
|
|
|
|
// see if there are any unflagged bombs in the area to be chorded - this loses the game
|
|
var bombCount = 0;
|
|
foreach (int adjIndex in GetAdjacentIndex(index)) {
|
|
MinesweeperTile adjTile = tiles[adjIndex];
|
|
if (adjTile.IsMine() && !adjTile.IsFlagged()) {
|
|
adjTile.SetExploded(true);
|
|
actionResults.Add(new ActionResult(adjTile.GetX(), adjTile.GetY(), ResultType.Exploded)); // mark the tile as exploded
|
|
bombCount++;
|
|
}
|
|
}
|
|
|
|
// if we have triggered a bomb then return
|
|
if (bombCount != 0) {
|
|
deaths = deaths + bombCount;
|
|
if (hardcore) {
|
|
this.gameStatus = GameStatus.Lost;
|
|
}
|
|
return actionResults;
|
|
}
|
|
|
|
// seems okay, so do the chording
|
|
List<MinesweeperTile> tilesToReveal = new List<MinesweeperTile>();
|
|
|
|
// determine which tiles need revealing
|
|
foreach (int adjIndex in this.GetAdjacentIndex(index)) {
|
|
MinesweeperTile adjTile = tiles[adjIndex];
|
|
if (adjTile.IsCovered() && !adjTile.IsFlagged()) { // covered and not flagged
|
|
tilesToReveal.Add(adjTile);
|
|
}
|
|
}
|
|
|
|
actionResults.AddRange(Reveal(tilesToReveal));
|
|
|
|
return actionResults;
|
|
|
|
}
|
|
|
|
// takes a list of tiles and reveals them and expands any zeros
|
|
private List<ActionResult> Reveal(List<MinesweeperTile> firstTiles) {
|
|
|
|
List<ActionResult> actionResults = new List<ActionResult>();
|
|
|
|
var soFar = 0;
|
|
|
|
foreach (MinesweeperTile firstTile in firstTiles) {
|
|
firstTile.SetCovered(false);
|
|
}
|
|
|
|
int safety = 1000000;
|
|
|
|
while (soFar < firstTiles.Count) {
|
|
|
|
MinesweeperTile tile = firstTiles[soFar];
|
|
|
|
actionResults.Add(new ActionResult(tile.GetX(), tile.GetY(), ResultType.Cleared, tile.GetValue()));
|
|
|
|
this.tilesLeft--;
|
|
|
|
// if the value is zero then for each adjacent tile not yet revealed add it to the list
|
|
if (tile.GetValue() == 0) {
|
|
|
|
foreach (int adjIndex in GetAdjacentIndex(tile.GetIndex())) {
|
|
|
|
MinesweeperTile adjTile = this.tiles[adjIndex];
|
|
|
|
if (adjTile.IsCovered() && !adjTile.IsFlagged()) { // if not covered and not a flag
|
|
adjTile.SetCovered(false); // it will be uncovered in a bit
|
|
firstTiles.Add(adjTile);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
soFar++;
|
|
if (safety-- < 0) {
|
|
Write("MinesweeperGame: Reveal Safety limit reached !!");
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
// if there are no tiles left to find then set the remaining tiles to flagged and we've won
|
|
if (this.tilesLeft == 0) {
|
|
for (var i = 0; i < this.tiles.Length; i++) {
|
|
MinesweeperTile tile = this.tiles[i];
|
|
if (tile.IsMine() && !tile.IsFlagged()) {
|
|
|
|
minesLeft--;
|
|
tile.ToggleFlagged();
|
|
actionResults.Add(new ActionResult(tile.GetX(), tile.GetY(), ResultType.Flagged)); // auto set remaining flags
|
|
|
|
}
|
|
}
|
|
|
|
this.gameStatus = GameStatus.Won;
|
|
|
|
}
|
|
|
|
return actionResults;
|
|
}
|
|
|
|
// converts X and Y position to an Index
|
|
private int GetIndex(int x, int y) {
|
|
return y * this.description.width + x;
|
|
}
|
|
|
|
// create the tiles
|
|
private void CreateTiles() {
|
|
|
|
//long start = DateTime.Now.Ticks;
|
|
|
|
tiles = new MinesweeperTile[this.description.width * this.description.height];
|
|
|
|
// create the tiles and store non-excluded indices into a list
|
|
for (int y = 0; y < this.description.height; y++) {
|
|
for (int x = 0; x < this.description.width; x++) {
|
|
|
|
int i = GetIndex(x, y);
|
|
tiles[i] = new MinesweeperTile(i, x, y);
|
|
|
|
}
|
|
}
|
|
|
|
//Write("Ticks to create MinesweeperTiles " + (DateTime.Now.Ticks - start));
|
|
}
|
|
|
|
// builds all the tiles and assigns bombs to them
|
|
private void PlaceMines(int firstIndex) {
|
|
|
|
//long start = DateTime.Now.Ticks;
|
|
|
|
// hold the tiles to exclude from being a mine
|
|
HashSet<int> excludedIndices = new HashSet<int>();
|
|
excludedIndices.Add(firstIndex);
|
|
|
|
// for a zero start game all the adjacent tile can't be mines either
|
|
if (this.description.gameType == GameType.Zero) {
|
|
foreach (int adjIndex in GetAdjacentIndex(firstIndex)) {
|
|
excludedIndices.Add(adjIndex);
|
|
}
|
|
}
|
|
|
|
// create a list of all included indices
|
|
List<int> indices = new List<int>();
|
|
for (int y = 0; y < this.description.height; y++) {
|
|
for (int x = 0; x < this.description.width; x++) {
|
|
|
|
int i = GetIndex(x, y);
|
|
if (!excludedIndices.Contains(i)) {
|
|
indices.Add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// shuffle the indices using a seed
|
|
indices.Shuffle(seed);
|
|
|
|
// allocate the mines and calculate the values
|
|
for (int i = 0; i < description.mines; i++) {
|
|
int index = indices[i];
|
|
MinesweeperTile tile = tiles[index];
|
|
|
|
//Utility.Write("Setting " + tile.AsText() + " to be a mine");
|
|
tile.SetMine(true); // this is set to be a mine
|
|
|
|
// set each affected tile to have an increased 'value'
|
|
foreach (int adjIndex in GetAdjacentIndex(tile.GetIndex())) {
|
|
tiles[adjIndex].IncrementValue();
|
|
}
|
|
}
|
|
|
|
this.gameStatus = GameStatus.InPlay;
|
|
|
|
//Write("Ticks to place mines on MinesweeperTiles " + (DateTime.Now.Ticks - start));
|
|
}
|
|
|
|
// returns all the indices adjacent to this index
|
|
private List<int> GetAdjacentIndex(int index) {
|
|
|
|
int col = index % description.width;
|
|
int row = index / description.width;
|
|
|
|
int first_row = Math.Max(0, row - 1);
|
|
int last_row = Math.Min(description.height - 1, row + 1);
|
|
|
|
int first_col = Math.Max(0, col - 1);
|
|
int last_col = Math.Min(description.width - 1, col + 1);
|
|
|
|
List<int> result = new List<int>();
|
|
|
|
for (int r = first_row; r <= last_row; r++) {
|
|
for (int c = first_col; c <= last_col; c++) {
|
|
int i = description.width * r + c;
|
|
if (i != index) {
|
|
result.Add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private void Write(String text) {
|
|
Console.WriteLine(text);
|
|
}
|
|
|
|
}
|
|
|
|
public static class Shuffler {
|
|
|
|
// shuffle a given array
|
|
public static void Shuffle<T>(this IList<T> list, int seed) {
|
|
|
|
Random rng = new Random(seed);
|
|
|
|
int n = list.Count;
|
|
while (n > 1) {
|
|
n--;
|
|
int k = rng.Next(n + 1);
|
|
T value = list[k];
|
|
list[k] = list[n];
|
|
list[n] = value;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|