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

转x33g5p2x  于2022-07-01 转载在 Java  
字(10.6k)|赞(0)|评价(0)|浏览(539)

**摘要：**本程序共封装了五个类，分别是主类GameWin类，绘制底层地图和绘制顶层地图的类MapBottom类和MapTop类，绘制底层数字的类BottomNum类，以及初始化地雷的BottomRay类和工具GameUtil类，用于存静态参数和方法。

本文分享自华为云社区《Java实现扫雷小游戏【完整版】》，作者：橙子!。

效果展示

主类：GameWin类

  1. package com.sxt;
  2. import javax.swing.*;
  3. import java.awt.*;
  4. import java.awt.event.MouseAdapter;
  5. import java.awt.event.MouseEvent;
  7. public class GameWin extends JFrame {
  8.     int width = 2 * GameUtil.OFFSET + GameUtil.MAP_W * GameUtil.SQUARE_LENGTH;
  9.     int height = 4 * GameUtil.OFFSET + GameUtil.MAP_H * GameUtil.SQUARE_LENGTH;
  11.     Image offScreenImage = null;
  12.     MapBottom mapBottom = new MapBottom();
  13.     MapTop mapTop = new MapTop();
  15.     void launch(){
  16.         GameUtil.START_TIME=System.currentTimeMillis();
  17.         this.setVisible(true);
  18.         this.setSize(width,height);
  19.         this.setLocationRelativeTo(null);
  20.         this.setTitle("Java扫雷小游戏");
  21.         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  22.         //鼠标事件
  23.         this.addMouseListener(new MouseAdapter() {
  24.             @Override
  25.             public void mouseClicked(MouseEvent e) {
  26.                 super.mouseClicked(e);
  27.                 switch (GameUtil.state){
  28.                     case 0 :
  29.                         if(e.getButton()==1){
  30.                             GameUtil.MOUSE_X = e.getX();
  31.                             GameUtil.MOUSE_Y = e.getY();
  32.                             GameUtil.LEFT = true;
  33.                         }
  34.                         if(e.getButton()==3) {
  35.                             GameUtil.MOUSE_X = e.getX();
  36.                             GameUtil.MOUSE_Y = e.getY();
  37.                             GameUtil.RIGHT = true;
  38.                         }
  39.                         //去掉break，任何时候都监听鼠标事件
  40.                     case 1 :
  41.                     case 2 :
  42.                         if(e.getButton()==1){
  43.                             if(e.getX()>GameUtil.OFFSET + GameUtil.SQUARE_LENGTH*(GameUtil.MAP_W/2)
  44.                                     && e.getX()<GameUtil.OFFSET + GameUtil.SQUARE_LENGTH*(GameUtil.MAP_W/2) + GameUtil.SQUARE_LENGTH
  45.                                     && e.getY()>GameUtil.OFFSET
  46.                                     && e.getY()<GameUtil.OFFSET+GameUtil.SQUARE_LENGTH){
  47.                                 mapBottom.reGame();
  48.                                 mapTop.reGame();
  49.                                 GameUtil.FLAG_NUM=0;
  50.                                 GameUtil.START_TIME=System.currentTimeMillis();
  51.                                 GameUtil.state=0;
  52.                             }
  53.                         }
  54.                         break;
  55.                     default:
  56.                 }
  57.             }
  58.         });
  60.         while (true){
  61.             repaint();
  62.             try {
  63.                 Thread.sleep(40);
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.     }
  70.     @Override
  71.     public void paint(Graphics g) {
  72.         offScreenImage = this.createImage(width,height);
  73.         Graphics gImage = offScreenImage.getGraphics();
  74.         //设置背景颜色
  75.         gImage.setColor(Color.lightGray);
  76.         gImage.fillRect(0,0,width,height);
  78.         mapBottom.paintSelf(gImage);
  79.         mapTop.paintSelf(gImage);
  80.         g.drawImage(offScreenImage,0,0,null);
  81.     }
  83.     public static void main(String[] args) {
  84.         GameWin gameWin = new GameWin();
  85.         gameWin.launch();
  86.     }
  87. }

底层地图MapBottom类

  1. //底层地图：绘制游戏相关组件
  2. package com.sxt;
  3. import java.awt.*;
  5. public class MapBottom {
  6.     BottomRay bottomRay = new BottomRay();
  7.     BottomNum bottomNum = new BottomNum();
  8.     {
  9.         bottomRay.newRay();
  10.         bottomNum.newNum();
  11.     }
  13.     //重置游戏
  14.     void reGame(){
  15.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  16.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  17.                 GameUtil.DATA_BOTTOM[i][j]=0;
  18.             }
  19.         }
  20.         bottomRay.newRay();
  21.         bottomNum.newNum();
  22.     }
  23.  
  24.     //绘制方法
  25.     void paintSelf(Graphics g){
  26.         g.setColor(Color.BLACK);
  27.         //画竖线
  28.         for (int i = 0; i <= GameUtil.MAP_W; i++) {
  29.             g.drawLine(GameUtil.OFFSET + i * GameUtil.SQUARE_LENGTH,
  30.                     3*GameUtil.OFFSET,
  31.                     GameUtil.OFFSET+i*GameUtil.SQUARE_LENGTH,
  32.                     3*GameUtil.OFFSET+GameUtil.MAP_H*GameUtil.SQUARE_LENGTH);
  33.         }
  34.         //画横线
  35.         for (int i = 0; i <=GameUtil.MAP_H; i++){
  36.             g.drawLine(GameUtil.OFFSET,
  37.                     3*GameUtil.OFFSET+i*GameUtil.SQUARE_LENGTH,
  38.                     GameUtil.OFFSET+GameUtil.MAP_W*GameUtil.SQUARE_LENGTH,
  39.                     3*GameUtil.OFFSET+i*GameUtil.SQUARE_LENGTH);
  40.         }
  41.         for (int i = 1; i <= GameUtil.MAP_W ; i++) {
  42.             for (int j = 1; j <= GameUtil.MAP_H; j++) {
  43.                 //雷
  44.                 if (GameUtil.DATA_BOTTOM[i][j] == -1) {
  45.                     g.drawImage(GameUtil.lei,
  46.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
  47.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
  48.                             GameUtil.SQUARE_LENGTH - 2,
  49.                             GameUtil.SQUARE_LENGTH - 2,
  50.                             null);
  51.                 }
  52.                 //数字
  53.                 if (GameUtil.DATA_BOTTOM[i][j] >=0) {
  54.                     g.drawImage(GameUtil.images[GameUtil.DATA_BOTTOM[i][j]],
  55.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 15,
  56.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 5,
  57.                             null);
  58.                 }
  59.             }
  60.         }
  62.         //绘制数字，剩余雷数，倒计时
  63.         GameUtil.drawWord(g,""+(GameUtil.RAY_MAX-GameUtil.FLAG_NUM),
  64.                 GameUtil.OFFSET,
  65.                 2*GameUtil.OFFSET,30,Color.red);
  66.         GameUtil.drawWord(g,""+(GameUtil.END_TIME-GameUtil.START_TIME)/1000,
  67.                 GameUtil.OFFSET + GameUtil.SQUARE_LENGTH*(GameUtil.MAP_W-1),
  68.                 2*GameUtil.OFFSET,30,Color.red);
  69.         switch (GameUtil.state){
  70.             case 0:
  71.                 GameUtil.END_TIME=System.currentTimeMillis();
  72.                 g.drawImage(GameUtil.face,
  73.                         GameUtil.OFFSET + GameUtil.SQUARE_LENGTH * (GameUtil.MAP_W/2),
  74.                         GameUtil.OFFSET,
  75.                         null);
  76.                 break;
  77.             case 1:
  78.                 g.drawImage(GameUtil.win,
  79.                         GameUtil.OFFSET + GameUtil.SQUARE_LENGTH * (GameUtil.MAP_W/2),
  80.                         GameUtil.OFFSET,
  81.                         null);
  82.                 break;
  83.             case 2:
  84.                 g.drawImage(GameUtil.over,
  85.                         GameUtil.OFFSET + GameUtil.SQUARE_LENGTH * (GameUtil.MAP_W/2),
  86.                         GameUtil.OFFSET,
  87.                         null);
  88.                 break;
  89.             default:
  90.         }
  91.     }
  92. }

