Java Swing扫雷游戏demo分享

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java Swing扫雷游戏demo分享相关的知识，希望对你有一定的参考价值。

好多年前写过简略的扫雷游戏，模拟windows的。
后来由于多次搬迁环境，弄丢了，遗憾不已啊。
于是趁着这两年还在编程的道路上，趁热再次编写了一次，同时也扩展了功能，更接近windows的扫雷。
此次重写是用Java swing实现的(eclipse开发)，考虑到各位看客可能大部分是Android岗位，于是我着重注意了功能结构化的处理，使游戏核心算法与UI分离，使用回调交互，便于迁移到android环境。




本人对swing不是很熟练，一直以来用swing做项目的人很少，学习资料也少，所有的这些都是在网上现查现用的。各位看客不会没关系，都是jdk里面的api，跟android、winform都很像。




本文思路分以下几步骤讲解：
1、效果图和基本原理。
2、核心算法。
3、程序结构和部分重要函数。
4、demo源码下载。


一、效果图：

技术分享


瞧瞧效果图，顶部是一个图片按钮，使用鼠标事件处理了按下、释放、点击时的图片效果。
中间部分用的是swing的GridLayout布局，跟android的GridLayout一样，除了部分用法不一样。




在某个格子上点击左键时，如果是雷，则输了。同时翻开所有的格子。
在某个格子上点击右键时，会标记为旗子；再点右键，变成问号，再点又还原。
已经点开了的格子上，点击右键无效。
如果点击的某个格子是空白的，则会递归摊开他周边所有不是雷的格子。
游戏结束时，点击顶部的小黄脸按钮，重新开始游戏。
以上部分，是主要功能描述。

二、核心算法：

技术分享

其实啊，就是两个二维数组的对应关系，界面格子二维数组 <==> 程序后台格子状态二维数组。
1、先制造二维数组，然后随机生成一定数量的随机数(认为是雷，赋给对应的数组位置)，要求在二维数组范围内。后台数据二维数组的每个元素，使用了一个对象，需要保存当前格子的好几种状态。

[html] view plain copy
  1. private void initButtons() {  
  2.     isClickComplete = true;  
  3.     if (buttonArr == null) {  
  4.         buttonArr = new JButton[mRowNums][mColumnNums];  
  5.     }  
  6.     for (int i = 0; i < mRowNums; i++) {  
  7.         for (int j = 0; j < mColumnNums; j++) {  
  8.             if (buttonArr[i][j] == null) {  
  9.                 buttonArr[i][j] = new JButton();  
  10.             }  
  11.             setButtonImage(buttonArr[i][j], MineType.MINE_STATUS_BLANK);  
  12.         }  
  13.     }  
  14. }  

JButton的二维数组，添加到GridLayout布局中。


[html] view plain copy
  1. // 初始化所有格子  
  2. private void resetOrCreateGrids(int rowNums, int columnNums) {  
  3.     if (beanArr == null) {  
  4.         beanArr = new MineBean[rowNums][columnNums];  
  5.     }  
  6.     for (int i = 0; i < beanArr.length; i++) {  
  7.         for (int j = 0; j < beanArr[i].length; j++) {  
  8.             if (beanArr[i][j] == null) {  
  9.                 beanArr[i][j] = new MineBean();  
  10.             }  
  11.             beanArr[i][j].reset();  
  12.         }  
  13.     }  
  14. }  

 

[html] view plain copy
  1. public class MineBean {  
  2.     public static int MINE_VALUE = 9;// 是雷子的格子值  
  3.   
  4.     private boolean isClickOpen = false;// 是否左键点开了格子  
  5.     private int mineCount = 0;// 周围雷的个数标记值(如果是9，则为雷)  
  6.     private int imageStatus = MineType.MINE_STATUS_BLANK;// 未点开图片状态  
  7.     ...  
  8. }  

后台数据服务二维数组，每个元素使用一个类来存储数据。

