扫雷游戏java

最新推荐文章于 2024-06-18 05:35:11 发布
最新推荐文章于 2024-06-18 05:35:11 发布
阅读量1.5k 收藏 16
点赞数 4
文章标签： 游戏 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A198237645_/article/details/125741578
版权

前言

        在我小的时候，电脑上有一款自带的游戏，每当打开电脑发现电脑没有网时，就会把这个游戏打开玩一玩，当时还不知道这个游戏是怎么玩的，而且这个游戏看起来非常单调无聊，所以直到现在通过网上查找资料才知道这个游戏的规则是什么😂😂，但我最近看着这个游戏的逻辑很简单，也想自己尝试着用代码敲一敲。

一、整体思路

        扫雷游戏第一步，需要先确定雷区的长度和宽度，再确定雷区中地雷的个数。可以通过一个二维数组来实现，将二维数组中的所有数全部赋值为零，通过for循环来产生地雷,在数组中如果是地雷则值为-1，如果该值已经为-1了，则继续循环。通过这一操作我们可以把地雷的分布图给做出来。

        再根据所得到的数组，通过对数组中的每个数进行访问，将每个数在二维数组中其他周围八个方格中有多少个地雷进行计数，如果该数组中的值为-1,则不需要进行操作,之后再把加起来的数填入该方格中,就能得到图像的内层图了。
        图像建立好之后我们需要进行踩雷，插旗子或取旗子，打问号或去问号，三个操作。

        踩雷有三种情况，一，如果踩到了方格在数组中的值为-1，则将所有的地雷全部显示出来，然后结束整个游戏。二，如果踩到了方格中的值为1，2，3，4，5，6，7，8就只需要显示该方格这个数就可以了。三，如果踩到的方格为0，则我们需要通过递归算法与计数这两步操作将其他周围方格为0全部显示出来并且它四周围绕的是不为0的方格。

        插旗子和打问号都是两个一样的操作，选择一个在数组中的坐标，同时，我们可以建立一个新的数组，来记录这些坐标，当我们下一次通过踩地雷操作来访问这些坐标时，则会提示该坐标无法进行踩雷操作，而取旗子和去问号与插旗子和打问号操作相反，整体思路大致是这样。

二、递归算法与计数

        这是我在做扫雷游戏这个过程中遇到的一个难点，就是将他周围的方格如果没有地雷全部都显示出来的操作。可以通过上下左右四个方向进行递归操作，从而来显示他周围所有的方格。但是递归算法如果不对他进行限制，那么，它将永无止境的进行下去，但是程序的递归深度总是有限的，所以，当程序运行到一定深度时，程序就会自动报错，因此，我们可以通过计数操作，来将这些已经递归过的方格排除掉，通过这样的操作就能够实现方格中空格和数的显示了。

        具体代码如下

 private void chuli1(int H1,int H2){
        StringBuilder JJ;
        for(int i=H1-1;i<=H1+1;i++)
        {
            for(int j=H2-1;j<=H2+1;j++)
            {
                if(i>=0&&i<this.L2&&j>=0&&j<this.L1&&A[i][j]==0&&zhongyao[i][j]==0)
                {
                    if(tuixiang[i].charAt(j)=='■')
                    {
                        qizi--;
                    }
                    if(tuixiang[i].charAt(j)=='?')
                    {
                        wenhao--;
                    }
                    JJ=new StringBuilder(tuixiang[i]);
                    JJ.setCharAt(j,' ');
                    tuixiang[i]=JJ.toString();
                    zhongyao[i][j]++;
                    chuli1(i,j);
                }
                else
                if(i>=0&&i<this.L2&&j>=0&&j<this.L1&&A[i][j]!=0&&A[i][j]!=-1&&zhongyao[i][j]==0)
                {
                    if(tuixiang[i].charAt(j)=='■')
                    {
                        qizi--;
                    }
                    if(tuixiang[i].charAt(j)=='?')
                    {
                        wenhao--;
                    }
                    JJ=new StringBuilder(tuixiang[i]);
                    JJ.setCharAt(j,(char)(A[i][j]+48));
                    zhongyao[i][j]++;
                    tuixiang[i]=JJ.toString();
                }
            }
        }
    }

三、代码的运行过程

 四、整体代码

        主程序代码：