顶层地图MapTop类

  1. 顶层地图类：绘制顶层组件
  2. package com.sxt;
  3. import java.awt.*;
  5. public class MapTop {
  6.     //格子位置
  7.     int temp_x;
  8.     int temp_y;
  10.     //重置游戏
  11.     void reGame(){
  12.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  13.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  14.                 GameUtil.DATA_TOP[i][j]=0;
  15.             }
  16.         }
  17.     }
  19.     //判断逻辑
  20.     void logic(){
  21.         temp_x=0;
  22.         temp_y=0;
  23.         if(GameUtil.MOUSE_X>GameUtil.OFFSET && GameUtil.MOUSE_Y>3*GameUtil.OFFSET){
  24.             temp_x = (GameUtil.MOUSE_X - GameUtil.OFFSET)/GameUtil.SQUARE_LENGTH+1;
  25.             temp_y = (GameUtil.MOUSE_Y - GameUtil.OFFSET * 3)/GameUtil.SQUARE_LENGTH+1;
  26.         }
  28.         if(temp_x>=1 && temp_x<=GameUtil.MAP_W
  29.                 && temp_y>=1 && temp_y<=GameUtil.MAP_H){
  30.             if(GameUtil.LEFT){
  31.                 //覆盖,则翻开
  32.                 if(GameUtil.DATA_TOP[temp_x][temp_y]==0){
  33.                     GameUtil.DATA_TOP[temp_x][temp_y]=-1;
  34.                 }
  35.                 spaceOpen(temp_x,temp_y);
  36.                 GameUtil.LEFT=false;
  37.             }
  38.             if(GameUtil.RIGHT){
  39.                 //覆盖则插旗
  40.                 if(GameUtil.DATA_TOP[temp_x][temp_y]==0){
  41.                     GameUtil.DATA_TOP[temp_x][temp_y]=1;
  42.                     GameUtil.FLAG_NUM++;
  43.                 }
  44.                 //插旗则取消
  45.                 else if(GameUtil.DATA_TOP[temp_x][temp_y]==1){
  46.                     GameUtil.DATA_TOP[temp_x][temp_y]=0;
  47.                     GameUtil.FLAG_NUM--;
  48.                 }
  49.                 else if(GameUtil.DATA_TOP[temp_x][temp_y]==-1){
  50.                     numOpen(temp_x,temp_y);
  51.                 }
  52.                 GameUtil.RIGHT=false;
  53.             }
  54.         }
  55.         boom();
  56.         victory();
  57.     }
  58.     //数字翻开
  59.     void numOpen(int x,int y){
  60.         //记录旗数
  61.         int count=0;
  62.         if(GameUtil.DATA_BOTTOM[x][y]>0){
  63.             for (int i = x-1; i <=x+1 ; i++) {
  64.                 for (int j = y-1; j <=y+1 ; j++) {
  65.                     if(GameUtil.DATA_TOP[i][j]==1){
  66.                         count++;
  67.                     }
  68.                 }
  69.             }
  70.             if(count==GameUtil.DATA_BOTTOM[x][y]){
  71.                 for (int i = x-1; i <=x+1 ; i++) {
  72.                     for (int j = y-1; j <=y+1 ; j++) {
  73.                         if(GameUtil.DATA_TOP[i][j]!=1){
  74.                             GameUtil.DATA_TOP[i][j]=-1;
  75.                         }
  76.                         //必须在雷区当中
  77.                         if(i>=1&&j>=1&&i<=GameUtil.MAP_W&&j<=GameUtil.MAP_H){
  78.                             spaceOpen(i,j);
  79.                         }
  80.                     }
  81.                 }
  82.             }
  83.         }
  84.     }
  85.     //失败判定  t 表示失败 f 未失败
  86.     boolean boom(){
  87.         if(GameUtil.FLAG_NUM==GameUtil.RAY_MAX){
  88.             for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  89.                 for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  90.                     if(GameUtil.DATA_TOP[i][j]==0){
  91.                         GameUtil.DATA_TOP[i][j]=-1;
  92.                     }
  93.                 }
  94.             }
  95.         }
  96.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  97.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  98.                 if(GameUtil.DATA_BOTTOM[i][j]==-1&&GameUtil.DATA_TOP[i][j]==-1){
  99.                     GameUtil.state = 2;
  100.                     seeBoom();
  101.                     return true;
  102.                 }
  103.             }
  104.         }
  105.         return false;
  106.     }
  107.     //失败显示
  108.     void seeBoom(){
  109.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  110.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  111.                 //底层是雷,顶层不是旗,显示
  112.                 if(GameUtil.DATA_BOTTOM[i][j]==-1&&GameUtil.DATA_TOP[i][j]!=1){
  113.                     GameUtil.DATA_TOP[i][j]=-1;
  114.                 }
  115.                 //底层不是雷,顶层是旗,显示差错旗
  116.                 if(GameUtil.DATA_BOTTOM[i][j]!=-1&&GameUtil.DATA_TOP[i][j]==1){
  117.                     GameUtil.DATA_TOP[i][j]=2;
  118.                 }
  119.             }
  120.         }
  121.     }
  122.     //胜利判断  t 表示胜利 f 未胜利
  123.     boolean victory(){
  124.         //统计未打开格子数
  125.         int count=0;
  126.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  127.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  128.                 if(GameUtil.DATA_TOP[i][j]!=-1){
  129.                     count++;
  130.                 }
  131.             }
  132.         }
  133.         if(count==GameUtil.RAY_MAX){
  134.             GameUtil.state=1;
  135.             for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  136.                 for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  137.                     //未翻开,变成旗
  138.                     if(GameUtil.DATA_TOP[i][j]==0){
  139.                         GameUtil.DATA_TOP[i][j]=1;
  140.                     }
  141.                 }
  142.             }
  143.             return true;
  144.         }
  145.         return false;
  146.     }
  148.     //打开空格
  149.     void spaceOpen(int x,int y){
  150.         if(GameUtil.DATA_BOTTOM[x][y]==0){
  151.             for (int i = x-1; i <=x+1 ; i++) {
  152.                 for (int j = y-1; j <=y+1 ; j++) {
  153.                     //覆盖,才递归
  154.                     if(GameUtil.DATA_TOP[i][j]!=-1){
  155.                         if(GameUtil.DATA_TOP[i][j]==1){GameUtil.FLAG_NUM--;}
  156.                         GameUtil.DATA_TOP[i][j]=-1;
  157.                         //必须在雷区当中
  158.                         if(i>=1&&j>=1&&i<=GameUtil.MAP_W&&j<=GameUtil.MAP_H){
  159.                             spaceOpen(i,j);
  160.                         }
  161.                     }
  162.                 }
  163.             }
  164.         }
  165.     }
  166.     //绘制方法
  167.     void paintSelf(Graphics g){
  168.         logic();
  169.         for (int i = 1; i <= GameUtil.MAP_W ; i++) {
  170.             for (int j = 1; j <= GameUtil.MAP_H; j++) {
  171.                 //覆盖
  172.                 if (GameUtil.DATA_TOP[i][j] == 0) {
  173.                     g.drawImage(GameUtil.top,
  174.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
  175.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
  176.                             GameUtil.SQUARE_LENGTH - 2,
  177.                             GameUtil.SQUARE_LENGTH - 2,
  178.                             null);
  179.                 }
  180.                 //插旗
  181.                 if (GameUtil.DATA_TOP[i][j] == 1) {
  182.                     g.drawImage(GameUtil.flag,
  183.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
  184.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
  185.                             GameUtil.SQUARE_LENGTH - 2,
  186.                             GameUtil.SQUARE_LENGTH - 2,
  187.                             null);
  188.                 }
  189.                 //差错旗
  190.                 if (GameUtil.DATA_TOP[i][j] == 2) {
  191.                     g.drawImage(GameUtil.noflag,
  192.                             GameUtil.OFFSET + (i - 1) * GameUtil.SQUARE_LENGTH + 1,
  193.                             GameUtil.OFFSET * 3 + (j - 1) * GameUtil.SQUARE_LENGTH + 1,
  194.                             GameUtil.SQUARE_LENGTH - 2,
  195.                             GameUtil.SQUARE_LENGTH - 2,
  196.                             null);
  197.                 }
  198.             }
  199.         }
  200.     }
  201. }

