扫雷小游戏（两小时完成）

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量3.2k 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63808944/article/details/122005489
版权

扫雷小游戏（两小时完成版）

游戏介绍：一共三个难度分别为简单（88,5颗雷），中等（1212,15颗雷），困难（5*15,30颗雷);

功能介绍：可进行难度选择、窗体内包括雷区、随机布置地雷、不能踩到地雷、鼠标单击重新开始可清零重新选择难度开始、游戏状态下可以实现通过单机难度选择用来改变难度、左键用于打开格子、右键是辅助功能插旗子、再次点击可以消除旗子、中键可以画鸭。

知识总结： 变量、数据类型、判断语句、循环结构、数组、二维数组、递归、简单窗口创建、图形图片绘制、鼠标事件

一、创建四个类（MineClearanceUI、MineListener、MinePanel、GameSelect）一个接口（Mineconfig）

（1）MineClearanceUI：窗口主函数入口

（2）MineListener：监听器，调用minePanel的画笔用来画地雷数字等；

（3）MinePanel：重绘地雷、数字、棋子等元素。

（4）Mineconfig；接口用来储存不变的定量（）

//接口代码
public interface Mineconfig {
    int X=20;
    int Y=20;
    //C代表行列 也代表难度选择
    int C=8;
    int R=8;
    int C2=12;
    int R2=12;
    int C3=15;
    int R3=15;
    //间隔
    int SIZE=25;
    //雷
    Image imagelei = new ImageIcon("D:\\图片\\扫雷\\HandGrenades.png").getImage();
    //棋子
    Image imageFlags = new ImageIcon("D:\\图片\\扫雷\\flag.gif").getImage();
    //顶层的这苍梧
    Image imagetop = new ImageIcon("D:\\图片\\扫雷\\top.gif").getImage();//顶层图片
    //彭于晏
    Image imagePYY = new ImageIcon("D:\\图片\\扫雷\\PYY.jpg").getImage();
    //鸭子
    Image imageNoflag = new ImageIcon("D:\\图片\\扫雷\\noflag.png").getImage();
}
二、简单窗口绘制，以及添加鼠标监听器和动作监听器
（1）绘制一个宽高为（260,330）的窗体
（2）往窗体上添加两个面板（MinePanell，btnPanel）

1）MinePanel以及btnPanel上添加鼠标监听器和动作监听器（ml），以及按钮（名称、颜色）

2）MinePanle以及btnPanel需要设置成边框布局（BorderLayout一北一南），其中南北的边框布局只能设置高度。

（3）在面板MinePanel上获取画笔，并把画笔传到MIneListener中用于画雷等
public class MineClearanceUI {
    //主函数
    public static void main(String[] args) {
        MineClearanceUI mc=new MineClearanceUI();
            mc.mineClearance();
    }
    //监听器对象
    MineListener ml=new MineListener();
    public void mineClearance(){
        JFrame jf=new JFrame();
        //限制窗口大小 可通过jfX,jfY来修改
        jf.setSize(260,330);
        jf.setTitle("扫雷");
        //可关闭 jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        //minPanel 为扫雷画板，注意不要创建两个同个类
        MinePanel minePanel=new MinePanel();//扫雷面板继承了JPanel所一不要同时JPanel MPnael同时存在，
        // JPanel MPnael要是同时存在的话会想到那个于重新创建了一个对象每个JPanel的属性和方法并不是相通的，在MinePanel里就画不出网格。
        //按钮面板
        JPanel btnJpanel=new JPanel();
        //尺寸
        Dimension dim=new Dimension(0,250);
        Dimension dim1=new Dimension(0,40);
        minePanel.setPreferredSize(dim);
        btnJpanel.setPreferredSize(dim1);
        //设置颜色
        minePanel.setBackground(Color.lightGray);
        btnJpanel.setBackground(Color.pink);
		//窗体添加两个面板:面板JPanel默认是流式布局：FlowLayout
        //此时注意 窗体JFrame是边框布局：BorderLayout
        jf.add(minePanel,BorderLayout.NORTH);
        jf.add(btnJpanel,BorderLayout.SOUTH);
        initJButton(btnJpanel,ml);//添加动作监听器
        jf.setVisible(true);
        //面板获取画笔
        Graphics g=minePanel.getGraphics();
        ml.g=g;
        //扫雷面板获取鼠标监听器
        minePanel.addMouseListener(ml);
        //传数组以及获得该方法；
        ml.steMinePanel(minePanel);
        //传jf对象用来改变窗体大小
        ml.jf=jf;
    }
    //封装添加按钮的方法
    public void initJButton(JPanel jPanel, ActionListener al){
        Dimension dim2=new Dimension(100,30);
        JButton xbt=new JButton();
        JButton rbt=new JButton();
        xbt.setPreferredSize(dim2);
        rbt.setPreferredSize(dim2);
        String name1="选择难度";
        String name2="重新开始";
        //添加动作监听器
        xbt.addActionListener(al);
        rbt.addActionListener(al);
        //添加名字
        xbt.setText(name1);
        rbt.setText(name2);
        jPanel.add(xbt);//添加是两个组件添加起来
        jPanel.add(rbt);
    }
}
三、监听器MineListener
(1）定义该有的参数，以及添加监听（ActionListener,MouseListener）和接口（Mineconfig）；
1)其中画数字：

