Java扫雷游戏代码

实现扫雷游戏控制台版

扫雷游戏

a、游戏的分析

在游戏中需要存在对象包含哪些。
格子对象（Grid）：
属性：内容（content）、状态（type）

b、工程架构

设计工程包结构
bean：存放实体类
core：游戏核心类（游戏操作）
test：扫雷玩的测试类

c、编写类

Grid（属性：content、type）
Core类–游戏核心类（雷区创建、显示雷区、布雷、踩雷）
Test类–测试类

d、核心类设计

1、格子对象创建方法定义
2、显示雷区方法定义
3、布雷方法定义
随机数工具：
Random r=new Random();
//获得整数类型的随机数
int x=r.nextInt(参数);参数表示随机值范围–>9
4、八个方向对象的方法定义
Point类：java中提供的坐标对象类 x,y
5、设置雷数的方法
通过遍历所有格子对象获取雷数的添加
6、踩雷
递归调用：在一个类的方法中实现当前方法调用自己的操作方式
1、通过传入一个坐标获取当前坐标位置的格子对象内容，判断内容的类型完成游戏操作
1、内容为雷 -->游戏结束
2、内容位数字 -->显示当前格子内容
3、内容为空白 -->通过当前位置实现空白的辐射操作（递归调用）

7、游戏胜利
1、方法的返回类型
2、test类中循环的结构（break）

扫雷实体类

package minersgame.bean;
/**
 * 格子实体类
 * @author 木叶
 *拥有格子的内容和状态属性
 */

public class Grid {
	//定义格子的私有属性
	private char content;
	private boolean type;
	public char getContent() {
		return content;
	}
	public void setContent(char content) {
		this.content = content;
	}
	public boolean isType() {
		return type;
	}
	public void setType(boolean type) {
		this.type = type;
	}

}

核心代码

package minersgame.core;

import java.awt.Point;
import java.util.Random;
import minersgame.bean.Grid;
/**
 * 游戏核心类
 * @author 木叶
 *包含游戏核心的功能：雷区制定、布雷实现、踩雷操作、显示雷区、获取方向、设置雷数、踩雷、显示胜利
 */
public class Core {

	//定义一个存放格子对象的二维数组完成雷区的保存
	Grid[][] grid=new Grid[9][9];
	//定义雷数的属性
	int count=10;
	int count2 = count;
	//定义一个属性获取当前状态
	public boolean state=true;
	//定义一个创建格子对象的方法，完成雷区中所有格子对象的创建
	public void createGrid() {
		//通过二维数组实现每个下标中添加格子对象
		for(int i=0;i<grid.length;i++) {
			for(int j=0;j<grid[i].length;j++) {
				//创建格子对象完成二维数组下标数据存放
				grid[i][j]=new Grid();
				//设置格子对象中的属性内容
				grid[i][j].setContent(' ');
				grid[i][j].setType(false);				
			}
		}
	}
	//定义一个布雷的方法
	public void setMines() {
		//定义随机数工具
		Random r=new Random();
		//通过随机方式获取随机坐标
		do {
			//获得x坐标
			int x=r.nextInt(9);
			//获得y坐标
			int y=r.nextInt(9);
			//判断当前随机位置的格子对象内容是否为雷，如果是雷就进入下次循环
			if(grid[x][y].getContent()!='*') {
			//通过x和y获得当前位置的格子对象
			grid[x][y].setContent('*');
			//实现数量自减
			count--;
			}	
			
		}while(count>0) ;
			
	}