底层数字BottomNum类

  1. //底层数字类
  2. package com.sxt;
  4. public class BottomNum {
  5.     void newNum() {
  6.         for (int i = 1; i <=GameUtil.MAP_W ; i++) {
  7.             for (int j = 1; j <=GameUtil.MAP_H ; j++) {
  8.                 if(GameUtil.DATA_BOTTOM[i][j]==-1){
  9.                     for (int k = i-1; k <=i+1 ; k++) {
  10.                         for (int l = j-1; l <=j+1 ; l++) {
  11.                             if(GameUtil.DATA_BOTTOM[k][l]>=0){
  12.                                 GameUtil.DATA_BOTTOM[k][l]++;
  13.                             }
  14.                         }
  15.                     }
  16.                 }
  17.             }
  18.         }
  19.     }
  20. }

初始化地雷BottomRay类

  1. //初始化地雷类
  2. package com.sxt;
  4. public class BottomRay {
  5.     //存放坐标
  6.     int[] rays = new int[GameUtil.RAY_MAX*2];
  7.     //地雷坐标
  8.     int x,y;
  9.     //是否放置 T 表示可以放置 F 不可放置
  10.     boolean isPlace = true;
  12.     //生成雷
  13.     void newRay() {
  14.         for (int i = 0; i < GameUtil.RAY_MAX*2 ; i=i+2) {
  15.             x= (int) (Math.random()*GameUtil.MAP_W +1);//1-12
  16.             y= (int) (Math.random()*GameUtil.MAP_H +1);//1-12
  17.             //判断坐标是否存在
  18.             for (int j = 0; j < i ; j=j+2) {
  19.                 if(x==rays[j] && y==rays[j+1]){
  20.                     i=i-2;
  21.                     isPlace = false;
  22.                     break;
  23.                 }
  24.             }
  25.             //将坐标放入数组
  26.             if(isPlace){
  27.                 rays[i]=x;
  28.                 rays[i+1]=y;
  29.             }
  30.             isPlace = true;
  31.         }
  33.         for (int i = 0; i < GameUtil.RAY_MAX*2; i=i+2) {
  34.             GameUtil.DATA_BOTTOM[rays[i]][rays[i+1]]=-1;
  35.         }
  36.     }
  37. }