（1）建立数组 imagesnum 同来储存（0~8）数字；并且把 图片地址获取；其中字符串+int类型的数字就会转换成对应数字的字符;

static Image[] imagesnum=new Image[9];//存图片
static{
        for (int i=1;i<=8;i++){//字符串的加法，字符串＋int类型的数字就会转换成对应数字的字符
            imagesnum[i]=new ImageIcon("D:\\图片\\扫雷\\num\\"+i+".png").getImage();
        }
    }

2)传画笔（ Graphics ）以及把数组（ leiArray、topArray）顶层坐标（ topx、topy ）传到MinePanel类里，到时会用来重绘

public void setGraphics(Graphics g){this.g=g;}
    MinePanel minePanel;
    public void steMinePanel( MinePanel minePanel){
        this.minePanel=minePanel;
        minePanel.leiArray=leiArray;
        minePanel.topArray=topArray;
        minePanel.topx=topx;
        minePanel.topy=topy;
    }

阶段代码

public class MineListener implements ActionListener, MouseListener, Mineconfig {
    JFrame jf;//定义一个窗体，用来做改变窗体的大小
    public Graphics g;//传画笔；
    int[][] leiArray=new int[C+2][R+2];//用来记录雷区并且重绘雷
    int[][] topArray=new int[C+2][R+2];//用来画顶层
    int topx,topy;//用来翻牌坐标
    int x,y;//获取坐标
    int count=0;//用来计数//不能放click方法里面要不然会点一次从新创建一次
    int leinum;//用来修改雷数
    int countWin;//用来判断输赢
    int jfX,jfY;//窗体的宽高