import java.util.Scanner;
public class SaoLei {
    //雷区的长度
    private int L1;
    //雷区的宽度
    private int L2;
    //地雷的个数
    private int shuliang;
    //雷区图像1
    private int [][]A;
    //雷区图像2
    private String []tuixiang;
    //显示单元的个数
    private int geshu;
    //雷区图像3
    private int [][]zhongyao;
    //重要信息1
    private int JDK;
    //重要信息2
    private int JKK;
    //旗子的个数
    private int qizi;
    //问号的个数
    private int wenhao;
    //雷区长度和宽度的输入
    private void T1(){
        Scanner input=new Scanner(System.in);
        System.out.println("提示：雷区的长度和宽度的范围为[2,64],地雷的个数要小于雷区的总个数");
        System.out.print("请输入雷区的长度：");
        do {
            this.L1=input.nextInt();
            if(this.L1<=1)
            {
                System.out.println("输入雷区的长度不正确！");
                System.out.print("请重新输入:");
            }
            if(this.L1>64)
            {
                System.out.println("输入的雷区长度过大！");
                System.out.print("请重新输入：");
            }
        }while (this.L1<=1||this.L1>64);
        System.out.print("请输入雷区的宽度：");
        do {
            this.L2=input.nextInt();
            if(this.L2<=1)
            {
                System.out.println("输入雷区的宽度不正确！");
                System.out.print("请重新输入:");
            }
            if(this.L2>64)
            {
                System.out.println("输入的雷区宽度过大！");
                System.out.print("请重新输入：");
            }
        }while (this.L2<=1||this.L2>64);
        System.out.print("请输入地雷的个数：");
        do {
            this.shuliang=input.nextInt();
            if(this.shuliang<=0||this.shuliang>=this.L1*this.L2)
            {
                System.out.println("输入地雷的个数不正确！");
                System.out.print("请重新输入：");
            }
        }while (this.shuliang<=0||this.shuliang>=this.L1*this.L2);
        tuixiang=new String[this.L2];
        geshu=0;
        zhongyao=new int[L2][L1];
        qizi=0;
        wenhao=0;
        JDK=0;
        JKK=0;
    }
    //地雷的随机分布
    private void T2(){
        A=new int[this.L2][this.L1];
        int B,C;
        for(int i=0;i<shuliang;i++)
        {
            do {
                B=(int)(0+Math.random()*this.L2);
                C=(int)(0+Math.random()*this.L1);
                if(A[B][C]!=-1)
                {
                    A[B][C]=-1;
                    break;
                }
            }while (true);
        }
        T10();
    }
    //对图像进行初始化
    private void T3(){
        StringBuilder []J=new StringBuilder[this.L2];
        System.out.print("   ");
        for(int i=0;i<this.L1;i++)
        {
            if(i+1<10)
            {
                System.out.print(i+1);
                System.out.print("  ");
            }
            else
            {
                System.out.print(i+1+" ");
            }
        }
        System.out.println();
        System.out.print("  ▏-");
        for(int i=1;i<L1;i++)
        {
            System.out.print("-▏-");
        }
        System.out.print("-▏");
        for(int i=0;i<this.L2;i++)
        {
            J[i]=new StringBuilder("");
        }
        for(int i=0;i<this.L2;i++)
        {
            for(int j=0;j<this.L1;j++)
            {
                J[i].append("□");
            }
        }
        for(int i=0;i<this.L2;i++)
        {
            tuixiang[i]=J[i].toString();
        }
        System.out.println();
        for(int i=0;i<this.L2;i++)
        {
            if(i+1<10)
            {
                System.out.print(" "+(i+1)+"▏");
            }
            else
            {
                System.out.print(i+1+"▏");
            }
            for(int j=1;j<this.L1+1;j++)
            {
                System.out.print(tuixiang[i].charAt(j-1)+" ▏");
            }
            System.out.println();
        }
    }
    //玩家进行的操作
    private void T4(){
        Scanner input=new Scanner(System.in);
        int A,AA,AAA;
        int []B=new int[2];
        while (geshu!=L1*L2-shuliang)
        {
            System.out.print("                ");
            System.out.printf("当前玩家的得分为【%d】",geshu);
            System.out.println();
            System.out.println("请玩家选择如下操作");
            System.out.print("""
                1.插旗子或取旗子
                2.打问号或去除问号
                3.揭开（踩地雷◑﹏◐）
                """);
            System.out.print("请输入你的选择：");
            do {
                A=input.nextInt();
                if(A<1||A>3)
                {
                    System.out.println("输入错误！");
                    System.out.print("请重新输入：");
                }
            }while (A<1||A>3);
            if(A==1)
            {
                do {
                    System.out.println("请玩家选择如下操作");
                    System.out.print("""
                        1.插旗子
                        2.取旗子
                        3.退出
                        """);
                    do {
                        AA=input.nextInt();
                        if(AA<1||AA>3)
                        {
                            System.out.println("输入错误！");
                            System.out.print("请重新输入：");
                        }
                        if(AA==2&&qizi==0)
                        {
                            System.out.println("该雷区没有旗子可取！");
                            System.out.println("请重新输入：");
                        }
                        if(AA==1&&qizi==L1*L2)
                        {
                            System.out.println("该区域的旗子已经被插满了！");
                            System.out.println("请重新输入：");
                        }
                    }while ((AA<1||AA>3)||(AA==2&&qizi==0)||(AA==1&&qizi==L1*L2));
                    if(AA==1)
                    {
                        do{
                            T12(B);
                            if(tuixiang[B[0]-1].charAt(B[1]-1)==' ')
                            {
                                System.out.println("该区域没有地雷！");
                                System.out.print("请重新输入：");
                            }
                            if(tuixiang[B[0]-1].charAt(B[1]-1)=='■')
                            {
                                System.out.println("该区域已经插了旗子了！");
                            }
                            if(tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8')
                            {
                                System.out.println("该区域没有地雷！");
                                System.out.print("请重新输入：");
                            }
                        }while(tuixiang[B[0]-1].charAt(B[1]-1)==' '||tuixiang[B[0]-1].charAt(B[1]-1)=='■'||tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8');
                        T6(B);
                        T8();
                    }
                    else
                    if(AA==2)
                    {
                        do{
                            T12(B);
                            if(tuixiang[B[0]-1].charAt(B[1]-1)!='■')
                            {
                                System.out.println("该区域没有旗子🚩！");
                            }
                        }while(tuixiang[B[0]-1].charAt(B[1]-1)!='■');
                        T13(B);
                        T8();
                    }
                    else
                    {
                        T8();
                        break;
                    }
                }while(true);
            }
            else
            if(A==2)
            {
                do {
                    System.out.println("请玩家选择如下操作");
                    System.out.print("""
                        1.打问号
                        2.去问号
                        3.退出
                        """);
                    do {
                        AAA=input.nextInt();
                        if(AAA<1||AAA>3)
                        {
                            System.out.println("输入错误！");
                            System.out.print("请重新输入：");
                        }
                        if(AAA==2&&wenhao==0)
                        {
                            System.out.println("该雷区没有问号！");
                            System.out.println("请重新输入：");
                        }
                        if(AAA==1&&wenhao==L1*L2)
                        {
                            System.out.println("该区域的问号已经被填满了！");
                            System.out.println("请重新输入：");
                        }
                    }while ((AAA<1||AAA>3)||(AAA==2&&wenhao==0)||(AAA==1&&wenhao==L1*L2));
                    if(AAA==1)
                    {
                        do{
                            T12(B);
                            if(tuixiang[B[0]-1].charAt(B[1]-1)==' ')
                            {
                                System.out.println("该区域没有问号！");
                                System.out.print("请重新输入：");
                            }
                            if(tuixiang[B[0]-1].charAt(B[1]-1)=='?')
                            {
                                System.out.println("该区域已经有问号了！");
                            }
                            if(tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8')
                            {
                                System.out.println("该区域没有问号！");
                                System.out.print("请重新输入：");
                            }
                        }while(tuixiang[B[0]-1].charAt(B[1]-1)==' '||tuixiang[B[0]-1].charAt(B[1]-1)=='?'||tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8');
                        T7(B);
                        T8();
                    }
                    else
                    if(AAA==2)
                    {
                        do{
                            T16(B);
                            if(tuixiang[B[0]-1].charAt(B[1]-1)!='?')
                            {
                                System.out.println("该区域没有问号！");
                            }
                        }while(tuixiang[B[0]-1].charAt(B[1]-1)!='?');
                        T14(B);
                        T8();
                    }
                    else
                    {
                        T8();
                        break;
                    }
                }while (true);
            }
            else
            {
                T15(B);
                T9(B);
                T8();
                if(JKK==1)
                {
                    System.out.println("该区域被旗子占据！");
                    System.out.println("请将旗子去除在进行操作");
                }
                else
                if(JKK==2)
                {
                    System.out.println("该区域被问号占据！");
                    System.out.println("请将问号去除在进行操作");
                }
                JKK=0;
                if(JDK==0)
                {
                    T11();
                    if(geshu==L1*L2-shuliang)
                    {
                        System.out.println("恭喜玩家获得胜利^o^");
                    }
                    System.out.println("\n");
                }
                else
                {
                    System.out.println("游戏失败！");
                    System.out.println("(╯‵□′)╯炸弹！•••*～●");
                    break;
                }
            }
        }
    }
    //揭开输入
    private int[] T15(int []B){
        Scanner input=new Scanner(System.in);
        do {
            System.out.print("请输入雷区的坐标：");
            B[0]=input.nextInt();
            B[1]=input.nextInt();
            if((B[0]>this.L2||B[0]<=0)||(B[1]>this.L1||B[1]<=0))
            {
                System.out.println("输入的坐标错误！");
            }
            else
            if(tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8'||tuixiang[B[0]-1].charAt(B[1]-1)==' ')
            {
                System.out.println("该区域没有地雷！");
            }
        }while((B[0]>this.L2||B[0]<=0)||(B[1]>this.L1||B[1]<=0)||tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8'||tuixiang[B[0]-1].charAt(B[1]-1)==' ');
        return B;
    }
    //旗子坐标输入
    private int[] T12(int []B){
        Scanner input=new Scanner(System.in);
        do {
            System.out.print("请输入旗子的坐标：");
            B[0]=input.nextInt();
            B[1]=input.nextInt();
            if((B[0]>this.L2||B[0]<=0)||(B[1]>this.L1||B[1]<=0))
            {
                System.out.println("输入的坐标错误！");
            }
            else
            if(tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8'||tuixiang[B[0]-1].charAt(B[1]-1)==' ')
            {
                System.out.println("该区域没有地雷！");
            }
        }while((B[0]>this.L2||B[0]<=0)||(B[1]>this.L1||B[1]<=0)||tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8'||tuixiang[B[0]-1].charAt(B[1]-1)==' ');
        return B;
    }
    //问号坐标输入
    private int[] T16(int []B){
        Scanner input=new Scanner(System.in);
        do {
            System.out.print("请输入旗子的坐标：");
            B[0]=input.nextInt();
            B[1]=input.nextInt();
            if((B[0]>this.L2||B[0]<=0)||(B[1]>this.L1||B[1]<=0))
            {
                System.out.println("输入的坐标错误！");
            }
            else
            if(tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8'||tuixiang[B[0]-1].charAt(B[1]-1)==' ')
            {
                System.out.println("该区域没有地雷！");
            }
        }while((B[0]>this.L2||B[0]<=0)||(B[1]>this.L1||B[1]<=0)||tuixiang[B[0]-1].charAt(B[1]-1)=='1'||tuixiang[B[0]-1].charAt(B[1]-1)=='2'||tuixiang[B[0]-1].charAt(B[1]-1)=='3'||tuixiang[B[0]-1].charAt(B[1]-1)=='4'||tuixiang[B[0]-1].charAt(B[1]-1)=='5'||tuixiang[B[0]-1].charAt(B[1]-1)=='6'||tuixiang[B[0]-1].charAt(B[1]-1)=='7'||tuixiang[B[0]-1].charAt(B[1]-1)=='8'||tuixiang[B[0]-1].charAt(B[1]-1)==' ');
        return B;
    }
    //给雷区加旗帜
    private void T6(int []B){
        StringBuilder A;
        if(tuixiang[B[0]-1].charAt(B[1]-1)=='?')
        {
            wenhao--;
        }
        qizi++;
        A=new StringBuilder(tuixiang[B[0]-1]);
        A.setCharAt(B[1]-1,'■');
        tuixiang[B[0]-1]=A.toString();
    }
    //给雷区减旗帜
    private void T13(int []B){
        StringBuilder A;
        A=new StringBuilder(tuixiang[B[0]-1]);
        A.setCharAt(B[1]-1,'□');
        tuixiang[B[0]-1]=A.toString();
        qizi--;
    }
    //给图像加问号
    private void T7(int []B){
        StringBuilder A;
        if(tuixiang[B[0]-1].charAt(B[1]-1)=='■')
        {
            qizi--;
        }
        wenhao++;
        A=new StringBuilder(tuixiang[B[0]-1]);
        A.setCharAt(B[1]-1,'?');
        tuixiang[B[0]-1]=A.toString();
    }
    //给图像减问号
    private void T14(int []B){
        StringBuilder A;
        A=new StringBuilder(tuixiang[B[0]-1]);
        A.setCharAt(B[1]-1,'□');
        tuixiang[B[0]-1]=A.toString();
        wenhao--;
    }
    //揭开
    private void T9(int []B){
        StringBuilder JJ;
        int H1,H2;
        if(tuixiang[B[0]-1].charAt(B[1]-1)=='■')
        {
            JKK=1;
        }
        else
        if(tuixiang[B[0]-1].charAt(B[1]-1)=='?')
        {
            JKK=2;
        }
        else
        {
            if(A[B[0]-1][B[1]-1]==-1)
            {
                T15();
                JDK=1;
            }
            else
            {
                if(A[B[0]-1][B[1]-1]==0)
                {
                    H1=B[0]-1;
                    H2=B[1]-1;
                    chuli1(H1,H2);
                }
                else
                {
                    JJ=new StringBuilder(tuixiang[B[0]-1]);
                    JJ.setCharAt(B[1]-1,(char)(A[B[0]-1][B[1]-1]+48));
                    tuixiang[B[0]-1]=JJ.toString();
                    zhongyao[B[0]-1][B[1]-1]++;
                }
            }
        }
    }
    //处理1
    private void chuli1(int H1,int H2){
        StringBuilder JJ;
        for(int i=H1-1;i<=H1+1;i++)
        {
            for(int j=H2-1;j<=H2+1;j++)
            {
                if(i>=0&&i<this.L2&&j>=0&&j<this.L1&&A[i][j]==0&&zhongyao[i][j]==0)
                {
                    if(tuixiang[i].charAt(j)=='■')
                    {
                        qizi--;
                    }
                    if(tuixiang[i].charAt(j)=='?')
                    {
                        wenhao--;
                    }
                    JJ=new StringBuilder(tuixiang[i]);
                    JJ.setCharAt(j,' ');
                    tuixiang[i]=JJ.toString();
                    zhongyao[i][j]++;
                    chuli1(i,j);
                }
                else
                if(i>=0&&i<this.L2&&j>=0&&j<this.L1&&A[i][j]!=0&&A[i][j]!=-1&&zhongyao[i][j]==0)
                {
                    if(tuixiang[i].charAt(j)=='■')
                    {
                        qizi--;
                    }
                    if(tuixiang[i].charAt(j)=='?')
                    {
                        wenhao--;
                    }
                    JJ=new StringBuilder(tuixiang[i]);
                    JJ.setCharAt(j,(char)(A[i][j]+48));
                    zhongyao[i][j]++;
                    tuixiang[i]=JJ.toString();
                }
            }
        }
    }
    //图像显示
    private void T8(){
        System.out.print("   ");
        for(int i=0;i<this.L1;i++)
        {
            if(i+1<10)
            {
                System.out.print(i+1);
                System.out.print("  ");
            }
            else
            {
                System.out.print(i+1+" ");
            }
        }
        System.out.println();
        System.out.print("  ▏-");
        for(int i=1;i<L1;i++)
        {
            System.out.print("-▏-");
        }
        System.out.print("-▏");
        System.out.println();
        for(int i=0;i<this.L2;i++)
        {
            if(i+1<10)
            {
                System.out.print(" "+(i+1)+"▏");
            }
            else
            {
                System.out.print(i+1+"▏");
            }
            for(int j=1;j<this.L1+1;j++)
            {
                System.out.print(tuixiang[i].charAt(j-1)+" ▏");
            }
            System.out.println();
        }
    }
    //String图像处理
    private void T10(){
        int J=0;
        for(int i=0;i<this.L2;i++)
        {
            for(int j=0;j<this.L1;j++)
            {
                if(A[i][j]!=-1)
                {
                    if(i-1>=0&&j-1>=0)
                    {
                        if(A[i-1][j-1]==-1)
                        {
                            J++;
                        }
                    }
                    if(i-1>=0)
                    {
                        if(A[i-1][j]==-1)
                        {
                            J++;
                        }
                    }
                    if(i-1>=0&&j+1<this.L1)
                    {
                        if(A[i-1][j+1]==-1)
                        {
                            J++;
                        }
                    }
                    if(j-1>=0)
                    {
                        if(A[i][j-1]==-1)
                        {
                            J++;
                        }
                    }
                    if(j+1<this.L1)
                    {
                        if(A[i][j+1]==-1)
                        {
                            J++;
                        }
                    }
                    if(i+1<this.L2&&j-1>=0)
                    {
                        if(A[i+1][j-1]==-1)
                        {
                            J++;
                        }
                    }
                    if(i+1<this.L2)
                    {
                        if(A[i+1][j]==-1)
                        {
                            J++;
                        }
                    }
                    if(i+1<this.L2&&j+1<this.L1)
                    {
                        if(A[i+1][j+1]==-1)
                        {
                            J++;
                        }
                    }
                    A[i][j]=J;
                }
                J=0;
            }
        }
    }
    //geshu计数
    private void T11() {
        for(int i=0;i<L2;i++)
        {
            for(int j=0;j<L1;j++)
            {
                if(zhongyao[i][j]==1)
                {
                    geshu++;
                }
                if(zhongyao[i][j]!=0)
                {
                    zhongyao[i][j]++;
                }
            }
        }
    }
    //最后的显示
    private void T15(){
        StringBuilder II;
        for(int i=0;i<L2;i++)
        {
            II=new StringBuilder(tuixiang[i]);
            for(int j=0;j<L1;j++)
            {
                if(A[i][j]==-1)
                {
                    II.setCharAt(j,'●');
                }
            }
            tuixiang[i]=II.toString();
        }
    }
    //游戏说明
    private void youxishuoming(){
        System.out.println("""
               
                1.尽快找到雷区中的所有不是地雷的格子,而不许踩到地雷。
                2.点开的数字是几，则说明该数字旁边的8个位置中有几个雷。
                3.如果挖开的是地雷，则会输掉游戏。
                4.其中“■”代表旗子，“●”代表地雷。
                5.插旗子的作用是表示该区域有地雷。
                6.打问号的作用是表示该区域不确定是否有地雷。
                7.插旗子或打问号的区域无法进行揭开操作。
                """);
    }
    //总方法
    public void asd(){
        Scanner input=new Scanner(System.in);
        int A;
        do {
            System.out.print("""
                《扫雷游戏》
                1.开始游戏
                2.游戏说明
                3.退出游戏
                """);
            System.out.print("请输入你的选择：");
            do {
                A=input.nextInt();
                if(A!=1&&A!=2&&A!=3)
                {
                    System.out.println("输入错误！");
                    System.out.print("请重新输入：");
                }
            }while(A!=1&&A!=2&&A!=3);
            if(A==1)
            {
                T1();
                T2();
                T3();
                T4();
            }
            else
            if(A==2)
            {
                youxishuoming();
            }
            else
            {
                System.exit(0);
            }
        }while (true);
    }
}

测试代码

public class str1 {
    public static void main(String[] args) {
        SaoLei A=new SaoLei();
        A.asd();
    }
}
胡闹的
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java编程实现三种等级的扫雷游戏（完整版）
陈橘又青的博客
10-24 4万+
扫雷是一款大众类的益智小游戏。根据点击格子出现的数字找出所有非雷格子，同时避免踩雷，踩到一个雷即全盘皆输。这款游戏有着很长的历史，从扫雷被开发出来到现在进行了无数次的优化，这款游戏通过简单的玩法，加上一个好看的游戏界面，每一处的细节都体现了扫雷的魅力。本次项目设计是通过 Java语言编制一个扫雷游戏，Java语言是当今较为流行的网络编程语言，它具有面向对象、跨平台、分布应用等特点。
[计算机毕设]基于java的扫雷游戏系统设计与实现(项目报告+答辩PPT+源代码+数据库)
2301_78287784的博客
06-16 1071
Java扫雷游戏的设计与实现扫雷这款游戏有着很长的历史，从扫雷被开发出来到现在进行了无数次的优化，这款游戏变得越来越让人爱不释手了，简单的玩法在加上一个好看的游戏界面，每一处的细节都体现了扫雷的魅力。所以本次的项目设计我将开发一款扫雷游戏。本次项目设计是以JAVA语言作为开发环境，使用Eclipse设计并开发一个类似Windows扫雷的游戏，实现其基本功能。报告首先介绍了课题背景，其次进行了需求分析及可行性分析；然后设计游戏流程，介绍雷区中的雷怎么安放和产生雷的随机算法；
《游戏学习》 java经典纸牌类小游戏《斗地主》源码
最新发布
2401_85764574的博客
06-18 799
if(time[0].getText().equals(“不要”)&&time[2].getText().equals(“不要”))//a[0,1,2,3]分别表示重复1,2,3,4次的牌。} else if (name.length / 3
Java小游戏-扫雷
m0_54570435的博客
04-22 1563
我设计的扫雷有在难度的选择上有三种难度，分别是初、中、高级，这三种难度定义的雷数和雷区的尺寸是固定的，假如玩家想要自己定义扫雷的难度可以自己设置雷数和尺寸，只要打开“自定义”配置弹窗，在之后的弹框里按提示输入雷数和尺寸，行数最大为24，列数最大为30，如果玩家设置的雷数超过了范围（比如雷数大于格子的总数或小于零），系统会默认雷数为行数减一与列数减一的乘积。但是需要注意的是，如果操作不当会是系统无限循环调用，使得游戏崩溃，所以在编写代码时必须使用判断的语句来控制循环调用的结束，以停止该方法的递归调用。
java做的扫雷小游戏
jonny903的专栏
03-01 473
本次项目设计是通过 Java语言编制一个扫雷游戏，Java语言是当今较为流行的网络编程语言，它具有面向对象、跨平台、分布应用等特点。这次设计，还有利于加深对 Java课程的进一步了解，也可以巩固所学 Java语言基本知识，增进 Java语言编辑基本功，拓宽常用类库的应用。
基于Java Swing 实现的gui扫雷游戏(超详细每行代码都有注释)
zxwyhzy的博客
10-12 1622
超详细Java Swing实现扫雷游戏
扫雷游戏java版
09-10
用java写的项目，项目可以直接运行，请放心下载使用。
扫雷游戏java设计程序
11-07
扫雷游戏 这是扫雷游戏的整个实现思路（具体算法实现见源代码）： 1、网格类Field 这个类定义了网格的一些基本属性，如：横坐标、纵坐标、大小、样式和附近地雷值等，还有用以绘图的paintField方法和 一系列获取和...
扫雷游戏Java版
08-05
用java写的项目，源码都经测试过，真实可靠，欢迎大家下载学习。用java写的项目，源码都经测试过，真实可靠，欢迎大家下载学习。用java写的项目，源码都经测试过，真实可靠，欢迎大家下载学习。用java写的项目，源码...
saolei.rar_扫雷游戏 java
09-20
模仿Windows的扫雷，完成扫雷游戏的全部功能。 定制JButton，书写自己的按钮类。 理解重载，运用重载完成游戏初级、中高级游戏功能。 掌握ActionListener等事件的注册、添加、操作等。 使用Grahpics能够绘制一般的...
java实现简单窗口小游戏“扫雷”，java缓存面试题
m0_63174811的博客
03-28 822
按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。道路是曲折的，前途是光明的！事情了，不过是“人同此心，心同此理”的暂时而已。道路是曲折的，前途是光明的！
【java初体验:最简单的方法调用案例】手机类、手机属性、功能
xjj1128的博客
09-29 1388
创建phone类：具有属性type price color size 方法 sendMessage() call()测试类：在main方法中，通过Phone创建对象 分别给对象的属性赋值 华为P50 5999.00 石墨黑 6.8 分别调用person类的功能方法sendMessage() call()
JAVA版扫雷游戏，清晰易懂，注释多
weixin_45345143的博客
10-22 7877
带有计时功能，游戏成功的条件是用完所有的旗，并且放在雷上面。 超时，或者用完旗以后，有旗子没在正确的位置上，或者踩到地雷，都会导致游戏失败。
Java 扫雷小游戏开发
2301_79678119的博客
03-31 671
首先在地图上随机生成一定数量的炸弹，这样每个格子都有一个确定的数字代表周围的炸弹数。当鼠标左键点击一个格子时，加载出数字对应的图片；右键点击时，加载出旗子等图片，并在表示地图的二维数组上做上相应标记。当左键点到炸弹则输掉游戏，全部点开且旗子位置正确则胜利。
一文教你从零开始设计并实现一个Java扫雷游戏
m0_61549781的博客
03-19 1598
4.3.1鼠标事件我们通过点击鼠标左键或者鼠标右键来完成游戏，使用系统自带的MouseDown和MouseUp事件来响应玩家的操作。函数原型如下：组件名称：组件名称：这两个原型中的参数，Button参数值分别表示玩家用鼠标的左键或者右键进行点击的。其意义如下：1：左键 2：右键如果同时按两个按键，那么系统就会传回3，因为点左键是1，点右键是2，一起点就是两个值相加了。
Java课程设计——扫雷小游戏
YX-hueimie
03-04 1281
水一篇文章，献给需要过java课程设计的同学，这是我上学期学java的时候弄的，老师只给了3天时限，我主学语言也不是java，所以写的比较乱以及堆了很多⑩山代码，希望对你能有帮助！ import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt
Java中扫雷游戏的递归算法_扫雷之递归
weixin_33116629的博客
03-02 1023
前言假前端这货又来了。 上一篇文章，我们已经生成了一张空白的雷区地图，并且将一定数量的地雷随机分布在整个雷区中，最后将环境标识计算出来。生成了一个较完整的雷区地图。 换个样子嗯，地图有点丑，还不直观。 我们利用 vue 的 filters 对地图渲染做一些处理，用 emoji 来展示整张地图。判断逻辑是：格子的数字是 0 ，显示空格子的数字是 9 ，显示炸弹格子是其他数字，仍然显...
C语言——扫雷中的个人疑问（以及解答）+易错点+扫雷代码
zhang_si_hang的博客
11-11 2875
个人疑问： 1.这个扫雷里面计算周围几个雷的函数，return返回值能不能是个字符，为什么非要减去8个字符零变成数字啊？ 答：你要的是雷的个数，而数组中都是字符1，字符1减去字符0能得到实际的数字差值，每个位置都减一个，所以总共减去8个，你返回一个字符，外边怎么知道有多少个... 2.这个n返回字符以后直接赋给show[x][y]可以不? 答：不行，因为你内部需要减去8个字符0，而外部这里只是加了一个，如果内部不减的话，相当于多出来7个字符0的值......
扫雷游戏java 代码
06-17
扫雷游戏是一个经典的计算机游戏，使用Java编程实现的话，通常会涉及图形用户界面（GUI）、数组数据结构以及游戏逻辑。以下是一个简单的Java扫雷游戏的概述和关键部分： 1. **主界面**：使用Java Swing或JavaFX库创建一个窗口，包含一个二维网格（棋盘），每个格子代表一个区域，可能是地雷或者空地。 2. **初始化**：创建一个二维数组表示棋盘，其中的地雷数量和位置随机分布。同时，设置好游戏规则，如玩家可以在每一步揭示周围的地雷数量。 3. **事件监听器**：为棋盘上的每个格子添加鼠标点击事件监听器。当玩家点击一个格子时，检查是否踩到地雷，如果是，则游戏结束；否则，根据周围地雷的数量更新该格子显示的数字或切换状态（比如标记为已揭开）。 4. **胜利条件**：当玩家揭示完所有的非地雷区域且没有触发地雷时，游戏胜利。 5. **错误处理**：处理玩家操作失误（如点击地雷）的情况，给出相应的提示。 6. **循环和控制流程**：游戏主循环不断接收用户输入并更新棋盘，直到游戏结束。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

胡闹的

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值