[html] view plain copy
  1. public class MineType {  
  2.     public static final int MINE_STATUS_OPEN_0 = 0;// 周围8个格子中没有雷  
  3.     public static final int MINE_STATUS_OPEN_1 = 1;// 周围8个格子中有1个雷  
  4.     public static final int MINE_STATUS_OPEN_2 = 2;// 周围8个格子中有2个雷  
  5.     public static final int MINE_STATUS_OPEN_3 = 3;// 周围8个格子中有3个雷  
  6.     public static final int MINE_STATUS_OPEN_4 = 4;// 周围8个格子中有4个雷  
  7.     public static final int MINE_STATUS_OPEN_5 = 5;// 周围8个格子中有5个雷  
  8.     public static final int MINE_STATUS_OPEN_6 = 6;// 周围8个格子中有6个雷  
  9.     public static final int MINE_STATUS_OPEN_7 = 7;// 周围8个格子中有7个雷  
  10.     public static final int MINE_STATUS_OPEN_8 = 8;// 周围8个格子中有8个雷  
  11.     public static final int MINE_STATUS_OPEN_9 = 9;// 周围8个格子中有9个雷  
  12.     public static final int MINE_STATUS_BLANK = 10;// 默认格子图片  
  13.     public static final int MINE_STATUS_FLAG = 11;// 格子标记为旗子  
  14.     public static final int MINE_STATUS_UNKNOW = 12;// 格子标记为问号  
  15.     public static final int MINE_STATUS_MINE_CLICK = 13;// 点击了雷子时的图片  
  16.     public static final int MINE_STATUS_DEAD = 14;// 失败时，顶部按钮图片  
  17.     public static final int MINE_STATUS_MILE = 15;// 开始时，顶部按钮图片  
  18.     public static final int MINE_STATUS_WAIT = 16;// 等待时，顶部按钮图片  
  19.     public static final int MINE_STATUS_WIN = 17;// 胜利时，顶部按钮图片  
  20.     public static final int MINE_STATUS_LOGO = 18;// logo标记  
  21. }  

格子需要显示的图片状态。有左键点击后需要显示的状态，有右键点击有需要显示的状态。

[html] view plain copy
  1. private ArrayList<Point> getAroundGrids(int i, int j) {  
  2.     if (beanArr == null) {  
  3.         return null;  
  4.     }  
  5.     // 取当前格子周围的8个点  
  6.     Point point1 = new Point((i - 1), (j - 1));  
  7.     Point point2 = new Point((i - 1), (j));  
  8.     Point point3 = new Point((i - 1), (j + 1));  
  9.     Point point4 = new Point((i), (j - 1));  
  10.     Point point5 = new Point((i), (j + 1));  
  11.     Point point6 = new Point((i + 1), (j - 1));  
  12.     Point point7 = new Point((i + 1), (j));  
  13.     Point point8 = new Point((i + 1), (j + 1));  
  14.     ArrayList<Point> aroundList = new ArrayList<>();  
  15.     aroundList.add(point1);  
  16.     aroundList.add(point2);  
  17.     aroundList.add(point3);  
  18.     aroundList.add(point4);  
  19.     aroundList.add(point5);  
  20.     aroundList.add(point6);  
  21.     aroundList.add(point7);  
  22.     aroundList.add(point8);  
  23.     for (int k = 0; k < aroundList.size(); k++) {  
  24.         Point pointTemp = aroundList.get(k);  
  25.         if (pointTemp.x < 0 || pointTemp.x >= beanArr.length || pointTemp.y < 0  
  26.                 || pointTemp.y >= beanArr[0].length) {  
  27.             // 越界  
  28.             aroundList.remove(k);  
  29.             k--;  
  30.         }  
  31.     }  
  32.     return aroundList;  
  33. }  

这个方法是获取当前位置的周围8个格子算法。需要注意的是，靠边的格子再获取周围8个格子时，会包含越界的。在加入到集合中时，需要过滤越界的数据。
然后就不用再考虑[左上角、右上角、左下角、右下角，左边、上边、右边、下边、内部]等多种情况了。

2、循环后台数据二维数组，每循环一步，找到它周围的8个格子(过滤掉不在UI范围内的)，统计雷子个数，然后给当前这个格子赋值(周围雷子数量值)。


3、最核心的算法：点一个空白格子时，会摊开一大片。这个其实很简单，每次点击一个格子时，显示对应的UI的同时，继续找到它周边的8个格子，然后循环递归调用当前函数。

[html] view plain copy
  1. public void leftClick(int i, int j) {  
  2.     if (beanArr == null || this.callBack == null || this.isGameOver) {  
  3.         return;  
  4.     }  
  5.     MineBean mineBean = getMineBean(i, j);  
  6.     if (mineBean == null) {  
  7.         return;  
  8.     }  
  9.     if (mineBean.isClickOpen()) {  
  10.         return;  
  11.     }  
  12.     mineBean.setClickOpen(true);  
  13.     if (unOpenMines < 0) {  
  14.         unOpenMines = 0;  
  15.     }  
  16.     unOpenMines--;  
  17.     if (mineBean.isMineNow()) {  
  18.         isGameOver = true;  
  19.         gameOver(i, j);  
  20.         return;  
  21.     }  
  22.     if (gameStartTime <= 0) {  
  23.         gameStartTime = System.currentTimeMillis();  
  24.     }  
  25.     if (this.callBack != null) {  
  26.         this.callBack.onLeftClick(mineBean, i, j);  
  27.     }  
  28.     checkWin();  
  29.     if (mineBean.getMineCount() == MineType.MINE_STATUS_OPEN_0) {  
  30.         // 递归摊开一片  
  31.         recursionAround(i, j);  
  32.     }  
  33. }  
  34.   
  35. private void recursionAround(int i, int j) {  
  36.     ArrayList<Point> list = getAroundGrids(i, j);  
  37.     for (int k = 0; k < list.size(); k++) {  
  38.         Point tempPoint = list.get(k);  
  39.         if (tempPoint == null) {  
  40.             continue;  
  41.         }  
  42.         MineBean mineBean = getMineBean(tempPoint.x, tempPoint.y);  
  43.         if (mineBean == null) {  
  44.             continue;  
  45.         }  
  46.         if (mineBean.isMineNow()) {  
  47.             continue;  
  48.         }  
  49.         if (mineBean.isClickOpen()) {  
  50.             continue;  
  51.         }  
  52.         leftClick(tempPoint.x, tempPoint.y);  
  53.     }  
  54. }  