    //雷图片
    static Image[] imagesnum=new Image[9];//存图片
    static{
        for (int i=1;i<=8;i++){//字符串的加法，字符串＋int类型的数字就会转换成对应数字的字符
            imagesnum[i]=new ImageIcon("D:\\图片\\扫雷\\num\\"+i+".png").getImage();
        }
    }
    public void setGraphics(Graphics g){this.g=g;}
    MinePanel minePanel;
    public void steMinePanel( MinePanel minePanel){
        this.minePanel=minePanel;
        minePanel.leiArray=leiArray;
        minePanel.topArray=topArray;
        minePanel.topx=topx;
        minePanel.topy=topy;
    }
    //用来传递MineListenner的监听器
    GameSelect gameSelect =new GameSelect();

3）为什么数组int[][] leiArray=new int[C+2][R+2]要加2如图所示

在这里插入图片描述

把数组放大2 这样就可以在 画数字的时候防止越界问题的发生，以及对topArray数组的坐标矫正方便很多！即只画上面7*7区域，最外围不画这样就巧妙的避免了越界问题1

（2）画雷（setMine）

1）创建一个新的画雷的封装方法

public void setMine(){
        //System.out.println("leinum="+leinum);
    //for循环<leinum：表示画雷的个数
        for(int k=0;k<leinum;k++) {
            //创建一个自由数的类
            Random random = new Random();
            //能取到的值（数组长度-2）+1由(0-7)到（1-8）这是避免取0，防止画数字时越界//地雷的行数
            //这样就能（x，y）的值就能画满整个面板的值
            //地雷的列数//为什么取8因为的的二维数组的长度为9，下标				只能是（0-8）
            x=random.nextInt(leiArray.length-2)+1;
            y=random.nextInt(leiArray.length-2)+1;
			//防止雷的重复！！非常重要
            if(leiArray[x][y]!=0){
                k=k-1;
                continue;
            }
            setBoom(g);//画雷
        }
    }
	//遍历雷的封装
    public void setBoom(Graphics g){
        //把-1赋值给数组当前leiArray[x][y]，并记录为-1
        leiArray[x][y] = -1;
        //如果上面的nexInt取就会超过该数组的长度，该数组的长度为arr1[9][9],意思是下标的取值范围为（0-8）//以简单为例
        //把赋值给二维数组，为什么选10呢？一个空格或者一个数外围最多能够做0-8个;
        //如果数组leiArray[x][y]=-1，就画雷
        if (leiArray[x][y]==-1){
            for (int i = 0; i < leiArray.length; i++) {
                for (int j = 0; j < leiArray.length; j++){ 
 					g.drawImage(imagelei, x * SIZE, y * SIZE, 20, 20, null);
                }
            }
        }
    }
(4)画数字：
//数字封装
    public void setNum(){
        //+2的原因是因为遍历的数组要比8*8要大一圈,
        for (int i=1;i<leiArray.length;i++){
            for(int j=1;j<leiArray.length;j++){
                if (leiArray[i][j]==-1){//如果在x,y坐标处有雷
                    setImagesnum(i,j,g);//遍历数字
                }
            }
        }
    }
//遍历数字封装
    public void setImagesnum(int i,int j,Graphics g){
        for (int k=i-1;k<i+2;k++) {//在他的周围(x-1,x+1),(y-1,y+1)遍历上数字
            for (int l = j - 1; l < j + 2; l++) {
                if (leiArray[k][l] >= 0) {
                    leiArray[k][l]++;
              //相当于count++;下面这个数组储存的是1，就画1，如果没有储存数就不遍历；
                    if (k > 0 && k < 9 && l > 0 && l < 9&&leiArray[k][l]<9){
                        //取得值1但是数组的arr1[9][9]=1;这个时候还是会画1;因此数组的长度要<9.
						g.drawImage(imagesnum[leiArray[k][l]], k * SIZE, l * SIZE, 15, 15, null);
                    }
                }
            }
        }
    }

阶段性成果：如下图

在这里插入图片描述

（5）画遮挡物
//遮挡物封装
    public void setObstructions(){
        for (int i=1;i<leiArray.length-1;i++){//+2的原因是因为遍历的数组要比8*8要大两圈
            for(int j=1;j<leiArray.length-1;j++){
                g.drawImage(imagetop,i * SIZE-5, j * SIZE-5, 26, 26, null);
                topArray[i][j]=100;
            }
        }
    }
（6）简易版扫雷(1)

把上面的画雷、画数字、画遮挡物的函数放到**public void actionPerformed(ActionEvent e) {}**函数中

public void actionPerformed(ActionEvent e) {
        //点击开始游戏，再去绘制
        String strs=e.getActionCommand();//鼠标监听获取操作命令
        if (strs.equals("选择难度")) {
           //画雷 -1代表雷
        setMine();
        //画数字 [i]代表数字
        setNum();
        //画遮挡物
        setObstructions();
        }

阶段性成果：如下图

在这里插入图片描述

这样我们简单的难度的底层地雷以及上层遮挡物已经做好了！

（7）创建一个选择难度窗口：选择难度

当点击选择难度时跳出这样的一个窗口。

注意：这里的监听器和原先界面的监听器时一样的

上面有三个按钮（如图）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jImyItqK-1639748156363)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1639742364831.png)]

（1）需要在类GameSelect里定义ActionListener al;//属性或者对象

