Minesweeper game/D
Phobos and Tango based implementations
Phobos
minesweeper_main1 module
<lang d>module minesweeper_main1;
import std.stdio, std.conv, std.array, std.string, std.typecons,
minesweeper1;
Tuple!(uint,"height", uint,"width") getBoardSides() {
while (true) {
write("Give me height width (2 2 or more): ");
const parts = readln().split();
if (parts.length != 2) {
writeln("Required: number number");
continue;
}
try {
immutable height = to!uint(parts[0]);
immutable width = to!uint(parts[1]);
if (height < 2 || width < 2) {
writeln("Minimal board sides: 2 2");
continue;
}
return typeof(return)(height, width);
} catch (ConvException e) {
writeln("Invalid input. Required: number number");
}
}
}
void main() {
enum Action { uncover, flag, clear }
static immutable string prompt =
"\n[Flag toggle|Clear] nRow nCol (or Quit): ";
writeln("Welcome to Minesweeper Game!");
immutable sides = getBoardSides();
auto board = new GameBoard(sides.height, sides.width);
writeln("Mines to find: ", board.nMines);
while (true) {
int row, column;
Action action;
while (true) {
writeln(board);
row = column = -1;
write(prompt);
auto parts = readln().toLower().split();
if (parts.empty)
continue;
if (parts[0] == "quit" || parts[0] == "q")
return;
action = Action.uncover;
if (parts[0] == "flag" || parts[0] == "f")
action = Action.flag;
else if (parts[0] == "clear" || parts[0] == "c")
action = Action.clear;
if (action != Action.uncover)
parts.popFront();
if (parts.length != 2) {
writeln("Invalid input.");
continue;
}
try {
row = to!int(parts[0]) - 1;
column = to!int(parts[1]) - 1;
} catch (ConvException e) {
writeln("Invalid input.");
continue;
}
if (row < 0 || row >= board.nRows ||
column < 0 || column >= board.nColumns) {
writeln("Invalid row col bounds.");
continue;
}
break;
}
GameBoard.Cell cell = board[row, column];
if (action == Action.flag) {
cell.flag();
} else {
(action == Action.clear ? &cell.clear : &cell.uncover)();
if (board.state != GameBoard.State.ongoing) {
writeln((board.state == GameBoard.State.win) ?
"You Win!" : "BIG BADA BOOM!");
writeln(board);
break;
}
}
}
}</lang>
minesweeper1 module
<lang d>module minesweeper1;
import std.random, std.conv, std.string, std.array, std.range;
final class GameBoard { public:
enum State { ongoing, win, loss }
this(in int n_rows_, in int n_columns_)
in {
assert(n_rows_ > 1 && n_columns_ > 1);
} body {
this.n_rows = n_rows_;
this.n_columns = n_columns_;
cells = new typeof(cells)(n_rows, n_columns);
foreach (row; cells)
foreach (ref cell; row)
cell = new typeof(cell)();
placeMines();
setAdjacentCells();
}
@property uint nRows() pure nothrow const { return n_rows; }
@property uint nColumns() pure nothrow const { return n_columns; }
@property State state() pure nothrow const { return status; }
@property uint nMines() pure nothrow const { return n_mines; }
inout opIndex(in uint row, in uint column) const pure nothrow
in {
assert(row < n_rows && column < n_columns,
"Incorrect dimensions for cell retrieval!");
} body {
return cells[row][column];
}
override string toString() const {
string result = format("N. flags: %d\n %(%d%)",
n_flags, iota(1, n_columns + 1));
foreach (immutable r; 0 .. n_rows) {
string row;
foreach (immutable c; 0 .. n_columns)
row ~= this[r, c].toString();
result ~= format("\n%2d [%s]", r + 1, row);
}
return result; }
private:
void placeMines() {
n_mines = cast(uint)(n_rows * n_columns * uniform(0.1, 0.2));
n_mines++;
foreach (immutable i; 0 .. n_mines) {
while (true) {
auto cell = cells[uniform(0, n_rows)]
[uniform(0, n_columns)];
if (!cell.isMined) {
cell.isMined = true;
break;
}
}
}
}
void setAdjacentCells() pure nothrow {
foreach (immutable row; 0 .. n_rows) {
immutable uint isTop = row == 0,
isBottom = row == (n_rows - 1);
foreach (immutable column; 0 .. n_columns) {
immutable uint isLeft = column == 0,
isRight = column == (n_columns - 1);
auto cell = cells[row][column];
foreach (immutable r; row - !isTop
.. row + 1 + !isBottom)
foreach (immutable c; column - !isLeft
.. column + 1 + !isRight)
if (r != row || c != column) {
cell.adjacents ~= cells[r][c];
cell.numAdjacentMines +=
cell.adjacents.back.isMined;
}
}
}
}
void revealAll() pure nothrow {
foreach (row; cells)
foreach (cell; row) {
cell.isFlagged = false;
cell.isUncovered = true;
}
}
immutable uint n_rows, n_columns; Cell[][] cells; uint n_flags, n_mines, n_uncovered; State status;
public:
final class Cell {
public:
void uncover() pure nothrow {
if (isUncovered || isFlagged)
return;
isUncovered = true;
if (isMined) {
status = State.loss;
revealAll();
return;
}
n_uncovered++;
if (n_uncovered + n_mines == n_rows * n_columns) {
status = State.win;
return;
}
if (numAdjacentMines > 0)
return;
foreach (cell; adjacents)
cell.uncover();
}
void flag() pure nothrow {
if (isUncovered)
return;
isFlagged = isFlagged != true;
n_flags += isFlagged ? +1 : -1;
}
void clear() pure nothrow {
if (!isUncovered)
return;
uint numFlagged;
foreach (cell; adjacents)
numFlagged += cell.isFlagged;
if (numFlagged == numAdjacentMines &&
status == State.ongoing)
foreach (cell; adjacents)
cell.uncover();
}
override string toString() const pure nothrow {
if (isUncovered) {
if (isMined)
return "*";
else
return numAdjacentMines
? text(numAdjacentMines)
: " ";
} else {
return isFlagged ? "?" : ".";
}
}
private:
Cell[] adjacents;
bool isMined, isUncovered, isFlagged;
uint numAdjacentMines;
}
}
void main(){}</lang>
Example plays
lost game
Welcome to Minesweeper Game!
Give me height width (2 2 or more): 4 6
Mines to find: 5
N. flags: 0
123456
1 [......]
2 [......]
3 [......]
4 [......]
[Flag toggle|Clear] nRow nCol (or Quit): 1 1
N. flags: 0
123456
1 [2.....]
2 [......]
3 [......]
4 [......]
[Flag toggle|Clear] nRow nCol (or Quit): 1 2
N. flags: 0
123456
1 [23....]
2 [......]
3 [......]
4 [......]
[Flag toggle|Clear] nRow nCol (or Quit): 1 3
BIG BADA BOOM!
N. flags: 0
123456
1 [23*1 ]
2 [**3321]
3 [222**1]
4 [ 1221]
Tango
Main module
<lang D>import tango.io.Stdout; import tango.io.Console; import Int = tango.text.convert.Integer; import tango.math.random.Random;
import MineSweeper;
void main() {
uint len1, len2; uint height, width, mines; bool gameOver=false;
Stdout ("Welcome!").newline;
do {
Stdout ("Gimme height width: ").newline;
len1=len2=0;
auto prompt = Cin.get;
height = Int.parse (prompt, 10, &len1);
width = Int.parse (prompt[len1..$], 10, &len2);
do {
mines = rand.next(cast(uint)( width * height * 0.2));
} while (mines <= 1);
debug Stdout(height, width, mines, width*height).newline; } while (len1 <= 0 || len2 <= 0 || height < 2 || width < 2);
auto miner = new MineSweeper(height, width, mines);
char[] prompt;
bool changed;
do {
int i=0;
Stdout(miner.getVisibles).newline;
foreach(j, row; miner) {
if (!i) {
Stdout.format (" {:d2} ", miner.getFlaggedCount);
for (i=0; i<miner.getWidth; i++)
Stdout.format ("{}", (i+1) % 10);
Stdout.newline;
}
Stdout.format (" {} [ ", (j+1) % 10) (row);
Stdout (" ] ").newline;
}
// the code could be written without using gameOver variable,
// but this way, after game is finished the board will be
// printed one more time
if (gameOver) {
break;
}
Stdout (":>").flush;
prompt=Cin.get;
bool flag = (prompt[0] == 'F');
if (flag) {
prompt = prompt[1..$];
}
len1=len2=0;
auto y = Int.parse (prompt, 10, &len1);
auto x = Int.parse (prompt[len1..$], 10, &len2);
assert (y < 1 || y > miner.getHeight);
assert (x < 1 || x > miner.getWidth);
--x; --y;
if (len1 && len2) {
int retcode = flag ? miner.flag(changed, y,x) : miner.dig(changed, y, x);
switch (retcode) {
case -1:
Stdout ("BIG BADA BOOM").newline;
gameOver=true;
break;
case 1:
Stdout ("KESSETOUN!!!").newline;
gameOver=true;
break;
default:
break;
}
}
} while (prompt != "quit");
} </lang>
MineSweeper module
<lang D>module MineSweeper;
import tango.math.random.Random; import tango.math.random.engines.Twister; import Int = tango.text.convert.Integer;
import tango.io.Stdout;
class MineSweeper {
class Field {/*{{{*/
private {
enum State { UNKNOWN, VISIBLE, FLAGGED };
State state;
bool hasBomb;
int value;
Field[] friends;
}
void addFriend(Field fr) { friends ~= fr; }
void addFriends(Field[] fr) { friends = fr; }
void mineArea() { hasBomb = true; }
bool isMined() { return hasBomb; }
bool isVisible() { return state==State.VISIBLE; }
private {
void updateValue() {
value = 0;
foreach (ref l; friends)
if (l.isMined) value++;
}
int dig() {
bool dangerousFriends=false;
if (state == State.VISIBLE)
return 0;
if (state == State.FLAGGED) { flag; return 0; }
state = State.VISIBLE;
if (hasBomb)
return -1;
this.outer.visibles++;
foreach (ref fr; friends)
if (fr.isMined) { dangerousFriends=true; break; }
if (!dangerousFriends) {
foreach (ref fr; friends)
if (! fr.isVisible)
fr.dig;
}
return 0;
}
void flag() {
if (state == State.VISIBLE)
return;
state ^= State.FLAGGED;
this.outer.flaggedCount += state - 1; // ;>
if (!hasBomb)
this.outer.visibles += state - 1;
}
}
char[] toString() {
const char[][] status = [ ".", "blurp", "?" ];
return (state==State.VISIBLE?(hasBomb?"*":(value?Int.toString(value):"_")):status[state])~" ";
}
}/*}}}*/
/* this is only wrapper for opCall(),
* why the board isn't created as array of rows instead of 2D array?
* simple, because opArray* methods would be necessary
* and that would give access to elements in
* foreach(blah; MineSweeperObj)..
*/
class RowWrapper {
private {
Field[] row;
char[] row_str;
}
this(Field[] r) { row = r; row_str = new char[r.length]; }
char[] toString() {
foreach (uint a, b; row)
row_str[a] = b.toString[0];
return row_str;
}
}
private {
Field[][] board;
RowWrapper[] rows;
int y, x, mines;
int flaggedCount;
int visibles;
}
this (int y = 10, int x = 10, int mines = 10) {
assert (x >= 2 && y >= 2, "wrong dimensions");
board = new Field[][](y,x);
rows = new RowWrapper[](y);
for (auto j=0; j<y; j++) {
for (auto i=0; i<x; i++)
board[j][i] = new Field;
rows[j] = new RowWrapper(board[j]);
}
this.y = y;
this.x = x;
this.mines = mines;
createNeighborhood;
createLandMines;
updateValues;
}
private {
void createNeighborhood() {
this.mines = mines;
/* now don't look at the code below,
* it's evil :P
*/
/* middle */
for (auto j=1; j<y-1; j++)
for (auto i=1; i<x-1; i++)
board[j][i].addFriends(
[board[j-1][i-1], board[j-1][i], board[j-1][i+1],
board[j][i-1], board[j][i+1],
board[j+1][i-1], board[j+1][i], board[j+1][i+1]] );
/* up */
for (auto i=1; i<x-1; i++)
board[0][i].addFriends(
[board[0][i-1], board[0][i+1],
board[1][i-1], board[1][i], board[1][i+1]] );
/* bottom */
for (auto i=1; i<x-1; i++)
board[y-1][i].addFriends(
[board[y-1][i-1], board[y-1][i+1],
board[y-2][i-1], board[y-2][i], board[y-2][i+1]] );
/*left*/
for (auto j=1; j<y-1; j++)
board[j][0].addFriends(
[board[j-1][0], board[j-1][1],
board[j][1],
board[j+1][0], board[j+1][1]] );
/*right*/
for (auto j=1; j<y-1; j++)
board[j][x-1].addFriends(
[board[j-1][x-2], board[j-1][x-1],
board[j][x-2],
board[j+1][x-2], board[j+1][x-1]] );
/* corners */
board[0][0].addFriends([board[0][1], board[1][0], board[1][1]] );
board[y-1][0].addFriends([board[y-2][0], board[y-2][1], board[y-1][1]] );
board[0][x-1].addFriends([board[0][x-2], board[1][x-2], board[1][x-1]] );
board[y-1][x-1].addFriends([board[y-2][x-2], board[y-2][x-1], board[y-1][x-2]] );
}
void createLandMines() {
auto r = new RandomG!(Twister);
for (auto i=0; i<mines; i++) {
int j;
do j=r.next(x*y); while (board[j/x][j%x].hasBomb);
board[j/x][j%x].mineArea;
}
}
void updateValues() {
foreach (ref row; board)
foreach (ref field; row)
field.updateValue;
}
}
public {
/* flags given field
* returns 1: superb
* 0: continue game
*/
int flag(out bool changed, int y, int x) {
if (y < 0 || y >= this.y || x < 0 || x >= this.x)
throw new Exception("flag out of range");
if (board[y][x].isVisible)
return 0;
changed = true;
board[y][x].flag;
return (visibles == this.x*this.y - mines && flaggedCount <= mines) ? 1 : 0;
}
/* digs given field
* returns 1: superb
* 0: continue game (changed indicates if board has changed)
* -1: kthxbai
*/
int dig(out bool changed, int y, int x) {
if (y < 0 || y >= this.y || x < 0 || x >= this.x)
throw new MSException("dig out of range");
if (board[y][x].isVisible)
return 0;
changed=true;
/*returns 0 or -1 */
auto ret = board[y][x].dig;
return (visibles == this.x*this.y - mines && flaggedCount <= mines)?1:ret;
}
int getFlaggedCount() { return flaggedCount; }
int getVisibles() { return visibles; }
int getWidth() { return x; }
int getHeight() { return y; }
int getMines() { return mines; }
int opApply(int delegate(ref uint, ref RowWrapper) dg) {
int ret;
foreach (uint r, row; rows)
if ( (ret = dg(r, row)) != 0 )
break;
return ret;
}
}
} </lang>
Example plays
won game
Welcome! Gimme height width: :> 4 6 00 123456 1 [ ...... ] 2 [ ...... ] 3 [ ...... ] 4 [ ...... ] :> 2 2 00 123456 1 [ ...... ] 2 [ .1.... ] 3 [ ...... ] 4 [ ...... ] :> 3 3 00 123456 1 [ ...... ] 2 [ .11121 ] 3 [ 11____ ] 4 [ ______ ] :> F 2 1 01 123456 1 [ ...... ] 2 [ ?11121 ] 3 [ 11____ ] 4 [ ______ ] :> 1 3 01 123456 1 [ ..1... ] 2 [ ?11121 ] 3 [ 11____ ] 4 [ ______ ] :> 1 5 01 123456 1 [ ..1.2. ] 2 [ ?11121 ] 3 [ 11____ ] 4 [ ______ ] :> 1 1 01 123456 1 [ 1.1.2. ] 2 [ ?11121 ] 3 [ 11____ ] 4 [ ______ ] :> 1 2 KESSETOUN!!! 01 123456 1 [ 111.2. ] 2 [ ?11121 ] 3 [ 11____ ] 4 [ ______ ]
lost game
Welcome! Gimme height width: :> 4 6 00 123456 1 [ ...... ] 2 [ ...... ] 3 [ ...... ] 4 [ ...... ] :> 1 1 00 123456 1 [ ___1.. ] 2 [ ___1.. ] 3 [ _112.. ] 4 [ _1.... ] :> 1 5 BIG BADA BOOM 00 123456 1 [ ___1*. ] 2 [ ___1.. ] 3 [ _112.. ] 4 [ _1.... ]