工具GameUtil类

  1. //工具类：存放静态参数，工具方法
  2. package com.sxt;
  3. import java.awt.*;
  5. public class GameUtil {
  6.     //地雷个数
  7.     static int RAY_MAX = 5;
  8.     //地图的宽
  9.     static int MAP_W = 11;
  10.     //地图的高
  11.     static int MAP_H = 11;
  12.     //雷区偏移量
  13.     static int OFFSET = 45;
  14.     //格子边长
  15.     static int SQUARE_LENGTH = 50;
  17.     //插旗数量
  18.     static int FLAG_NUM = 0;
  20.     //鼠标相关
  21.     //坐标
  22.     static int MOUSE_X;
  23.     static int MOUSE_Y;
  24.     //状态
  25.     static boolean LEFT = false;
  26.     static boolean RIGHT = false;
  28.     //游戏状态 0 表示游戏中 1 胜利 2 失败
  29.     static int state = 0;
  31.     //倒计时
  32.     static long START_TIME;
  33.     static long END_TIME;
  35.     //底层元素  -1 雷 0 空 1-8 表示对应数字
  36.     static int[][] DATA_BOTTOM = new int[MAP_W+2][MAP_H+2];
  37.     //顶层元素  -1 无覆盖 0 覆盖 1 插旗 2 差错旗
  38.     static int[][] DATA_TOP = new int[MAP_W+2][MAP_H+2];
  40.     //载入图片
  41.     static Image lei = Toolkit.getDefaultToolkit().getImage("imgs/lei.png");
  42.     static Image top = Toolkit.getDefaultToolkit().getImage("imgs/top.gif");
  43.     static Image flag = Toolkit.getDefaultToolkit().getImage("imgs/flag.gif");
  44.     static Image noflag = Toolkit.getDefaultToolkit().getImage("imgs/noflag.png");
  46.     static Image face = Toolkit.getDefaultToolkit().getImage("imgs/face.png");
  47.     static Image over = Toolkit.getDefaultToolkit().getImage("imgs/over.png");
  48.     static Image win = Toolkit.getDefaultToolkit().getImage("imgs/win.png");
  50.     static Image[] images = new Image[9];
  51.     static {
  52.         for (int i = 1; i <=8 ; i++) {
  53.             images[i] = Toolkit.getDefaultToolkit().getImage("imgs/num/"+i+".png");
  54.         }
  55.     }
  57.     static void drawWord(Graphics g,String str,int x,int y,int size,Color color){
  58.         g.setColor(color);
  59.         g.setFont(new Font("仿宋",Font.BOLD,size));
  60.         g.drawString(str,x,y);
  61.     }
  62. }

总结

在使用Java编写扫雷小游戏时遇到了很多问题，在解决问题时，确实对java的面向对象编程有了更加深入的理解。虽然GUI现在并没有很大的市场，甚至好多初学者已经放弃了学习GUI，但是利用GUI编程的过程对于培养编程兴趣，深入理解Java编程有很大的作用。

本程序共封装了五个类，分别是主类GameWin类，绘制底层地图和绘制顶层地图的类MapBottom类和MapTop类，绘制底层数字的类BottomNum类，以及初始化地雷的BottomRay类和工具GameUtil类，用于存静态参数和方法。

游戏的设计类似windows扫雷，用户在图形化用户界面内利用鼠标监听事件标记雷区，左上角表示剩余雷的数量，右上角动态显示使用的时间。用户可选择中间组件按钮重新游戏。为了解决程序窗口闪动的问题，本程序采用了双缓冲技术。

程序的总体界面布局：

项目结构：

程序测试：

请大家指正！

点击关注，第一时间了解华为云新鲜技术~

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://huaweicloud.blog.csdn.net/article/details/125546346

内容来源于网络，如有侵权，请联系作者删除！

Java技术交流扫雷小游戏GameWin类MapBottom类MapTop类

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com