public class GameSelect {
    ActionListener al;//属性或者对象

（2）在类MineListener里面做新创建对象然后在点击“选择难度”的时候把这个窗口弹出

GameSelect gameSelect =new GameSelect();
    @Override
    public void actionPerformed(ActionEvent e) {
        //点击开始游戏，再去绘制
        String strs=e.getActionCommand();//鼠标监听获取操作命令
        if (strs.equals("选择难度")) {
            //this代表的是本类对象（mineListener）
            gameSelect.al=this;//传监听器给GameSelect
            gameSelect.gameSlect();//显示新创建的创口
        }

(3)GameSelect窗口代码如下

//类能够调用方法和属性，对象调用方法必须要在函数里面
public class GameSelect {
    ActionListener al;//属性或者对象
    public void gameSlect(){
        JFrame selectJF=new JFrame();
        selectJF.setSize(200,210);
        selectJF.setDefaultCloseOperation(2);
        selectJF.setLocationRelativeTo(null);
        setJButton(selectJF,al);//this 表示本类对象
        selectJF.setVisible(true);

    }
    public void setJButton(JFrame selectJF,ActionListener al){
        //尺寸
        Dimension dim1=new Dimension(180,50);
        JButton easy=new JButton("简单(8*8,5颗雷)");
        JButton medium=new JButton("中等(12*12,15颗雷)");
        JButton hard=new JButton("困难(15*15,30颗雷)");
        //尺寸
        easy.setPreferredSize(dim1);
        medium.setPreferredSize(dim1);
        hard.setPreferredSize(dim1);
        //添加监听器
        easy.addActionListener(al);
        medium.addActionListener(al);
        hard.addActionListener(al);
        //一定要添加一个布局要不然会被覆盖，JFrame默认是边框布局 BorderLayoiut(南北只设置高度，东西只设置宽度)，JPanel默认是流失布局Flowlyout
        selectJF.setLayout(new FlowLayout());
        selectJF.add(easy);
        selectJF.add(medium);
        selectJF.add(hard);
    }
    public void getEasy(){
        System.out.println("获取简单难度");
    }
    public void getMedium(){
        System.out.println("获取中等难度");
    }
    public void getHard(){
        System.out.println("获取困难难度");
    }
}
（8）实现 简单(88,5颗雷)、中等(1212,15颗雷)、困难(15*15,30颗雷)三中类型的窗口大小变换，以及雷区、数字、遮挡物的绘画

在类MineListener里

GameSelect gameSelect =new GameSelect();
    @Override
    public void actionPerformed(ActionEvent e) {
        //点击开始游戏，再去绘制
        String strs=e.getActionCommand();//鼠标监听获取操作命令
        if (strs.equals("选择难度")) {
            gameSelect.al=this;//传监听器给GameSelect
            gameSelect.gameSlect();//显示新创建的创口
        }
        if (strs.equals("简单(8*8,5颗雷)")){
            gameSelect.getEasy();
            again();
            //简单的数组
            leiArray=new int[C+2][R+2];
            topArray=new int[C+2][R+2];
            //雷数
            leinum=5;
            //等于5时判赢
            countWin=5;
            //jf窗体大小
            jfX=260;
            jfY=320;
            //尺寸
            Dimension dim=new Dimension(0,240);
            minePanel.setPreferredSize(dim);
        }
        
        if (strs.equals("中等(12*12,15颗雷)")){
            gameSelect.getMedium();
            again();
            //中等的数组
           leiArray=new int[C2+2][R2+2];
           topArray=new int[C2+2][R2+2];
            //雷数以及=6时判赢
            leinum=15;
            countWin=15;
            //窗体大小以及画板的大小
            jfX=370;
            jfY=430;
            Dimension dim=new Dimension(0,350);//尺寸
            minePanel.setPreferredSize(dim);
        }
        if (strs.equals("困难(15*15,30颗雷)")){
            gameSelect.getHard();
            again();
             //困难的数组
            leiArray=new int[C3+2][R3+2];
            topArray=new int[C3+2][R3+2];
            leinum=30;
            countWin=30;
            //窗体大小
            jfX=435;
            jfY=490;
            Dimension dim=new Dimension(0,410);//尺寸
            minePanel.setPreferredSize(dim);

        }
        //画雷 -1代表雷
        setMine();
        //画数字 [i]代表数字
        setNum();
        //画遮挡物
        setObstructions();
        minePanel.leiArray=leiArray;
        minePanel.topArray=topArray;
        jf.setSize(jfX,jfY);//改变窗体大小
        if (strs.equals("重新开始")){
            //点击重新开始，所有数据清零
            again();
        }
        minePanel.repaint();
    }
    //重新开始封装
    public void again(){
        for (int i=1;i<leiArray.length-1;i++) {
            for (int j = 1; j < leiArray.length - 1; j++) {
                leiArray[i][j] = 0;
                topArray[i][j] = 0;
                count = 0;
                leinum = 0;
                countWin = 0;
            }
        }
    }
实现效果如图：

在这里插入图片描述
在这里插入图片描述

九、实现翻开功能
（1）翻开 空 时实现递归功能：
（2）翻到雷时实现炸雷效果：
（3）右键画旗子（再次右键点击旗子消失）：
 @Override
//先获取顶层的坐标
    public void mousePressed(MouseEvent e) {
        //鼠标的坐标
        int x=e.getX();
        int y=e.getY();
        //取整矫正
        topx=(x-X+SIZE)/SIZE;//取整用来点击翻开
        topy=(y-Y+SIZE)/SIZE;
    }
右键画旗子（再次右键点击旗子消失）：
//画旗子 topArray[topx][topy]=-2;
    if (e.getButton()==MouseEvent.BUTTON3){//点击右键
        
        if (topArray[topx][topy] == 100) {
            topArray[topx][topy]=-2;
            if (topArray[topx][topy] == -2 && leiArray[topx][topy] == -1) {
                count++;
                //定义一个count用来判输赢，当雷的坐标和棋子坐标重合数为count的数时，则判赢
                System.out.println("count=" + count);
            }
            //右键再次点击旗子，重绘遮挡物 -100表示遮挡物
        }else {topArray[topx][topy] = 100;}
        //判输赢countWin时能赢
        if (count==countWin){
            JOptionPane.showMessageDialog(minePanel,"YouWIN");
            }
        }
    //画鸭子  topArray[topx][topy]=-3;
    if (e.getButton()==MouseEvent.BUTTON2){//中键画鸭子
            topArray[topx][topy]=-3;//画鸭子标识问号
        }
        minePanel.repaint();
    }
打开递归，炸雷、功能的实现：
@Override
    public void mouseClicked(MouseEvent e) {
        //打开雷以及递归
    if(e.getButton()==MouseEvent.BUTTON1){
        setOpen(topx,topy);
        }
        //打开方法
    public void setOpen(int topx,int topy){
        //打开的是数字,数在leiArray[][]数组里的值肯定>0
        if (leiArray[topx][topy]>0) {
            //顶层的数组在该坐标的值变为0，即遮挡物消失
            topArray[topx][topy]=0;
        }
        //当点到雷的时候
        if(leiArray[topx][topy]==-1){
            //顶层的所有遮挡物全部赋值为0即全部消失
            for(int i=1;i<leiArray.length-1;i++){
                for (int j=1;j< leiArray.length-1;j++){
                    //顶层的数组值全部为零
                    topArray[i][j]=0;
                    //在雷的位置画彭于晏（炸雷）
                    if (leiArray[i][j]==-1){
                        //把值-3赋值给雷数组这样就可以在消失瞬间在雷的位置，画彭于晏
                        leiArray[i][j]=-10;//-3表示炸出彭于晏
                    }
                }
            }
            //弹出结束窗口
            JOptionPane.showMessageDialog(minePanel,"你惨了，你坠入爱河了！");//放上面会那个重绘 数组的长度 遍
        }
       //递归的实现，如果leiArray[topx][topy]=0；即直接打开 该坐标范围x∈[ topx - 			1,topx + 2),y∈[ topx - 1,topx + 2)一共九个坐标的值
       //周围的
        if(leiArray[topx][topy]==0&&topx< leiArray.length-1&&topy< leiArray.length-1) {//条件防越界topx，topy的值不能超过数组的范围
            for (int i = topx - 1; i>=0&&i < topx + 2; i++) {
                for (int j = topy - 1; j>=0&&j < topy + 2; j++) {
      //递归，原理是如果顶层遮挡物的值！=0，赋值0给该坐标的数组，这样就能形成扩散现象.
                    //碰到了数字
                    if ( topArray[i][j] != 0) {
                        //打开该数字的顶层遮挡物
                        topArray[i][j] = 0;
                        //防止递归的时候超出雷区的范围
                       if(i>0&&j>0&&i<leiArray.length-1&&j<leiArray.length-1){
                            //再次调用set方法为了再次做判断
                            setOpen(i,j);
                           //递归实现
                        }
                    }
                }
            }
        }
    }
10、重绘的实现类MinePanel
public class MinePanel extends JPanel implements Mineconfig {
    //二维数组用来遍历
    public int[][] leiArray;
    //画顶层的遮挡物
    int[][] topArray;
    int topx,topy;
    static Image[] imagesnum=new Image[9];//存图片
    static{
        for (int i=1;i<=8;i++){
        imagesnum[i]=new ImageIcon("D:\\图片\\扫雷\\num\\"+i+".png").getImage();
        }
    }
    //重写paint方法
    public void paint(Graphics g) {
        super.paint(g);
        //画线
        for (int i = 0; i < leiArray.length-1; i++) {
            //(leiArray.length-2)是因为要根据数组的长度来画线
         	g.drawLine(X, Y + i * SIZE, X +  (leiArray.length-2) * SIZE, Y + i * SIZE);
            g.drawLine(X + i * SIZE, Y, X + i * SIZE, Y + (leiArray.length-2) * SIZE);
        }
        //重绘雷 -1
            for (int i=0;i<leiArray.length-1;i++){
                for (int j=0;j<leiArray.length-1;j++){
                    if (leiArray[i][j]==-1) {
                      g.drawImage(imagelei, i * SIZE, j * SIZE, 20, 20, null);
                    }
                    //重绘彭于晏
                    if(leiArray[i][j]==-10){
                  g.drawImage(imagePYY, i * SIZE-5, j * SIZE-5, 25, 25, null);
                    }
                }
            }
        //重绘数字
        for (int i=1;i<leiArray.length-1;i++){
            for (int j=1;j<leiArray.length-1;j++){
                //或用双斜杠表示
                if (leiArray[i][j]==1||leiArray[i][j]==2||leiArray[i][j]==3||leiArray[i][j]==4||leiArray[i][j]==5||leiArray[i][j]==6
                ||leiArray[i][j]==7||leiArray[i][j]==8) {
                    g.drawImage(imagesnum[leiArray[i][j]], i * SIZE, j * SIZE, 15, 15, null);
                }
            }
        }
        //重绘的遮挡物;topArray[i][j]==100
        for (int i=0;i<topArray.length-1;i++){//+2的原因是因为遍历的数组要比8*8要大两圈
            for(int j=0;j<topArray.length-1;j++){
                if (topArray[i][j]==100) {
                    g.drawImage(imagetop, i * SIZE - 5, j * SIZE - 5, 26, 26, null);
                }
            }
        }
        //重绘旗子
        for (int i=0;i<topArray.length-1;i++){//+2的原因是因为遍历的数组要比8*8要大两圈
            for(int j=0;j<topArray.length-1;j++){
                //子
                if (topArray[i][j]==-2) {
                    g.drawImage(imageFlags, i * SIZE - 5, j * SIZE - 5, 26, 26, null);
                }
                //重绘鸭
                if(topArray[i][j]==-3){
                    g.drawImage(imageNoflag, i * SIZE-5, j * SIZE-5, 25, 25, null);
                }
            }
        }
    }
}

11、解决提前看到雷 的方法

直接在MineListener把数字雷的 g.drawImage方法注释掉即可，原理是因为只赋值不画，点开的时候再在MinePanel的重绘！

//遍历雷的封装
    public void setBoom(Graphics g){
        leiArray[x][y] = -1;//如果上面的nexInt取就会超过该数组的长度，该数组的长度为arr1[9][9],意思是下标的取值范围为（0-8）
        if (leiArray[x][y]==-1){//把赋值给二维数组，为什么选10呢？一个空格或者一个数外围最多能够做0-8个;
            for (int i = 0; i < leiArray.length; i++) {
                for (int j = 0; j < leiArray.length; j++) {
//                    g.drawImage(imagelei, x * SIZE, y * SIZE, 20, 20, null);
                }
            }
        }
    }

//遍历数字封装
    public void setImagesnum(int i,int j,Graphics g){
        for (int k=i-1;k<i+2;k++) {//在他的周围(x-1,x+1),(y-1,y+1)遍历上数字
            for (int l = j - 1; l < j + 2; l++) {
                if (leiArray[k][l] >= 0) {
                    leiArray[k][l]++;
                    //相当于count++;下面这个数组储存的是1，就画1，如果没有储存数就不遍历；
                    if (k > 0 && k < 9 && l > 0 && l < 9&&leiArray[k][l]<9){
                        //取得值1但是数组的arr1[9][9]=1;这个时候还是会画1;
//                        g.drawImage(imagesnum[leiArray[k][l]], k * SIZE, l * SIZE, 15, 15, null);
                    }
                }
            }
        }
    }

结束Good Luck for you！

MXS—COLIE
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
炸雷（详细解析）
ASBSIHD的博客
04-06 612
玩家可以发射 mm 个排雷火 箭, 小明已经规划好了每个排雷火箭的发射方向, 第 jj 个排雷火箭 \left(x_{j}, y_{j}, r_{j}\right)(xj​,yj​,rj​) 表 示这个排雷火箭将会在 \left(x_{j}, y_{j}\right)(xj​,yj​) 处爆炸, 它的爆炸范围是以半径为 r_{j}rj​ 的一个圆, 在其爆炸范围内的炸雷会被引爆。接下来的 nn 行, 每行三个整数 x_{i}, y_{i}, r_{i}xi​,yi​,ri​, 表示一个炸雷的信息。
mine clearance
03-26
c# visual studio 2008 扫雷 实现连击显示周围雷数
JavaScript扫雷游戏mineClearance
尐轩web前端网络日志
05-08 3318
这个扫雷游戏是当年（去年）我刚学完JavaScript后自己做的一个练习小项目 不算html、css也有近1000行的代码 时隔一年，现在一看当时写的仍然有不成熟的地方现在拿出来希望对一些初学的小伙伴有所帮助功能及界面如下游戏难度选择游戏时间及剩余雷数记录双击或鼠标滑轮键智能扫雷如果点击的方格上的数字和周围插旗的数量相等 那么周围没有点开的方格都会被点开 （不相等就会有×的动画）失败界面胜利
JAVA基础课程设计 简易扫雷
热门推荐
M阳光的专栏
01-03 1万+
以下每行代码,文字均为原创,转载请注明出处. 程序一共分为7个文件,每个文件为一个类 文件名 功能描述 Test.java 测试类,包含main()函数 Mine.java 设计主界面, Calmine.java 随机雷的位置.计算雷区点击后应该显示的数字 My_button.java 继承自button类,添加按钮的坐标x,y
java 简易扫雷_JAVA基础课程设计 简易扫雷
weixin_34313368的博客
02-16 348
以下每行代码,文字均为原创,转载请注明出处.程序一共分为7个文件,每个文件为一个类文件名功能描述Test.java测试类,包含main()函数Mine.java设计主界面,Calmine.java随机雷的位置.计算雷区点击后应该显示的数字My_button.java继承自button类,添加按钮的坐标x,y.Num_Mine.java雷数,包括用户以标记的雷数,标记正确的雷数,以及总雷数Click...
java小游戏 扫雷 java小游戏 扫雷
06-23
java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java小游戏 扫雷java...
android studio 安卓扫雷小游戏源代码
06-13
android studio 安卓扫雷小游戏源代码 运用Android 制作扫雷游戏，制作简单，没有复杂的代码，对于熟悉Android的页面布局,跳转有帮助理解=。这个扫雷还有点瑕疵，广大程序员们可以对其修改和完善。
基于EasyX的扫雷小游戏
02-02
【扫雷小游戏与EasyX库】 扫雷是一款广受欢迎的经典电脑游戏，旨在锻炼玩家的逻辑推理和观察能力。在这个项目中，我们将探讨如何使用EasyX库来实现一个基于C++的扫雷小游戏。EasyX是一个轻量级的Windows图形库，它...
C语言实现简单扫雷小游戏
01-01
本文实例为大家分享了C语言实现扫雷小游戏的具体代码，供大家参考，具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include #include #include /* 用 C 语言写一个简单的扫雷游戏 */ // 1.写一个游戏菜单 Menu...
基于java开发的扫雷小游戏
11-15
基于java开发的扫雷小游戏
java学习笔记4
zx616122的博客
11-26 4526
异常处理 1.计算两数相乘的结果，要求乘数不能超过99，超过就抛出异常 class MyException extends Exception{ //自定义异常类，继承Exception类 public MyException(String msg){ //构造方法接收异常信息 super(msg); //调用父类中的构造方法 } } public class Throwdemo { public static void mai
java实现扫雷（myeclipse）
wang1115868的博客
06-29 1092
JAVA实现扫雷（myeclipse）简单的目录Block代码blockstate代码BlockType代码DialogRecordName代码DialogSelfDefineDialogShowRecord代码Grade代码MineFrameMinePanel代码Record代码RecordDao代码saolei代码UpdateTimeTask上面为所有的代码，图片就不往上面发了，根据要求存放就...
扫雷（java图形界面好例题）
寻找、发现、追求、获得———这就是狼的生活要素
05-08 4110
CleanMine.java package xjj; import java.awt.BorderLayout; import java.awt.Dimension; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.ButtonGroup; import
零基础学写《扫雷》游戏（Qt）
啊渊的专栏
04-01 9602
扫雷游戏是在windows系统中自带的游戏，他的游戏玩法其实很简单，20世纪初期电脑上没有啥游戏可以玩，所以扫雷游戏也算是当时是最常火爆的一个电脑游戏。 以下文章详细介绍扫雷游戏的实现。实现语言为C++。...
Java游戏项目之扫雷游戏
平平无奇の小透明的博客
02-27 1212
今天为大家带来的视频课程讲解了一个扫雷游戏的详细开发过程。只要90分钟就可以完成一个你自己亲手开发出来的Java扫雷游戏！
扫雷小游戏（可选择简单、一般、困难三种模式、可展开，可标记）
小赵小赵福星高照的博客
05-03 2148
扫雷 test.c - 扫雷游戏的测试 game.c - 游戏函数的实现 game.h - 游戏函数的声明 首先讲一讲我们整体的思路框架，我们设计这个游戏，让玩家想玩的时候可以一直玩，所以我们采用do…while循环语句，然后打印菜单，写一个菜单函数，让玩家进行选择，这里我们采用switch分支语句，当我们选择1时进入游戏，此时需要写一个游戏函数，选择0时退出游戏，选择其他时，告诉他选择错误，重新输入，我们发现当选择1和选择错误时我们需要循环继续，退出游戏是我们退出循环的时候，所以我们将while()里
扫雷游戏代码
m0_63248617的博客
05-05 923
扫雷游戏小程序的开发！ 游戏功能的介绍:如最上方的介绍,首先是难度选择界面,通过点击三个不同的选项来实现不同难度游戏的选择,点击简单后显示如下方图片所示,大小为9*9的格子,其内包含10个地雷,可以通过左键的单机实现格子的翻开,如果翻开的是空白格子,则表示其周围8个格子内没有雷,将会递归的打开此8个格子,直到无法再次打开为止,例如上方除3外的格子都是点击了空白格子实现的,而点开的格子如果是数字格子,则将直接..
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 505
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 287
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
C语言实现扫雷小游戏源码基础入门
本文档提供了一个用C语言编写的扫雷游戏源代码，旨在实现经典的扫雷游戏玩法。该程序利用了`graphics.h`库来处理图形界面，`stdlib.h`和`dos.h`库可能包含了与硬件交互的函数。以下是对关键部分的详细解读： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值