上面代码就是点击某个格子后，显示UI，同时处理递归摊开一片的算法。


4、UI点击格子时，提供横竖坐标，传递给算法工具类对象处理。算法函数中找到对应的数据位置，判断情况再回调给UI显示。避免UI与算法函数耦合度太高，难以移植。

[html] view plain copy
  1. public interface CallBack {  
  2.     void onInit();  
  3.   
  4.     void onWin(long time);// 胜利  
  5.   
  6.     void onGameOver();// 失败  
  7.   
  8.     void onLeftClick(MineBean mineBean, int i, int j);  
  9.   
  10.     void onRightClick(MineBean mineBean, int i, int j);  
  11. }  


以上部分是核心算法描述。


三、程序结构和部分重要函数。

技术分享

[html] view plain copy
  1. // 初始化随机雷子  
  2. private void makeRandomMines() {  
  3.     if (beanArr == null) {  
  4.         return;  
  5.     }  
  6.     int nowMines = 0;  
  7.     while (nowMines < mMineCount) {  
  8.         int i = random.nextInt(beanArr.length);  
  9.         int j = random.nextInt(beanArr[0].length);  
  10.         MineBean mineBean = beanArr[i][j];  
  11.         if (!mineBean.isMineNow()) {  
  12.             mineBean.setMineNow();  
  13.             nowMines++;  
  14.         }  
  15.     }  
  16. }  
  17.   
  18. // 计算格子周围雷子状态  
  19. private void initGridAroundStatus() {  
  20.     if (beanArr == null) {  
  21.         return;  
  22.     }  
  23.     for (int i = 0; i < beanArr.length; i++) {  
  24.         for (int j = 0; j < beanArr[i].length; j++) {  
  25.             MineBean mineBean = beanArr[i][j];  
  26.             if (mineBean.isMineNow()) {  
  27.                 // 当前格子是雷  
  28.                 continue;  
  29.             }  
  30.             // 取当前格子周围有效的格子集合  
  31.             ArrayList<Point> list = getAroundGrids(i, j);  
  32.             int mineCount = 0;  
  33.             Point tempPoint = null;  
  34.             MineBean tempBean = null;  
  35.             // 统计这些点是否是雷子  
  36.             for (int k = 0; k < list.size(); k++) {  
  37.                 tempPoint = list.get(k);  
  38.                 if (tempPoint == null) {  
  39.                     continue;  
  40.                 }  
  41.                 tempBean = getMineBean(tempPoint.x, tempPoint.y);  
  42.                 if (tempBean == null) {  
  43.                     continue;  
  44.                 }  
  45.                 if (tempBean.isMineNow()) {  
  46.                     mineCount++;  
  47.                 }  
  48.             }  
  49.             mineBean.setMineCount(mineCount);  
  50.         }  
  51.     }  
  52. }  



怎么判断输赢呢？

[html] view plain copy
  1. private void checkWin() {  
  2.     if (flagMines != unOpenMines) {  
  3.         return;  
  4.     }  
  5.     isGameOver = true;  
  6.     if (this.callBack != null) {  
  7.         this.callBack.onWin(System.currentTimeMillis() - gameStartTime);  
  8.     }  
  9. }  


我弄了两个变量，flagMines被标记的旗子，unOpenMines未被点开的格子个数。如果两者相等，就是胜利了。如果点到了雷，就输了




核心算法和逻辑都已描述，可能说的不直观，如果没进入状态还是很难看明白的，慢慢领悟吧。




还好后面提供源码下载。欢迎留言批评。


http://download.csdn.net/detail/fesdgasdgasdg/9867460






































































以上是关于Java Swing扫雷游戏demo分享的主要内容，如果未能解决你的问题，请参考以下文章

《游戏学习》Java版仿windows扫雷小游戏源码

无聊的周末用Java写个扫雷小游戏

java小项目之：扫雷，这游戏其实没有那么简单！

扫雷游戏

用Python写扫雷游戏实例代码分享还有很多小游戏代码

全文手敲代码，教你用Java实现扫雷小游戏