	//定义显示雷区的方法
	public void show() {
		//通过遍历二维数组获得所有的格子个数
		System.out.println("xy 0 1 2 3 4 5 6 7 8");
		for(int i=0;i<grid.length;i++) {
			System.out.print(i+"  ");
			for(int j=0;j<grid[i].length;j++){
					//
				if(grid[i][j].isType() ){
					System.out.print(grid[i][j].getContent()+" ");		
				}else {
				System.out.print("■ ");
					}
				}
			System.out.println();
			}
		}		
//定义坐标获取的方法 --获得8个方向的坐标对象方法 
	public Point[] getPoint(int x,int y) {//超过一个以上的返回要用数组
		//定义一个坐标对象数组
		Point[] point=new Point[8];
		//左边
		point[0]=new Point(x-1,y);
		//左上
		point[1]=new Point(x-1,y-1);
		//上边
		point[2]=new Point(x,y-1);
		//右上
		point[3]=new Point(x+1,y-1);
		//右边
		point[4]=new Point(x+1,y);
		//右下
		point[5]=new Point(x+1,y+1);
		//下边
		point[6]=new Point(x,y+1);
		//左下
		point[7]=new Point(x-1,y+1);
		return point;
	}

//定义一个设置雷数的方法
	 public void setMinesNumber() {
		 //通过循环获得所有的格子对象
		 for(int i=0;i<grid.length;i++) {
			 for(int j=0;j<grid[i].length;j++) {
				 //定义一个统计类属的变量
				 int sum=0;
				 //判断当前格子对象内容是否为雷，如果是雷就进入下次获取，否则完成雷数统计
				 if(grid[i][j].getContent()!='*') {
					 //通过当前的坐标获取八个方向坐标对象
					 Point[] p=this.getPoint(i, j);
					 //通过坐标对象数组获取对应下标格子对象
					 for(int k=0;k<p.length;k++) {
						 //获得每个坐标对象
						 Point point=p[k];
						 //通过判断过去的8个方向位置是否越界
						 if(point.x>=0&&point.x<9&&point.y>=0&&point.y<9) {
							 //通过当前方向坐标获取位置上的格子对象
							if( grid[point.x][point.y].getContent()=='*') {
								sum++;//雷数自增
							}							 
						 }
					 }
					 //通过雷数统计变量确定是否有雷存在，如果有就将当前
					 //雷数添加到当前位置的格子对象中
					 if(sum>0) {
						 //在当前格子对象中添加雷数
						 grid[i][j].setContent((char)(48+sum));
					 }					 
				 }
			 }
		 }
	 }	 
	 //定义一个踩雷踩雷
	 public void stampMine(int x,int y) {
		 //开启当前格子状态为打开
		 grid[x][y].setType(true);
		 //判断当前坐标位置的格子内容是否为雷，如果是雷就结束否则就继续
		if(grid[x][y].getContent()!='*') {
			//判断当前格子对象是否为数字，如果为数字就不操作
			if(grid[x][y].getContent()==' ') {
				//获得当前格子周围8个方向的坐标对象
				Point[] p=this.getPoint(x, y);
				//循环遍历8个方向获得对应的格子对象
				for(int k=0;k<p.length;k++) {
					//分别获得的方向对象
					Point point=p[k];
					//判断是否越界
					if(point.x>=0&&point.x<9&&point.y>=0&&point.y<9) {
						/**
						 * 判断当前坐标对象对应的格子对象内容是否为空格，
						 * 如果是空格实现递归调用，如果是数字就开启当前格子
						 */
						if(grid[point.x][point.y].getContent()==' '&&grid[point.x][point.y].isType()==false) {
							//当前格子为空格的情况
							this.stampMine(point.x, point.y);
					}else {
						//当前格子为数字的情况
						grid[point.x][point.y].setType(true);
						}
					}
				}				
			}			
		}else {
			System.out.println("踩雷了，游戏结束！！！");
			 //修改游戏状态
			state=false;
			//显示出所有格子
			for(int i=0;i<grid.length;i++) {
				for(int j=0;j<grid[i].length;j++) {
					grid[i][j].setType(true);
				}
			}
		}		
	 } 
	 //定义一个游戏胜利的方法
	 public boolean getVictory(){
		 //为打开格子数
		 int number=0;
		 //使用循环得出格子总数
		 //使用循环得出打开格子总数
			 for(int i=0;i<grid.length;i++) {
				 for(int j=0;j<grid[i].length;j++) {
					if(!grid[i][j].isType()) {
						number++;
					}
				 }
			 }
			 //判断未打开鸽子数师傅等于雷数，是则预习成功，不是进入下次
		if(number==count2) {
			for(int i=0;i<grid.length;i++) {
				for(int j=0;j<grid[i].length;j++) {
					grid[i][j].setType(true);
				}
			}
			System.out.println("游戏胜利！！！扫雷成功！！！");
			return false;
		}else {
			return true;
		}
	 }	 
}

测试类

package minersgame.test;

import java.util.Scanner;

import minersgame.core.Core;

public class Test {
	public static void main(String[] args) {
		/*
		 * 实现游戏核心
		 */
		//获得游戏核心类对象
		Core c=new Core();
		c.createGrid();
		c.setMines();
		//显示
		c.show();
		//添加雷数
		c.setMinesNumber();
		Scanner scan=new Scanner(System.in);
		while(c.state){
			System.out.println("请输入X坐标：");
			int x=scan.nextInt();
			System.out.println("请输入Y坐标：");
			int y=scan.nextInt();
			//调用踩雷方法
			c.stampMine(x, y);
			//显示雷区方法
			c.show();
			//判断是否游戏胜利
			if(c.getVictory()) {	
			}else {
				c.show();
				break;
			}
		}
	}
}