利用java开发简易版扫雷游戏

1.简介

学了几周的Java，闲来无事，写个乞丐版的扫雷，加强一下Java基础知识。

2.编写过程

编写这个游戏，一共经历了三个阶段,编写了三个版本的游戏代码。

第一版：完成了扫雷游戏的基本雏形，实现了游戏的基本功能,游戏运行在cmd黑窗口中，以字符绘制游戏界面,无图形化窗口，通过控制台输入字符完成游戏控制。代码放置在一个java文件中，代码的可读性以及可扩展性都比较差。

第二版：在第一版实现基本功能的基础之上，对游戏代码进行重构，根据各部分的功能创建多个类，增加代码注释，提高代码的可读性以及可扩展性。

第三版：在第二版重构代码的基础之上给游戏增加了图形化界面，将用户从控制台输入命令控制游戏变为通过鼠标左右键点击操作控制游戏。

3.游戏运行逻辑

游戏运行逻辑图(第一版代码)：

游戏运行逻辑图(第二版代码)：

以上两个游戏流程图的运行是建立在从控制台读取数据的基础之上的，两者的执行逻辑大体相同，其本质区别在于修改游戏数据的时机不相同。前者是在通关判断之前修改数据，后者实在通关判断之后。两者在运行期间并没有什么区别，但是当玩家完成扫雷之后最后的画面打印就会出现问题，即游戏画面中最后一个进行操作的坐标点的字符的显示状态，在发生改变之前就会终止程序。通过对修改游戏数据以及通关判断这两个操作的执行顺序进行调整，即可修正这一显示错误。

游戏运行逻辑图(第三版代码)：

这个运行流程图是基于第三版加了图形化界面之后的游戏代码，游戏控制流程与控制台输入控制的流程基本相同，只是将从控制台读取用户输入变成了监听用户的鼠标左键与右键的点击事件。并且，从控制台读取数据时要保证游戏结束前一直进行读取，因此需要设置while(true)循环以进行实现，游戏结束使用break跳出循环。而在图形化界面中，使用的是事件监听器，事件监听器在游戏结束前持续监听用户的鼠标点击事件，在游戏结束的弹窗弹出的同时移除监听器，结束鼠标对游戏的控制。

4.游戏相关数据存储与读取

