/**
* @(#)Block.java
*该类用于创建Block对象，将其放到游戏区的每个格子里面，里面存放着该“格子”的一些属性：
* *************************
* ——1. String name -->是雷时，存入“雷”
* 属性 ——|-2. boolean boo -->是雷时，为true，否则为false。我称为“雷性”
* ——3. int number -->用于存储周边，九回宫格内周边八个方格内的雷数
* *************************
* ——1. void setName(String name) -->设置name
* |-2. void setNumber(int i) -->设置周边雷数
* 方法 ——|-3. int getNumber() -->得到周边雷数
* |-4. String getName() -->得到name
* |-5. boolean isMine() -->判断雷性
* ——6. void setIsMine(boolean boo) -->设置雷性
* ***********************
*
* @author 宋俊林
* @version 1.00 /4/25
*/
public class Block {
String name; //是雷时，存入“雷”
int number; //用于存储周边，九回宫格内周边八个方格内的雷数
boolean boo = false; //是雷时，为true，否则为false。我称为“雷性”
//设置name
public void setName(String name){
this.name = name;
}
//得到name
public String getName(){
return name;
}
//设置周边雷数
public void setNumber(int i){
this.number = i;
}
//得到周边雷数
public int getNumber(){
return number;
}
//设置雷性
public void setIsMine(boolean boo){
this.boo = boo;
}
//判断雷性
public boolean isMine(){
return boo;
}
}
/**
* @(#)MineFrame.java
*
* 该类是主窗体类，该类将以Block类的实例和BlockView类的实例作为成员，并负责二者之间的交互
*
* @author 宋俊林
* @version 1.00 /4/25
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MineFrame extends JFrame implements ActionListener{
JButton reStart;
Block block[][];
BlockView blockView[][];
LayMines lay;
int row=10,colum=12,mineCount=22;
int colorSwitch = 0;
JPanel pCenter,pNorth;
public MineFrame() {
reStart = new JButton("重新开始"); //做一个restart按钮
pCenter = new JPanel(); //中心主游戏区面板
pNorth = new JPanel(); //上部控制面板
pNorth.setBackground(Color.gray);
block = new Block[row][colum];
for(int i=0;i
for(int j=0;j
block[i][j]=new Block();
}
}
lay = new LayMines();
lay.layMinesForBlock(block,mineCount);
blockView = new BlockView[row][colum];
pCenter.setLayout(new GridLayout(row,colum));
for(int i=0;i
for(int j=0;j
blockView[i][j] = new BlockView(); //实例化一个blockView数组
blockView[i][j].setName(block[i][j].getName());
pCenter.add(blockView[i][j]);
blockView[i][j].getBlockCover().addActionListener(this); //给每一小格添加监听器
}
}
reStart.addActionListener(this); //给reStart添加监听器
pNorth.add(reStart); //将组件添加到窗口中
add(pNorth,BorderLayout.NORTH);
add(pCenter,BorderLayout.CENTER);
setSize(200,232);
setVisible(true);
//pack();
addWindowListener(new WindowAdapter(){ //添加窗口关闭事件的监听
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
validate();
}
public void actionPerformed(ActionEvent e){
JButton source = (JButton)e.getSource();
if(source!=reStart){
int m = -1,n=-1;
for(int i=0;i
for(int j=0;j
//判断事件对象，如果是格子[i][j]，则翻开,并将该对象存储到[m][n]
if(source==blockView[i][j].getBlockCover()){
m = i;
n = j;
break;
}
}
}
if(block[m][n].isMine()){
for(int i=0;i
for(int j=0;j
//如果[m][n]是雷，则游戏停止，移除所有格子的事件监听，按钮动作失效
//同时翻开所有是雷的按钮
blockView[i][j].getBlockCover().removeActionListener(this);
if(block[i][j].isMine())
blockView[i][j].seeBlockName();
}
}
}else{
if(block[m][n].getNumber()>0)
blockView[m][n].seeBlockName();
else{
//如果所采处雷数为0，则翻开周边
if(block[m][n].getNumber()==0){
for(int k=Math.max(m-1,0);k<=Math.min(m+1,row-1);k++){
for(int t=Math.max(n-1,0);t<=Math.min(n+1,colum-1);t++){
blockView[k][t].seeBlockName();
}
}
}
}
}
}
if(source==reStart){
for(int i=0;i
for(int j=0;j
block[i][j].setIsMine(false);
}
}
lay.layMinesForBlock(block,mineCount);
for(int i=0;i
for(int j=0;j
blockView[i][j].setName(block[i][j].getName());
blockView[i][j].seeBlockCover();
blockView[i][j].getBlockCover().addActionListener(this);
}
}
}
}
public static void main(String args[]){
new MineFrame();
}
}
/**
* @(#)BlockView.java
*
* 该类是为Block类创建视图，注意，要实现扫雷效果，则需要将试图分为两层，表层是按钮，底层是标签，
* 所以要用到CardLayout布局。另外，想在一个个格子里面放多各元件，得考虑用Panel容器，所以该视图类
* 继承自Panel
*
* @author 宋俊林
* @version 1.00 /4/25
*/
import java.awt.*;
import javax.swing.*;
public class BlockView extends JPanel {
JLabel blockName;
JButton blockCover;
CardLayout card;
BlockView(){ //在构造器中初始化各属性
card = new CardLayout();
setLayout(card);
blockName = new JLabel();
blockCover = new JButton();
add("cover",blockCover); //将blockCover添加到层面板
add("name",blockName); //将blockname添加到层面板
}
public void setName(String name){ //设置blockName的text
blockName.setText(name);
}
public String getName(){ //得到blockName的text
return blockName.getText();
}
public void seeBlockName(){ //显示blockName
card.show(this,"name");
validate();
}
public void seeBlockCover(){ //显示blockCover
card.show(this,"cover");
validate();
}
public JButton getBlockCover(){ //得到blockCover
return blockCover;
}
}
/**
* @(#)LayMines.java
*
* * 我感觉这个类时扫雷的算法核心，只要搞定这个类，其他都不是问题，该类只有一个主方法
* *---> void layMinesForBlock(Block block[][],int mineCount)
* * 其中:
* * 1.参数block[][]数组存放着整个游戏区的方格的block对象，一个方格对应一个
* * 同时，用二维数组也为实现扫描周边的九回宫格统计雷数提供支持
* * 2.参数mineCount来存放你想生成的类的个数
* * 3.这里还用到了集合LinkedList，来存储block[][]中的所有block对象，
*
*
* @author 宋俊林
* @version 1.00 /4/25
*/
import java.util.LinkedList;
public class LayMines {
public void layMinesForBlock(Block block[][],int mineCount){
int row = block.length;
int column = block[0].length;
LinkedList list = new LinkedList(); //创建list(用到范型)
for(int i=0;i
for(int j=0;j
list.add(block[i][j]); //利用循环，将block都加到列表list里
}
}
while(mineCount>0){
int size = list.size();
int randomIndex=(int)(Math.random()*size); //生产随机数，将这些随机数对应的block对象的属性设为是雷的属性
Block b = list.get(randomIndex); //根据随机数，取对应的block对象
b.setName("雷"); //将name设为‘雷’
b.setIsMine(true); //将雷性设为true
list.remove(randomIndex); //将list中是雷的节点删除，以免设置雷重复
mineCount--;
}
for(int i=0;i
for(int j=0;j
if(!block[i][j].isMine()){ //如果block[i][j]不是雷是执行下面的统计操作，扫描周边
int mineNumber = 0;
/**
* 我感觉下面是核心的核心，扫描周围的八个(但是在游戏区的边界上，可能不足八个格子)，所以这里扫描是就得处理边界问题
*这里为防止越界，用的是比较大小取值的方法，很精妙“Math.max(j-1,0)”;下面是扫描图：
* [———————————————————————————]
* [(i-1,j-1)|(i-1,j)|(i-1,j+1)]
* [———————————————————————————]
* [ (i,j-1) | (i,j) | (i，j+1)]
* [———————————————————————————]
* [(i+1,j-1)|(i+i,j)|(i+1,j+1)]
* [———————————————————————————]
*/
for(int k=Math.max(i-1,0);k<=Math.min(i+1,row-1);k++){
for(int t=Math.max(j-1,0);t<=Math.min(j+1,column-1);t++){
if(block[k][t].isMine()){
mineNumber++;
}
}
}
block[i][j].setName(""+mineNumber); //将name存为number后边会进行显示
block[i][j].setNumber(mineNumber); //将周边的雷数存入number中
}
}
}
}
}
