Minesweeper
In this part of the Java 2D games tutorial, we will create a Minesweeper game clone.Minesweeper
Minesweeper is a popular board game shipped with many operating systems by default. The goal of the game is to sweep all mines from a mine field. If the player clicks on the cell which contains a mine, the mine detonates and the game is over. Further a cell can contain a number or it can be blank. The number indicates how many mines are adjacent to this particular cell. We set a mark on a cell by right clicking on it. This way we indicate, that we believe, there is a mine.The following Minesweeper clone is a modified and simplified version of an Java applet which I found at javaside.com.
Board.java
package mines;First we will define the constants used in our game.
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class Board extends JPanel {
private final int NUM_IMAGES = 13;
private final int CELL_SIZE = 15;
private final int COVER_FOR_CELL = 10;
private final int MARK_FOR_CELL = 10;
private final int EMPTY_CELL = 0;
private final int MINE_CELL = 9;
private final int COVERED_MINE_CELL = MINE_CELL + COVER_FOR_CELL;
private final int MARKED_MINE_CELL = COVERED_MINE_CELL + MARK_FOR_CELL;
private final int DRAW_MINE = 9;
private final int DRAW_COVER = 10;
private final int DRAW_MARK = 11;
private final int DRAW_WRONG_MARK = 12;
private int[] field;
private boolean inGame;
private int mines_left;
private Image[] img;
private int mines = 40;
private int rows = 16;
private int cols = 16;
private int all_cells;
private JLabel statusbar;
public Board(JLabel statusbar) {
this.statusbar = statusbar;
img = new Image[NUM_IMAGES];
for (int i = 0; i < NUM_IMAGES; i++) {
img[i] =
(new ImageIcon(this.getClass().getResource((i)
+ ".png"))).getImage();
}
setDoubleBuffered(true);
addMouseListener(new MinesAdapter());
newGame();
}
public void newGame() {
Random random;
int current_col;
int i = 0;
int position = 0;
int cell = 0;
random = new Random();
inGame = true;
mines_left = mines;
all_cells = rows * cols;
field = new int[all_cells];
for (i = 0; i < all_cells; i++)
field[i] = COVER_FOR_CELL;
statusbar.setText(Integer.toString(mines_left));
i = 0;
while (i < mines) {
position = (int) (all_cells * random.nextDouble());
if ((position < all_cells) &&
(field[position] != COVERED_MINE_CELL)) {
current_col = position % cols;
field[position] = COVERED_MINE_CELL;
i++;
if (current_col > 0) {
cell = position - 1 - cols;
if (cell >= 0)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
cell = position - 1;
if (cell >= 0)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
cell = position + cols - 1;
if (cell < all_cells)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
}
cell = position - cols;
if (cell >= 0)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
cell = position + cols;
if (cell < all_cells)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
if (current_col < (cols - 1)) {
cell = position - cols + 1;
if (cell >= 0)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
cell = position + cols + 1;
if (cell < all_cells)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
cell = position + 1;
if (cell < all_cells)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
}
}
}
}
public void find_empty_cells(int j) {
int current_col = j % cols;
int cell;
if (current_col > 0) {
cell = j - cols - 1;
if (cell >= 0)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
cell = j - 1;
if (cell >= 0)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
cell = j + cols - 1;
if (cell < all_cells)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
}
cell = j - cols;
if (cell >= 0)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
cell = j + cols;
if (cell < all_cells)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
if (current_col < (cols - 1)) {
cell = j - cols + 1;
if (cell >= 0)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
cell = j + cols + 1;
if (cell < all_cells)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
cell = j + 1;
if (cell < all_cells)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
}
}
public void paint(Graphics g) {
int cell = 0;
int uncover = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
cell = field[(i * cols) + j];
if (inGame && cell == MINE_CELL)
inGame = false;
if (!inGame) {
if (cell == COVERED_MINE_CELL) {
cell = DRAW_MINE;
} else if (cell == MARKED_MINE_CELL) {
cell = DRAW_MARK;
} else if (cell > COVERED_MINE_CELL) {
cell = DRAW_WRONG_MARK;
} else if (cell > MINE_CELL) {
cell = DRAW_COVER;
}
} else {
if (cell > COVERED_MINE_CELL)
cell = DRAW_MARK;
else if (cell > MINE_CELL) {
cell = DRAW_COVER;
uncover++;
}
}
g.drawImage(img[cell], (j * CELL_SIZE),
(i * CELL_SIZE), this);
}
}
if (uncover == 0 && inGame) {
inGame = false;
statusbar.setText("Game won");
} else if (!inGame)
statusbar.setText("Game lost");
}
class MinesAdapter extends MouseAdapter {
public void mousePressed(MouseEvent e) {
int x = e.getX();
int y = e.getY();
int cCol = x / CELL_SIZE;
int cRow = y / CELL_SIZE;
boolean rep = false;
if (!inGame) {
newGame();
repaint();
}
if ((x < cols * CELL_SIZE) && (y < rows * CELL_SIZE)) {
if (e.getButton() == MouseEvent.BUTTON3) {
if (field[(cRow * cols) + cCol] > MINE_CELL) {
rep = true;
if (field[(cRow * cols) + cCol] <= COVERED_MINE_CELL) {
if (mines_left > 0) {
field[(cRow * cols) + cCol] += MARK_FOR_CELL;
mines_left--;
statusbar.setText(Integer.toString(mines_left));
} else
statusbar.setText("No marks left");
} else {
field[(cRow * cols) + cCol] -= MARK_FOR_CELL;
mines_left++;
statusbar.setText(Integer.toString(mines_left));
}
}
} else {
if (field[(cRow * cols) + cCol] > COVERED_MINE_CELL) {
return;
}
if ((field[(cRow * cols) + cCol] > MINE_CELL) &&
(field[(cRow * cols) + cCol] < MARKED_MINE_CELL)) {
field[(cRow * cols) + cCol] -= COVER_FOR_CELL;
rep = true;
if (field[(cRow * cols) + cCol] == MINE_CELL)
inGame = false;
if (field[(cRow * cols) + cCol] == EMPTY_CELL)
find_empty_cells((cRow * cols) + cCol);
}
}
if (rep)
repaint();
}
}
}
}
private final int NUM_IMAGES = 13;There are 13 images used in this game. A cell can be surrounded by maximum of 8 mines, so we need numbers 1..8. We need images for an empty cell, a mine, a covered cell, a marked cell and finally for a wrongly marked cell. The size of each of the images is 15x15 px.
private final int CELL_SIZE = 15;
private final int COVER_FOR_CELL = 10;A mine field is an array of numbers. For example 0 denotes an empty cell. Number 10 is used for a cell cover as well as for a mark. Using constants improves readability of the code.
private final int MARK_FOR_CELL = 10;
private final int EMPTY_CELL = 0;
...
private int[] field;The field is an array of numbers. Each cell in the field has a specific number. E.g. a mine cell has number 9. A cell with number 2, meaning it is adjacent to two mines, has number two. The numbers are added. For example, a covered mine has number 19, 9 for the mine and 10 for the cell cover etc.
private int mines = 40;The minefield in our game has 40 hidden mines. There are 16 rows and 16 columns in this field. So there are 256 cells together in the minefield.
private int rows = 16;
private int cols = 16;
for (int i = 0; i < NUM_IMAGES; i++) {
img[i] =
(new ImageIcon(this.getClass().getResource((i)
+ ".png"))).getImage();
}
Here we load our images into the image array. The images are named 0.png, 1.png ... 12.png. The newGame() initiates the Minesweeper game.
all_cells = rows * cols;These lines set up the mine field. Every cell is covered by default.
field = new int[all_cells];
for (i = 0; i < all_cells; i++)
field[i] = COVER_FOR_CELL;
while (i < mines) {
position = (int) (all_cells * random.nextDouble());
if ((position < all_cells) &&
(field[position] != COVERED_MINE_CELL)) {
current_col = position % cols;
field[position] = COVERED_MINE_CELL;
...
In the while cycle we randomly position all mines in the field. cell = position - cols;Each of the cells can be surrounded up to 8 cells. (This does not apply to the border cells.) We raise the number for adjacent cells for each of the randomly placed mine. In our example, we add 1 to the top neighbor of the cell in question.
if (cell >= 0)
if (field[cell] != COVERED_MINE_CELL)
field[cell] += 1;
In the find_empty_cells() method, we find empty cells. If the player clicks on a mine cell, the game is over. If he clicks on a cell adjacent to a mine, he uncovers a number indicating how many mines the cell is adjacent to. Clicking on an empty cell leads to uncovering many other empty cells plus cells with a number that form a border around a space of empty borders. We use a recursive algorithm to find empty cells.
cell = j - 1;In this code, we check the cell that is left to an empty cell in question. If it is not empty, uncover it. If it is empty, repeat the whole process by recursively calling the find_empty_cells() method.
if (cell >= 0)
if (field[cell] > MINE_CELL) {
field[cell] -= COVER_FOR_CELL;
if (field[cell] == EMPTY_CELL)
find_empty_cells(cell);
}
The paint() method turns numbers into images.
if (!inGame) {
if (cell == COVERED_MINE_CELL) {
cell = DRAW_MINE;
} else if (cell == MARKED_MINE_CELL) {
cell = DRAW_MARK;
} else if (cell > COVERED_MINE_CELL) {
cell = DRAW_WRONG_MARK;
} else if (cell > MINE_CELL) {
cell = DRAW_COVER;
}
}
If the game is over and we lost, we show all uncovered mines if any and show all wrongly marked cells if any. g.drawImage(img[cell], (j * CELL_SIZE),This code line draws every cell.
(i * CELL_SIZE), this);
In the mousePressed() method we react to mouse clicks. The Minesweeper game is controlled solely by mouse. We react to left and right mouse clicks.
field[(cRow * cols) + cCol] += MARK_FOR_CELL;If we right click on an unmarked cell, we add MARK_FOR_CELL to the number representing the cell. This leads to drawing a covered cell with a mark in the paint() method.
mines_left--;
if (field[(cRow * cols) + cCol] > COVERED_MINE_CELL) {
return;
}
Nothing happens, if we click on the covered & marked cell. It must by first uncovered by another right click and only then it is possible to left click on it. field[(cRow * cols) + cCol] -= COVER_FOR_CELL;Left click removes a cover from the cell.
if (field[(cRow * cols) + cCol] == MINE_CELL)In case we left clicked on a mine, the game is over. If we left clicked on an empty cell, we call the find_empty_cells() method, which recursively finds all adjacent empty cells.
inGame = false;
if (field[(cRow * cols) + cCol] == EMPTY_CELL)
find_empty_cells((cRow * cols) + cCol);
Mines.java
package mines;This is the main class.
import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class Mines extends JFrame {
private final int WIDTH = 250;
private final int HEIGHT = 290;
private JLabel statusbar;
public Mines() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(WIDTH, HEIGHT);
setLocationRelativeTo(null);
setTitle("Minesweeper");
statusbar = new JLabel("");
add(statusbar, BorderLayout.SOUTH);
add(new Board(statusbar));
setResizable(false);
setVisible(true);
}
public static void main(String[] args) {
new Mines();
}
}
Figure: Minesweeper
In this part of the Java 2D games tutorial, we created a Java clone of the Minesweeper game. 
0 comments:
Post a Comment