以10x10x3的三维数组存储每个坐标点的信息(包括行号、列号、是否是地雷、当前显示的符号(未操作?、插旗#、地雷*)、周围地雷数)。

一维数组的下标表示行号，二维数组的下标表示列号，三维数组中存的第一个数据表示的是该位置是否是地雷(0-不是,1-是)，第二个数据表示该位置当前显示的符号(0-?,1-#,2-*,3-显示地雷数)，第三个数据表示该位置周围的地雷数。例如：

1. array[0][9][0]=1;表示将第0行第9列设置为地雷
2. array[0][9][1]=1;表示将第0行第9列的显示字符设置为'#'
3. array[0][9][2]=0;表示将第0行第9列位置周围的地雷数设置为0

5.游戏代码

5.1 第一版

第一版的游戏代码写在一个类中，主要的作用是实现基本的游戏功能。代码如下：

1. import java.util.Random;
2. import java.util.Scanner;
3. /**
4. * 扫雷游戏
5. * @author zjl
6. *
7. */
8. public class MineSweeper {
9. public static void main(String[] args) {
10. Scanner input = new Scanner(System.in);
11. //初始化游戏数据
12. int[][][] gameData = init();
13. while (true) {
14. //打印游戏信息
15. showInfo();
16. //打印游戏框
17. showWin(gameData);
18. //踩中地雷结束游戏
19. //由于踩中地雷会把所有标记变成'*'，所以只需要判断0行0列的显示标记是不是'*'就行了
20. if (gameData[0][0][1] == 2) {
21. System.out.println("踩中地雷,游戏结束！");
22. break;
23. }
24. //通关结束游戏
25. if (missionAccomplished(gameData)) {
26. System.out.println("恭喜通关！");
27. break;
28. }
29. //读取控制台数据并对游戏数据数组进行修改
30. gameData = readAndChangeData(input,gameData);
31. }
32. }
33. /**
34. * 打印提示信息
35. */
36. private static void showInfo() {
37. printBlank(25);
38. System.out.println("*******************************************************\n"
39. + "\t\t 游戏信息\n"
40. + "游戏名称：扫雷\n"
41. + "游戏版本：1.0\n"
42. + "游戏操作：1.输入行号及列号来选中要翻开的\'?\'进行操作,可\n"
43. + "\t 以选择插旗(#)或者直接翻开.\n"
44. + "\t 2.如果翻开'*'则表示地雷,则游戏结束;如果翻开\n"
45. + "\t 的是数字,则表示该格周围的地雷数.\n"
46. + "\t 3.标记出全部地雷,并且没有\'?\',则闯关成功,游戏\n"
47. + "\t 结束.\n"
48. + "*******************************************************\n\n");
49. }
50. /**
51. * 打印游戏框
52. */
53. private static void showWin(int[][][] gameData) {
54. System.out.println(" 0 1 2 3 4 5 6 7 8 9\n"
55. + " ***********************");
56. //遍历游戏框中的每个坐标，读取并打印显示符号
57. for (int i = 0; i < 10; i++) {
58. System.out.print(i + " * ");
59. for (int j = 0; j < 10; j++) {
60. //读取展示的符号
61. char sign;
62. switch (gameData[i][j][1]) {
63. case 1:
64. sign = '#';
65. break;
66. case 2:
67. sign = '*';
68. break;
69. case 3:
70. sign = (char)(gameData[i][j][2] + 48);
71. break;
72. default:
73. sign = '?';
74. break;
75. }
76. //打印符号
77. System.out.print(sign + " ");
78. }
79. System.out.println("*");
80. }
81. System.out.println(" ***********************");
82. }
83. /**
84. * 打印空白行
85. */
86. private static void printBlank(int blankNum) {
87. for (int i = 0; i < blankNum; i++) {
88. System.out.println("");
89. }
90. }
91. /**
92. * 随机生成地雷坐标
93. */
94. private static int[][] createMineCoord() {
95. //定义二维数组
96. int[][] mineCoordArray = new int[20][2];
97. Random random = new Random();
98. //将生成的随机坐标存入数组中
99. for (int i = 0; i < 20; i++) {
100. for (int j = 0; j < 2; j++) {
101. //生成0~9范围内的随机数
102. int randomNumber = random.nextInt(10);
103. mineCoordArray[i][j] = randomNumber;
104. }
105. }
106. return mineCoordArray;
107. }
108. /**
109. * 初始化游戏数据
110. */
111. private static int[][][] init(){
112. //创建大小为10*10*3的三维数组(默认初始值为0)
113. int[][][] gameData = new int[10][10][3];
114. //生成随机的地雷坐标，并将其存入游戏数据数组中
115. int[][] mineCoordArray = createMineCoord();
116. for (int[] mineCoord : mineCoordArray) {
117. int row = mineCoord[0];
118. int col = mineCoord[1];
119. gameData[row][col][0] = 1;
120. }
121. //计算每格周围地雷数并将其存入游戏数据数组中
122. //循环遍历每个坐标
123. for (int i = 0; i < 10; i++) {
124. for (int j = 0; j < 10; j++) {
125. //遍历当前坐标周围的8个坐标
126. for (int aroundRow = i-1; aroundRow <= i+1; aroundRow++) {
127. //行号超范围则跳过
128. if (aroundRow < 0 || aroundRow > 9) {
129. continue;
130. }
131. for (int aroundCol = j-1; aroundCol <= j+1; aroundCol++) {
132. //列号超范围则跳过
133. if (aroundCol < 0 || aroundCol > 9) {
134. continue;
135. }
136. //排除本身坐标点
137. if ((gameData[aroundRow][aroundCol][0] == 1) && (!(aroundRow == i && aroundCol == j))) {
138. gameData[i][j][2] += 1;
139. }
140. }
141. }
142. }
143. }
144. return gameData;
145. }
146. /**
147. * 从控制台读取数据，并对游戏的数据数组进行修改
148. * @param input
149. */
150. private static int[][][] readAndChangeData(Scanner input,int[][][] gameData) {
151. //定义在循环外部，以方便后续使用
152. int row;
153. int col;
154. printBlank(12);
155. //读取输入
156. //设置循环来读取行号，当输入的行号不在范围内时，会一直提示玩家
157. while (true) {
158. System.out.print("请输入行号：");
159. row = input.nextInt();
160. if (row >= 0 && row <= 9) {
161. break;
162. } else {
163. System.out.println("输入的行号不符合规范！");
164. }
165. }
166. //设置循环来读取列号，当输入的行号不在范围内时，会一直提示玩家
167. while(true) {
168. System.out.print("请输入列号：");
169. col = input.nextInt();
170. if (col >= 0 && col <= 9) {
171. break;
172. } else {
173. System.out.println("输入的列号不符合规范！");
174. }
175. }
176. //设置循环，防止玩家输入不能识别的字符
177. while (true) {
178. System.out.print("标记(B)还是直接翻开(F)：");
179. String sign = input.next();
180. //如果翻开的是炸弹，直接把所有标记变成'*'，并返回结束游戏
181. if (sign.equalsIgnoreCase("f")) {
182. if (gameData[row][col][0] == 1) {
183. for (int i = 0; i < 10; i++) {
184. for (int j = 0; j < 10; j++) {
185. gameData[i][j][1] =2;
186. }
187. }
188. break;
189. }
190. }
191. //修改数据
192. if (gameData[row][col][1] != 3) {//gameData[row][col][1] == 3 表示已被翻开，翻开的坐标点不能再被操作
193. if (sign.equalsIgnoreCase("b")) {
194. gameData[row][col][1] = 1;
195. } else if (sign.equalsIgnoreCase("f")) {
196. //如果翻开的不是炸弹，则显示其周围地雷数
197. if (gameData[row][col][0] != 1) {
198. gameData[row][col][1] = 3;
199. }
200. } else {
201. System.out.println("输入不符合要求，请重新输入！");
202. continue;
203. }
204. }
205. break;
206. }
207. return gameData;
208. }
209. /**
210. * 通关判断
211. * @return
212. */
213. private static boolean missionAccomplished(int[][][] gameDate) {
214. //坐标点总数
215. int totalSite = 10 * 10;
216. //统计地雷数与非地雷数
217. int mineSigned = 0;
218. int noMineOpen = 0;
219. //遍历游戏数据数组
220. for (int i = 0; i < 10; i++) {
221. for (int j = 0; j < 10; j++) {
222. //通关条件
223. //1、翻开非地雷的位置
224. if (gameDate[i][j][0] == 0 && gameDate[i][j][1] == 3) {
225. noMineOpen++;
226. }
227. //2、地雷位置标记
228. if (gameDate[i][j][0] == 1 && gameDate[i][j][1] == 1) {
229. mineSigned++;
230. }
231. }
232. }
233. if (totalSite == (noMineOpen + mineSigned)) {
234. return true;
235. }
236. return false;
237. }
238. }

5.2 第二版

这一版的代码实在第一版的基础上对代码进行重构，根据功能对代码进行分类，将其放入不同的类中，增加代码的可读性与可维护性、可扩展性。代码一共分为五个类：主程序类、设置类、地雷类、控制类、显示类。各部分代码各司其职，共同作用，共同完成游戏运行。

主程序类，游戏程序入口：

1. import java.util.Scanner;
2. /**
3. * 扫雷游戏
4. * @author zjl
5. *
6. */
7. public class MineSweeper {
8. /**
9. * 游戏运行主程序
10. * @param args
11. */
12. public static void main(String[] args) {
13. Scanner input = new Scanner(System.in);
14. //初始化游戏数据
15. int[][][] gameData = GameControl.init();
16. while (true) {
17. //打印游戏信息
18. Show.gameInfo();
19. //打印游戏框
20. Show.gameBoard(gameData);
21. //踩中地雷结束游戏
22. //由于踩中地雷会把所有标记变成'*'，所以只需要判断0行0列的显示标记是不是'*'就行了
23. if (gameData[0][0][Settings.SIGN_DATA] == Settings.MINE_SIGN_DATA) {
24. System.out.println("踩中地雷,游戏结束！");
25. break;
26. }
27. //通关结束游戏
28. if (GameControl.missionAccomplished(gameData)) {
29. System.out.println("恭喜通关！");
30. break;
31. }
32. //读取控制台数据并对游戏数据数组进行修改
33. GameControl.readAndChangeData(input,gameData);
34. }
35. }
36. }

设置类，游戏相关设置数据：

1. /**
2. * 定义游戏初始数据的类
3. * @author zjl
4. *
5. */
6. public class Settings {
7. //定义游戏界面参数
8. /**
9. * 游戏界面的行数
10. */
11. public static final int ROW_SIZE = 10;
12. /**
13. * 游戏界面的列数
14. */
15. public static final int COL_SIZE = 10;
16. /**
17. * 两个游戏界面之间的默认空白行数
18. */
19. public static final int DEFAULT_BLANK = 20;
20. /**
21. * 地雷数
22. */
23. public static final int MINE_NUM = 20;
24. /**
25. * 确定地雷位置所需要的坐标数，由于是在平面内，所以只需要设置横纵坐标，值为2
26. */
27. public static final int MINE_SITE_NUM = 2;
28. /**
29. * 地雷行坐标在地雷数组中的下标
30. */
31. public static final int MINE_ROW_IN_ARRAY = 0;
32. /**
33. * 地雷列坐标在地雷数组中的下标
34. */
35. public static final int MINE_COL_IN_ARRAY = 1;
36. /**
37. * 每个坐标点中存储数据的数组的大小
38. */
39. public static final int DATA_SIZE = 3;
40. //定义每个坐标点中存储数据的数组中数值的含义
41. /**
42. * 数组中存放地雷信息的位置
43. */
44. public static final int MINE_DATA = 0;
45. /**
46. * 表示不是地雷,为默认值
47. */
48. public static final int IS_NOT_MINE = 0;
49. /**
50. * 表示是地雷
51. */
52. public static final int IS_MINE = 1;
53. /**
54. * 数组中存放符号信息的位置
55. */
56. public static final int SIGN_DATA = 1;
57. /**
58. * 表示初始符号，即'?'
59. */
60. public static final int INIT_SIGN_DATA = 0;
61. /**
62. * 表示插旗符号，即'#'
63. */
64. public static final int FLAG_SIGN_DATA = 1;
65. /**
66. * 表示地雷符号，即'*'
67. */
68. public static final int MINE_SIGN_DATA = 2;
69. /**
70. * 表示当前位置已翻开，即应该显示当前位置的地雷数
71. */
72. public static final int MINE_NUM_SIGN_DATA = 3;
73. /**
74. * 数组中存放坐标点周围地雷数的位置
75. */
76. public static final int AROUND_MINE_DATA = 2;
77. //游戏符号
78. /**
79. * 初始符号'?'
80. */
81. public static final char INIT_SIGN = '?';
82. /**
83. * 插旗符号'#'
84. */
85. public static final char FLAG_SIGN = '#';
86. /**
87. * 地雷符号'*'
88. */
89. public static final char MINE_SIGN = '*';
90. /**
91. * 在ASCII码表中整数48~57代表字符0~9,设置一个增量值，将数字转换为字符
92. */
93. public static final int ASCII_ADD = 48;
94. //定义玩家在控制台输入的操纵符
95. /**
96. * 表示翻开操纵的符号
97. */
98. public static final String OPEN_OPERATION = "F";
99. /**
100. * 表示插旗操作的符号
101. */
102. public static final String FLAG_OPERATION = "B";
103. /**
104. * 游戏信息
105. */
106. public static final String INFORMATION = "**************************************************\n"
107. + "\t\t 游戏信息\n"
108. + "游戏名称：扫雷\n"
109. + "游戏版本：2.0\n"
110. + "游戏操作：1.输入行号及列号来选中要翻开的\'?\'进行操作,可\n"
111. + "\t 以选择插旗(#)或者直接翻开.\n"
112. + "\t 2.如果翻开'*'则表示地雷,则游戏结束;如果翻开\n"
113. + "\t 的是数字,则表示该格周围的地雷数.\n"
114. + "\t 3.标记出全部地雷,并且没有\'?\',则闯关成功,游戏\n"
115. + "\t 结束.\n"
116. + "**************************************************\n\n";
117. }

地雷类，生成随机的地雷坐标数据：

1. import java.util.Random;
2. /**
3. * 有关地雷的类
4. * @author zjl
5. *
6. */
7. public class Mine {
8. /**
9. * 随机生成地雷坐标
10. */
11. public static int[][] createMineCoord() {
12. //定义二维数组
13. int[][] mineCoordArray = new int[Settings.MINE_NUM][Settings.MINE_SITE_NUM];
14. Random random = new Random();
15. //将生成的随机坐标存入数组中
16. for (int i = 0; i < Settings.MINE_NUM; i++) {
17. for (int j = 0; j < Settings.MINE_SITE_NUM; j++) {
18. //生成行坐标随机数,并将其放入数组
19. if (j == Settings.MINE_ROW_IN_ARRAY) {
20. mineCoordArray[i][j] = random.nextInt(Settings.ROW_SIZE);
21. }
22. //生成列坐标随机数,并将其放入数组
23. if (j == Settings.MINE_COL_IN_ARRAY) {
24. mineCoordArray[i][j] = random.nextInt(Settings.COL_SIZE);
25. }
26. }
27. }
28. return mineCoordArray;
29. }
30. }

控制类,控制游戏进程，以及游戏数据：

1. import java.util.Scanner;
2.  
3. /**
4. * 关于游戏相关控制的类
5. * @author zjl
6. *
7. */
8. public class GameControl {
9.  
10. /**
11. * 初始化游戏数据
12. */
13. public static int[][][] init(){
14. //创建存储游戏相关数据的三维数组(默认初始值为0)
15. int[][][] gameData = new int[Settings.ROW_SIZE][Settings.COL_SIZE][Settings.DATA_SIZE];
16.  
17. //生成随机的地雷坐标，并将其存入游戏数据数组中
18. int[][] mineCoordArray = Mine.createMineCoord();
19. for (int[] mineCoord : mineCoordArray) {
20. int row = mineCoord[Settings.MINE_ROW_IN_ARRAY];
21. int col = mineCoord[Settings.MINE_COL_IN_ARRAY];
22. gameData[row][col][Settings.MINE_DATA] = Settings.IS_MINE;
23. }
24. //计算每格周围地雷数并将其存入游戏数据数组中
25. //循环遍历每个坐标
26. for (int i = 0; i < Settings.ROW_SIZE; i++) {
27. for (int j = 0; j < Settings.COL_SIZE; j++) {
28. //遍历当前坐标周围的8个坐标
29. for (int aroundRow = i-1; aroundRow <= i+1; aroundRow++) {
30. //行号超范围则跳过
31. if (aroundRow < 0 || aroundRow > Settings.ROW_SIZE-1) {
32. continue;
33. }
34. for (int aroundCol = j-1; aroundCol <= j+1; aroundCol++) {
35. //列号超范围则跳过
36. if (aroundCol < 0 || aroundCol > Settings.COL_SIZE-1) {
37. continue;
38. }
39. //排除本身坐标点
40. if ((gameData[aroundRow][aroundCol][Settings.MINE_DATA] == Settings.IS_MINE) && (!(aroundRow == i && aroundCol == j))) {
41. gameData[i][j][Settings.AROUND_MINE_DATA] += 1;
42. }
43. }
44. }
45. }
46. }
47. return gameData;
48. }
49. /**
50. * 从控制台读取数据，并对游戏的数据数组进行修改
51. * @param input
52. */
53. public static void readAndChangeData(Scanner input,int[][][] gameData) {
54. //定义在循环外部，以方便后续使用
55. int row;
56. int col;
57. //读取输入
58. //设置循环来读取行号，当输入的行号不在范围内时，会一直提示玩家
59. while (true) {
60. System.out.print("请输入行号：");
61. row = input.nextInt();
62. if (row >= 0 && row <= Settings.ROW_SIZE-1) {
63. break;
64. } else {
65. System.out.println("输入的行号不符合规范！");
66. }
67. }
68. //设置循环来读取列号，当输入的行号不在范围内时，会一直提示玩家
69. while(true) {
70. System.out.print("请输入列号：");
71. col = input.nextInt();
72. if (col >= 0 && col <= Settings.COL_SIZE-1) {
73. break;
74. } else {
75. System.out.println("输入的列号不符合规范！");
76. }
77. }
78. //设置循环，防止玩家输入不能识别的字符
79. while (true) {
80. System.out.print("标记(B)还是直接翻开(F)：");
81. String sign = input.next();
82.  
83. //如果翻开的是炸弹，直接把所有标记变成'*'，并返回结束游戏
84. if (sign.equalsIgnoreCase(Settings.OPEN_OPERATION)) {
85. if (gameData[row][col][Settings.MINE_DATA] == Settings.IS_MINE) {
86. for (int i = 0; i < Settings.ROW_SIZE; i++) {
87. for (int j = 0; j < Settings.COL_SIZE; j++) {
88. gameData[i][j][Settings.SIGN_DATA] =Settings.MINE_SIGN_DATA;
89. }
90. }
91. break;
92. }
93. }
94. //修改数据
95. if (gameData[row][col][Settings.SIGN_DATA] != Settings.MINE_NUM_SIGN_DATA) {//相等表示已被翻开，翻开的坐标点不能再被操作
96. if (sign.equalsIgnoreCase(Settings.FLAG_OPERATION)) {
97. gameData[row][col][Settings.SIGN_DATA] = Settings.FLAG_SIGN_DATA;
98. } else if (sign.equalsIgnoreCase(Settings.OPEN_OPERATION)) {
99. //如果翻开的不是炸弹，则显示其周围地雷数
100. if (gameData[row][col][Settings.MINE_DATA] == Settings.IS_NOT_MINE) {
101. gameData[row][col][Settings.SIGN_DATA] = Settings.MINE_NUM_SIGN_DATA;
102.  
103. }
104. } else {
105. System.out.println("输入不符合要求，请重新输入！");
106. continue;
107. }
108. }
109. break;
110. }
111. }
112. /**
113. * 通关判断
114. * @return
115. */
116. public static boolean missionAccomplished(int[][][] gameDate) {
117. //坐标点总数
118. int totalSite = Settings.ROW_SIZE * Settings.COL_SIZE;
119. //统计地雷数与非地雷数
120. int mineSigned = 0;
121. int noMineOpen = 0;
122. //遍历游戏数据数组
123. for (int i = 0; i < Settings.ROW_SIZE; i++) {
124. for (int j = 0; j < Settings.COL_SIZE; j++) {
125. //通关条件
126. //1、翻开非地雷的位置
127. if (gameDate[i][j][Settings.MINE_DATA] == Settings.IS_NOT_MINE && gameDate[i][j][Settings.SIGN_DATA] == Settings.MINE_NUM_SIGN_DATA) {
128. noMineOpen++;
129. }
130. //2、地雷位置标记
131. if (gameDate[i][j][Settings.MINE_DATA] == Settings.IS_MINE && gameDate[i][j][Settings.SIGN_DATA] == Settings.FLAG_SIGN_DATA) {
132. mineSigned++;
133. }
134. }
135. }
136. //当翻开的的坐标数加上标记的地雷数等于坐标点总数的时候，返回true表示可以结束游戏
137. if (totalSite == (noMineOpen + mineSigned)) {
138. return true;
139. }
140. //条件不满足，游戏继续
141. return false;
142. }
143. }

显示类，对游戏的相关画面进行打印：

1. /**
2. * 展示游戏相关画面的类
3. * @author zjl
4. *
5. */
6. public class Show {
7. /**
8. * 打印提示信息
9. */
10. public static void gameInfo() {
11. //打印空白行，作用是使展现在控制台的图形刷新
12. printSign(Settings.DEFAULT_BLANK,"\n");
13. System.out.println(Settings.INFORMATION);
14. }
15. /**
16. * 打印一行指定的图形
17. */
18. public static void printSign(int num,String sign) {
19. for (int i = 0; i < num; i++) {
20. System.out.print(sign);
21. }
22. }
23. /**
24. * 打印游戏框
25. */
26. public static void gameBoard(int[][][] gameData) {
27. //打印游戏上边框
28. printSign(4, " ");
29. for (int i = 0; i < Settings.COL_SIZE; i++) {
30. printSign(1, i+" ");
31. }
32. printSign(1, "\n *");
33. printSign(Settings.COL_SIZE+1, "**");
34. printSign(1, "\n");
35. //遍历游戏框中的每个坐标，读取并打印显示符号
36. for (int i = 0; i < Settings.ROW_SIZE; i++) {
37. System.out.print(i + " * ");
38. for (int j = 0; j < Settings.COL_SIZE; j++) {
39. //读取展示的符号
40. char sign;
41. switch (gameData[i][j][Settings.SIGN_DATA]) {
42. case Settings.FLAG_SIGN_DATA:
43. sign = Settings.FLAG_SIGN;
44. break;
45. case Settings.MINE_SIGN_DATA:
46. sign = Settings.MINE_SIGN;
47. break;
48. case Settings.MINE_NUM_SIGN_DATA:
49. //将数组中存的整型数值通过ASCII码转为字符型表示
50. sign = (char)(gameData[i][j][Settings.AROUND_MINE_DATA] + Settings.ASCII_ADD);
51. break;
52. default:
53. sign = Settings.INIT_SIGN;
54. break;
55. }
56. //打印符号
57. System.out.print(sign + " ");
58. }
59. System.out.println("*");
60. }
61. //打印游戏下边框
62. printSign(2, " ");
63. printSign(Settings.COL_SIZE+1, "**");
64. printSign(1, "*\n");
65. }
66. }

5.3 第三版

在第二版的基础上，去除了显示类，增加了图片类、图形界面类、事件监听器类。

游戏运行主程序类：

1. /**
2. * 扫雷游戏主程序类
3. * @author zjl
4. *
5. */
6. public class MineSweeper {
7. /**
8. * 游戏运行主程序
9. * @param args
10. */
11. public static void main(String[] args) {
12. int[][][] gameData = new int[Settings.ROW_SIZE][Settings.COL_SIZE][Settings.DATA_SIZE];
13. //创建游戏控制类对象
14. GameDataController controller = new GameDataController(gameData);
15. //初始化游戏数据
16. controller.init();
17. //绘制游戏界面
18. new Graphic(controller);
19. }
20. }

设置类，提供游戏运行相关这是数据：

1. /**
2. * 定义游戏初始数据的类
3. * @author zjl
4. *
5. */
6. public class Settings {
7. //定义游戏界面参数
8. /**
9. * 游戏界面的行数
10. */
11. public static final int ROW_SIZE = 10;
12. /**
13. * 游戏界面的列数
14. */
15. public static final int COL_SIZE = 10;
16.  
17. /**
18. * 地雷数
19. */
20. public static final int MINE_NUM = 20;
21. /**
22. * 确定地雷位置所需要的坐标数，由于是在平面内，所以只需要设置横纵坐标，值为2
23. */
24. public static final int MINE_SITE_NUM = 2;
25. /**
26. * 地雷行坐标在地雷数组中的下标
27. */
28. public static final int MINE_ROW_IN_ARRAY = 0;
29. /**
30. * 地雷列坐标在地雷数组中的下标
31. */
32. public static final int MINE_COL_IN_ARRAY = 1;
33.  
34. /**
35. * 每个坐标点中存储数据的数组的大小
36. */
37. public static final int DATA_SIZE = 3;
38. //定义每个坐标点中存储数据的数组中数值的含义
39. /**
40. * 数组中存放地雷信息的位置
41. */
42. public static final int MINE_DATA = 0;
43. /**
44. * 表示不是地雷,为默认值
45. */
46. public static final int IS_NOT_MINE = 0;
47. /**
48. * 表示是地雷
49. */
50. public static final int IS_MINE = 1;
51. /**
52. * 数组中存放符号信息的位置
53. */
54. public static final int SIGN_DATA = 1;
55. /**
56. * 表示初始符号
57. */
58. public static final int INIT_SIGN_DATA = 0;
59. /**
60. * 表示插旗符号
61. */
62. public static final int FLAG_SIGN_DATA = 1;
63. /**
64. * 表示地雷符号
65. */
66. public static final int MINE_SIGN_DATA = 2;
67. /**
68. * 表示当前位置已翻开，即应该显示当前位置的地雷数
69. */
70. public static final int MINE_NUM_SIGN_DATA = 3;
71. /**
72. * 数组中存放坐标点周围地雷数的位置
73. */
74. public static final int AROUND_MINE_DATA = 2;
75.  
76. //定义游戏框尺寸数据
77. /**
78. * 图片边长
79. */
80. public static final int IMAGE_SIZE = 60;
81. /**
82. * 游戏窗口在屏幕上的x位置
83. */
84. public static final int FRAME_X = 400;
85. /**
86. * 游戏窗口在屏幕上的y位置
87. */
88. public static final int FRAME_Y = 150;
89. /**
90. * 游戏窗口的宽度
91. */
92. public static final int FRAME_WIDTH = IMAGE_SIZE * ROW_SIZE;
93. /**
94. * 游戏窗口的高度
95. */
96. public static final int FRAME_HEIGHT =IMAGE_SIZE * COL_SIZE;
97. /**
98. * 游戏网格线的宽度
99. */
100. public static final int BORDER_WIDTH = 1;
101. /**
102. * 游戏窗口标题栏高度
103. */
104. public static final int TITLE_HEIGHT = 23;
105.  
106. //弹窗数据
107. /**
108. * 弹窗标题
109. */
110. public static final String DIALOG_TITLE = "提示";
111. /**
112. * 弹窗提示语,踩雷
113. */
114. public static final String DIALOG_DEFEAT = "踩雷,游戏结束!";
115. /**
116. * 弹窗提示语,通关
117. */
118. public static final String DIALOG_VECTORY = "恭喜通关!";
119. }

图片类，提供游戏相关图片：

1. import javax.swing.ImageIcon;
2.  
3. /**
4. * 这是一个用于提供游戏所需图片的类,在游戏运行时,将相关的图片加载到图形界面上
5. * @author zjl
6. *
7. */
8. public class Image{
9. /**
10. * ImageIcon类型的常量,表示地雷图片
11. */
12. public static final ImageIcon IMAGE_MINE = new ImageIcon("img\\mine.png");
13. /**
14. * ImageIcon类型的常量,表示旗帜图片
15. */
16. public static final ImageIcon IMAGE_FLAG = new ImageIcon("img\\flag.png");
17. /**
18. * ImageIcon类型的常量,表示失败时的表情图片
19. */
20. public static final ImageIcon IMAGE_DEFEAT = new ImageIcon("img\\defeat.png");
21. /**
22. * ImageIcon类型的常量,表示通关时的表情图片
23. */
24. public static final ImageIcon IMAGE_VECTORY = new ImageIcon("img\\vectory.png");
25.  
26. /**
27. * 这是一个用于返回数字图片的静态方法,
28. * 通过传入的参数来获取表示对应数字的图片,
29. * 返回的图片上的数字表示某位置周围存在的地雷数
30. * @param mineNum-int类型,表示传入地雷数量的参数
31. * @return image-ImageIcon类型的返回值,返回的图片上的数字与参数mineNum对应
32. */
33. public static ImageIcon getImageByNum(int mineNum) {
34. ImageIcon image = new ImageIcon("img\\"+mineNum+".png");
35. return image;
36. }
37. }

地雷类，生成游戏中的类的相关数据：

1. import java.util.Random;
2.  
3. /**
4. * 这是一个用于生成随机地雷坐标的类。
5. * 由于生成的是伪随机数,因此生成的地雷坐标可能重复,所以实际游戏中的地雷数量并不固定。
6. * @author zjl
7. *
8. */
9. public class Mine {
10.  
11. /**
12. * 随机生成坐标数据,为游戏提供随机的地雷坐标数据。
13. * @return mineCoordArray-int类型的二维数组,存储的是生成的地雷的坐标数据
14. */
15. public static int[][] createMineCoord() {
16. //定义二维数组
17. int[][] mineCoordArray = new int[Settings.MINE_NUM][Settings.MINE_SITE_NUM];
18. Random random = new Random();
19. //将生成的随机坐标存入数组中
20. for (int i = 0; i < Settings.MINE_NUM; i++) {
21. for (int j = 0; j < Settings.MINE_SITE_NUM; j++) {
22. //生成行坐标随机数,并将其放入数组
23. if (j == Settings.MINE_ROW_IN_ARRAY) {
24. mineCoordArray[i][j] = random.nextInt(Settings.ROW_SIZE);
25. }
26. //生成列坐标随机数,并将其放入数组
27. if (j == Settings.MINE_COL_IN_ARRAY) {
28. mineCoordArray[i][j] = random.nextInt(Settings.COL_SIZE);
29. }
30. }
31. }
32.  
33. return mineCoordArray;
34. }
35. }

游戏控制类，提供用于游戏控制的相关方法：

1. import javax.swing.JLabel;
2.  
3. /**
4. * 这是一个用于游戏数据控制的类,
5. * @author zjl
6. *
7. */
8. public class GameDataController {
9. /**
10. * 私有的成员变量,用于存储在构造方法中接收到的游戏数据
11. */
12. private int[][][] gameData;
13. /**
14. * 这是本类的一个有参构造方法,通过传入游戏数据来构造一个游戏数据控制器
15. * @param gameData-存储游戏相关数据的三维数组
16. */
17. public GameDataController(int[][][] gameData) {
18. this.gameData = gameData;
19. }
20. /**
21. * 初始化游戏数据
22. */
23. public void init(){
24. //将地雷数据存入三维游戏数组中
25. int[][] mineCoordArray = Mine.createMineCoord();
26. for (int[] mineCoord : mineCoordArray) {
27. int row = mineCoord[Settings.MINE_ROW_IN_ARRAY];
28. int col = mineCoord[Settings.MINE_COL_IN_ARRAY];
29. gameData[row][col][Settings.MINE_DATA] = Settings.IS_MINE;
30. }
31. //计算每格周围地雷数并将其存入游戏数据数组中
32. calcAroundNum();
33. }
34. /**
35. * 游戏通关判断
36. * @return 返回boolean类型的true或false,true表示游戏通关
37. */
38. public boolean missionAccomplished() {
39. //坐标点总数
40. int totalSite = Settings.ROW_SIZE * Settings.COL_SIZE;
41. //统计地雷数与非地雷数
42. int mineSigned = 0;
43. int noMineOpen = 0;
44. //遍历游戏数据数组
45. for (int i = 0; i < Settings.ROW_SIZE; i++) {
46. for (int j = 0; j < Settings.COL_SIZE; j++) {
47. //通关条件
48. //1、翻开非地雷的位置
49. if (gameData[i][j][Settings.MINE_DATA] == Settings.IS_NOT_MINE && gameData[i][j][Settings.SIGN_DATA] == Settings.MINE_NUM_SIGN_DATA) {
50. noMineOpen++;
51. }
52. //2、地雷位置标记
53. if (gameData[i][j][Settings.MINE_DATA] == Settings.IS_MINE && gameData[i][j][Settings.SIGN_DATA] == Settings.FLAG_SIGN_DATA) {
54. mineSigned++;
55. }
56. }
57. }
58. //当翻开的的坐标数加上标记的地雷数等于坐标点总数的时候，返回true表示可以结束游戏
59. if (totalSite == (noMineOpen + mineSigned)) {
60. return true;
61. }
62. //条件不满足，游戏继续
63. return false;
64. }
65. /**
66. * 用于鼠标左击时的游戏控制操作,即翻开所点击的位置
67. * @param x-表示点击位置在游戏框上的x轴坐标
68. * @param y-表示点击位置在游戏框上的y轴坐标
69. * @param labels-表示用于放置图片的标签的集合
70. */
71. public void leftClick(int x, int y, JLabel[][] labels) {
72.  
73. if (gameData[y][x][Settings.SIGN_DATA] == Settings.INIT_SIGN_DATA) {
74. if (gameData[y][x][Settings.MINE_DATA] == Settings.IS_MINE) {
75. //如果翻开的是地雷，显示弹窗提示结束游戏
76. labels[y][x].setIcon(Image.IMAGE_MINE);
77. Graphic.showDialog(false);
78. }else {
79. //如果当前位置未被翻开，则翻开当前位置，修改游戏数据及显示图片
80. gameData[y][x][Settings.SIGN_DATA] = Settings.MINE_NUM_SIGN_DATA;
81. int aroundMineNum = gameData[y][x][Settings.AROUND_MINE_DATA];
82. labels[y][x].setIcon(Image.getImageByNum(aroundMineNum));
83. }
84. }
85. }
86. /**
87. * 用于鼠标右击时的游戏控制操作,即插旗与取消插旗
88. * @param x-表示点击位置在游戏框上的x轴坐标
89. * @param y-表示点击位置在游戏框上的y轴坐标
90. * @param labels-表示用于放置图片的标签的集合
91. */
92. public void rightClick(int x, int y, JLabel[][] labels) {
93.  
94. if (gameData[y][x][Settings.SIGN_DATA] == Settings.INIT_SIGN_DATA) {
95. //如果当前位置未被翻开，则修改相应数据，并将其显示为插旗
96. gameData[y][x][Settings.SIGN_DATA] = Settings.FLAG_SIGN_DATA;
97. labels[y][x].setIcon(Image.IMAGE_FLAG);
98. } else if (gameData[y][x][Settings.SIGN_DATA] == Settings.FLAG_SIGN_DATA) {
99. //如果该位置已被插旗，则修改相应数据，并将其恢复初始状态
100. gameData[y][x][Settings.SIGN_DATA] = Settings.INIT_SIGN_DATA;
101. labels[y][x].setIcon(null);
102. }
103. }
104. /**
105. * 计算每个位置周围的地雷数,并将算出的结果存入到三维游戏数组中
106. */
107. private void calcAroundNum() {
108.  
109. for (int i = 0; i < Settings.ROW_SIZE; i++) {
110. for (int j = 0; j < Settings.COL_SIZE; j++) {
111. //遍历当前坐标周围的8个坐标
112. for (int aroundRow = i-1; aroundRow <= i+1; aroundRow++) {
113. //行号超范围则跳过
114. if (aroundRow < 0 || aroundRow > Settings.ROW_SIZE-1) {
115. continue;
116. }
117. for (int aroundCol = j-1; aroundCol <= j+1; aroundCol++) {
118. //列号超范围则跳过
119. if (aroundCol < 0 || aroundCol > Settings.COL_SIZE-1) {
120. continue;
121. }
122. //排除本身坐标点
123. if ((gameData[aroundRow][aroundCol][Settings.MINE_DATA] == Settings.IS_MINE) && (!(aroundRow == i && aroundCol == j))) {
124. gameData[i][j][Settings.AROUND_MINE_DATA] += 1;
125. }
126. }
127. }
128. }
129. }
130. }
131. }

绘制图形化界面类，生成显示游戏的图形化界面：

1. import java.awt.Color;
2. import java.awt.GridLayout;
3.  
4. import javax.swing.BorderFactory;
5. import javax.swing.ImageIcon;
6. import javax.swing.JFrame;
7. import javax.swing.JLabel;
8. import javax.swing.JOptionPane;
9.  
10. /**
11. * 绘制扫雷的图形界面的类,提供用于绘制界面以及用于获取相关对象的方法
12. * @author zjl
13. *
14. */
15. public class Graphic {
16. /**
17. * 定义JFrame类型的的静态属性frame
18. */
19. private static JFrame frame;
20. /**
21. * 定义GameListener类型的游戏事件监听器gameListener
22. */
23. private static GameListener gameListener;
24. /**
25. * 定义用于存储JLabel类型数据的二维数组labels
26. */
27. private JLabel[][] labels = new JLabel[Settings.ROW_SIZE][Settings.COL_SIZE];
28. /**
29. * 定义JLabel类型的属性label
30. */
31. private JLabel label;
32. /**
33. * 定义游戏控制器
34. */
35. private GameDataController controller;
36. /**
37. * 初始化游戏图形界面中窗口容器的相关设置
38. */
39. static {
40. frame = new JFrame("扫雷2.0");
41. //将frame的布局管理器设置为GridLayout
42. frame.setLayout(new GridLayout(Settings.ROW_SIZE, Settings.COL_SIZE));
43. //设置frame的位置、大小、可见性，设置窗体大小不可更改以及关闭按钮的功能
44. frame.setBounds(Settings.FRAME_X, Settings.FRAME_Y, Settings.FRAME_WIDTH, Settings.FRAME_HEIGHT);
45. frame.setVisible(true);
46. frame.setResizable(false);
47. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
48. }
49. /**
50. * 这是该类的一个有参构造方法,用于创建Graphic对象。
51. * 该构造方法调用本类中的draw()方法,绘制游戏的图形化界面
52. * @param controller-接收主函数中传入的游戏参数控制器对象,后续将其传递到事件监听器中,使监听器能够修改游戏数据
53. */
54. public Graphic(GameDataController controller) {
55. this.controller = controller;
56. draw();
57. }
58. /**
59. * 绘制游戏的图形化界面,并在游戏窗口上添加事件监听器
60. */
61. private void draw() {
62. //通过循环创建label，并将其加入到frame中
63. for (int i = 0; i < Settings.ROW_SIZE; i++) {
64. for (int j = 0; j < Settings.COL_SIZE; j++) {
65. frame.add(label = new JLabel());
66. labels[i][j] = label;
67. //设置label的边框属性
68. label.setBorder(BorderFactory.createLineBorder(Color.BLACK, Settings.BORDER_WIDTH));
69. }
70. }
71. //创建事件监听器，监听鼠标点击在frame上的位置，并将监听器添加到frame上
72. gameListener = new GameListener(labels, controller);
73. frame.addMouseListener(gameListener);
74. }
75. /**
76. * 绘制游戏结束时的弹窗。
77. * 根据传入的参数判断游戏是因为踩到地雷而结束还是因为通关而结束,从而绘制不同效果的弹窗
78. * @param result-boolean类型的参数,表示游戏是因为通关结束还是因为踩雷结束
79. */
80. public static void showDialog(boolean result) {
81. int option;
82. String message;
83. ImageIcon image;
84. //判断游戏的结束原因,并进行相应的赋值操作
85. if (result) {
86. message = Settings.DIALOG_VECTORY;
87. image = Image.IMAGE_VECTORY;
88. } else {
89. message = Settings.DIALOG_DEFEAT;
90. image = Image.IMAGE_DEFEAT;
91. }
92. //弹窗出现表示游戏结束,此时应移除窗体上的事件监听器
93. frame.removeMouseListener(gameListener);
94. //根据相关参数绘制弹窗
95. option = JOptionPane.showConfirmDialog(null, message, Settings.DIALOG_TITLE, JOptionPane.CANCEL_OPTION,JOptionPane.INFORMATION_MESSAGE,image);
96. /* 根据弹窗上的按钮点击结果判断是否关闭游戏退出程序。
97. * 只有在点击确定时才会结束程序,点击取消并不会推出游戏，
98. * 而是停留在游戏结束时的画面，但是不能进行游戏操作,
99. * 点击关闭窗口即可退出程序
100. */
101. if (option != JOptionPane.CANCEL_OPTION) {
102. System.exit(0);
103. }
104. }
105. }

事件监听器类，用于提供监听鼠标点击事件的监听器：

1. import java.awt.event.MouseAdapter;
2. import java.awt.event.MouseEvent;
3.  
4. import javax.swing.ImageIcon;
5. import javax.swing.JLabel;
6.  
7. /**
8. * 定义游戏相关的事件监听器
9. * @author zjl
10. *
11. */
12. public class GameListener extends MouseAdapter {
13. /**
14. * 私有的成员变量,用以接收构造事件监听器时传入的JLabel数组
15. */
16. private JLabel[][] labels;
17. /**
18. * 私有的成员变量,用以接收构造事件监听器时传入的游戏数据控制器对象
19. */
20. private GameDataController controller;
21. /**
22. * 这是本类一个有参构造方法,用于根据传入的参数构造事件监听器对象
23. * @param labels-这是一个JLabel数组,为后续改变相应的图像显示提供容纳图片的JLabel组件
24. * @param controller-游戏数据控制器对象,用于改变相应游戏数据
25. */
26. public GameListener(JLabel[][] labels, GameDataController controller) {
27. this.labels = labels;
28. this.controller = controller;
29. }
30. /**
31. * 重写MouseAdapter类中的mouseClicked方法,添加响应鼠标操作的逻辑代码
32. */
33. @Override
34. public void mouseClicked(MouseEvent e) {
35. //对鼠标点击点的坐标进行计算可得到label在数组中的下标
36. int x = (e.getX()-Settings.BORDER_WIDTH)/Settings.IMAGE_SIZE;
37. int y = (e.getY()-Settings.TITLE_HEIGHT)/Settings.IMAGE_SIZE;
38. //区分鼠标左击右击事件
39. if (e.getButton() == MouseEvent.BUTTON1) {//鼠标左击，进行的操作为翻开当前位置
40. controller.leftClick(x, y, labels);
41. } else if (e.getButton() == MouseEvent.BUTTON3) {//鼠标右击，进行的操作为插旗与取消插旗
42. controller.rightClick(x, y, labels);
43. }
44. //通关判断
45. if (controller.missionAccomplished()) {
46. //通关则显示弹窗并移除监听器
47. Graphic.showDialog(true);
48. }
49. }
50. }

6.部分代码思路

6.1 生成随机的地雷坐标

创建Random类的对象，使用相关方法，生成地雷行坐标与列坐标的随机数值，使用二维数组存储坐标点数据。由于没有做去重处理，因此有概率生成多个相同的坐标，所以地雷数最多为设置的生成数，最少为1(概率极低)。

生成随机坐标的代码如下：

1. public static int[][] createMineCoord() {
2. //定义二维数组
3. int[][] mineCoordArray = new int[Settings.MINE_NUM][Settings.MINE_SITE_NUM];
4. Random random = new Random();
5. //将生成的随机坐标存入数组中
6. for (int i = 0; i < Settings.MINE_NUM; i++) {
7. for (int j = 0; j < Settings.MINE_SITE_NUM; j++) {
8. //生成行坐标随机数,并将其放入数组
9. if (j == Settings.MINE_ROW_IN_ARRAY) {
10. mineCoordArray[i][j] = random.nextInt(Settings.ROW_SIZE);
11. }
12. //生成列坐标随机数,并将其放入数组
13. if (j == Settings.MINE_COL_IN_ARRAY) {
14. mineCoordArray[i][j] = random.nextInt(Settings.COL_SIZE);
15. }
16. }
17. }
18.  
19. return mineCoordArray;
20. }

6.2 测试地雷生成

代码如下：

1. import java.util.Random;
2.  
3. public class Test {
4. public static void main(String[] args) {
5. int[][][] gameData = init();
6. for (int i = 0; i < 10; i++) {
7. for (int j = 0; j < 10; j++) {
8. System.out.print("(");
9. for (int k= 0; k < 3; k++) {
10. System.out.print(gameData[i][j][k]);
11. if (k < 2) {
12. System.out.print(",");
13. }
14. }
15. System.out.print(")");
16. }
17. System.out.println();
18. }
19. }
20.  
21. /**
22. * 初始化游戏数据
23. * @return
24. */
25. private static int[][][] init(){
26. //创建大小为10*10*3的三维数组,并赋初值(默认初始值为0)
27. int[][][] gameData = new int[10][10][3];
28.  
29. //生成随机的地雷坐标，并将其存入游戏数据数组中
30. int[][] mineCoordArray = createMineCoord();
31. for (int[] mineCoord : mineCoordArray) {
32. int row = mineCoord[0];
33. int col = mineCoord[1];
34. gameData[row][col][0] = 1;
35. }
36.  
37. //计算每格周围地雷数并将其存入游戏数据数组中
38.  
39. return gameData;
40. }
41. }

运行结果如下：

将其转化为图像形式就是：

6.3 计算每格周围的地雷数目

思路：遍历目标坐标点周围的8个坐标点，每当发现一个地雷，则目标坐标点的游戏数据数组中的统计地雷的数值加1。

实现代码：

1. private void calcAroundNum() {
2.  
3. for (int i = 0; i < Settings.ROW_SIZE; i++) {
4. for (int j = 0; j < Settings.COL_SIZE; j++) {
5. //遍历当前坐标周围的8个坐标
6. for (int aroundRow = i-1; aroundRow <= i+1; aroundRow++) {
7. //行号超范围则跳过
8. if (aroundRow < 0 || aroundRow > Settings.ROW_SIZE-1) {
9. continue;
10. }
11. for (int aroundCol = j-1; aroundCol <= j+1; aroundCol++) {
12. //列号超范围则跳过
13. if (aroundCol < 0 || aroundCol > Settings.COL_SIZE-1) {
14. continue;
15. }
16. //排除本身坐标点
17. if ((gameData[aroundRow][aroundCol][Settings.MINE_DATA] == Settings.IS_MINE) && (!(aroundRow == i && aroundCol == j))) {
18. gameData[i][j][Settings.AROUND_MINE_DATA] += 1;
19. }
20. }
21. }
22. }
23. }
24.  
25. }

测试运行结果如下：

将其转换为图像表示：

7.游戏运行画面

7.1 踩中地雷

第一、二版：

第三版：

7.2 通关游戏

第一、二版：

第三版：

到此这篇关于利用java开发丐版扫雷游戏的文章就介绍到这了,更多相关java开发扫雷游戏内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/weixin_48304192/article/details/115676029