J2ME期末课程设计疯狂扫雷.doc

课程设计报告

课程名称: 移动计算技术与应用
设计题目： 疯狂扫雷
院 系：
专 业： 　
班　　级：
学 号：
姓 名：
指导教师：
设计地点：
开课时间： 2011 至 2012 学年第 2 学期

常熟理工学院计算机科学与工程学院 制
学生姓名 手写签名 　成绩

评语：

指导教师（签名）
年 月 日

目录
1. 设计目的和任务 1
2. 开发环境 1
2.1硬件环境 1
2.2软件环境 1
3. 设计课题 1
3.1课题名称 1
3.2课题详细描述 1
3.3功能介绍 1
4. 相关技术及知识点 2
5. 技术与实现 2
5.1设计与实现描述 2
5.2程序功能实现截图 2
5.3程序实现 5
5.4测试应用程序 17
6. 总结 17
7. 参考资料 17

0

1. 设计目的和任务
众所周知扫雷游戏是附带在Windows操作系统中的小游戏，它通过点击格子并以出现的数字来判断附近地雷的数量，将全部地雷做上标记即可胜利。
我们一般接触的扫雷都是基于 PC 平台的，现在手机游戏那么普遍，手机版本的扫雷却一直没有得到流行，何不让这款休闲智力游戏在我们手中也能游戏呢？于是我们基于电脑版本的扫雷原理，编写了一款手机版本的扫雷，这就是我们这次项目的目标及任务，手机版本的扫雷玩起来更方便，随时随地都可以扫雷，使得这款游戏不只局限于电脑，这也方便了各位爱好扫雷的玩家们。

2. 开发环境
2.1硬件环境
◆装有Windows XP的计算机一台
◆设备齐全的实验室
◆用于测试的手机一台
2.2软件环境
◆操作系统：Windows XP 或 Windows 7
◆开发平台：NetBeansIDE6.5.1或以上版本
◆辅助软件：WirelessToolkit2.5.2

3. 设计课题
3.1课题名称
疯狂扫雷（手机版扫雷游戏）
3.2课题详细描述
具体的设计思路参照于微软公司所出的 PC 版本的扫雷，只是我们实现的语言采用了手机易于识别的 Java。
手机版本的扫雷功能与微软公司所出的电脑版本很相似，这也方便了玩家，不需要在操作习惯上做太大的改变，因此适应性很强。
基本功能：点击格子并以出现的数字来判断附近地雷的数量，将全部地雷做上标记即可胜利。其次还可以进行闯关竞技。最后还可以实现雷区的随机分布功能。
3.3功能介绍
游戏设计为关卡式，每过一关并进入下一关，游戏的难度也会随之加大。
点击格子得到数字来判断周围的地雷数，找到所有雷并做上标记（小旗）即胜利（雷区以红色填充格表示）。
点击数字“1”标记地雷，数字“3”显示游戏状况，数字“5”确定，点击“0”重新开始游戏或进入下一关。

4. 相关技术及知识点
◆调用paint函数绘制游戏方格
◆MIDlet：运用MIDlet应用程序实现入口，控制屏幕和命令
◆数组：根据游戏逻辑，产生一个10行10列的二维数组，并与界面的100个位置相对应
◆游戏API：运用游戏API中的GameCanvas类扩展MIDPCanvas类，提供游戏的基本接口

5. 技术与实现
5.1设计与实现描述
在设计功能时，我们分别用了相应的函数来实现。
首先扫雷游戏要有方格，因此必须有一个绘图函数绘出相应的屏幕方格，我们利用了 paint 函数来实现，在程序中，系统会自动调用该绘图函数,并传入绘图设备 g ,通过该设备,我们可以绘制如直线,矩形快,字符串,图片等。
在完成绘图后，我们需要让系统随机产生雷区，这就需要编写一个“布雷”函数，利用 rand 随机 mine_num 个雷的位置，并利用相应的语句实现 X、Y 数值的随机确定。
布完雷后，便要编写函数，如何识别键盘的输入指令，于是我们编写了 keyPressed ，通过该函数，系统可以自动调用该函数,当有键盘事件发生为按下某键,参数 key 为按下键的键值，并通过函数里面具体的语句来判断该数值的具体含义，以便作相应的处理。
在具体的扫雷过程中，利用 boolean isWinGame 来进行红旗的标记。标记完后，应该在屏幕上显示出相应位置雷区数量的提示，这就用到了 showMap，该函数是一个递归函数,把当前位置设置成显示,并判断当前位置雷数是否为 0 个，如果是 0 个雷,那么它周围的 8 个格子都要再作一次 showMap。
如果闯关成功，就会进入到下一关。如果不成功，就会重新开始。这些功能都通过 rePlay 函数来实现。闯关成功，rePlay 就会自动增加雷区数量，加大游戏难度。
5.2程序功能实现截图

(1) 运行程序，按数字“3”看到的界面（图5.2.1）：

图5.2.1
(2) 游戏失败界面（图5.2.2）：

图5.2.2
(3) 游戏胜利，进入下一关（图5.2.3）：

图5.2.3
(4) 游戏第二关（每闯一关，界面变大，难度加大图5.2.4）：

图5.2.4

5.3程序实现
程序包括两个类：Game.java 和 Minesweeper.java

Game.java：
import java.util.Random; //得到随机函数
import javax.microedition.lcdui.*; //写界面所需要的包

class Game extends Canvas
{
//游戏状态
private static final int STATEPLAY = 0; //游戏中
private static final int STATELOST = 1; //游戏失败
private static final int STATEWIN = 2; //游戏胜利
//格子状态
private static final int MINE_OFF_SHOW = 0;//不显示格子中雷的数

private static final int MINE_ON_SHOW = 1; //显示格子中雷的数
private static final int MINE_ASK = 9; //设置问号
private static final int MINE_FLAG = 10; //设置红旗
private static final int MINE_GUESS_ERR = 11; //显示猜错了
//定义键值
private static final int KEY_UP = 1; //上
private static final int KEY_DOWN = 2; //下
private static final int KEY_LEFT = 3; //左
private static final int KEY_RIGHT = 4; //右
private static final int KEY_FIRE = 5; //中间确认键

public static Random rand; //随机数对象

private int map_x = 10; //雷区 行数
private int map_y = 10; //雷区 列数
private int map_w = 20; //一个雷区的格子的宽度
private int map_h = 20; //一个雷区的格子的高度
private int key_x = map_x / 2; //游戏初始时光标所在雷区的格子位置
private int key_y = map_y / 2; //游戏初始时光标所在雷区的格子位置
private int mine_num= 10; //雷区的雷数不应该大于雷区的格子总数
private int flagNum = mine_num; //剩余红旗数
private int rightNum= 0; //猜对的雷数
private int[][] map; //雷区的地图数组 >=10 为雷, <10 为周围的雷数, 0 为附近没有雷
private int[][] map_show; //雷区的地图数组是否显示该位置的雷数//1 显示//0 不显示//9 问号//10 红旗
private int gameState = STATEPLAY; //游戏状态
private int s_width = 0; //屏幕尺寸 宽

private int s_height = 0; //屏幕尺寸 高
private int addMine = 0; //重新开始后雷数增加的个数
private boolean isShowInfo = false; //是否显示游戏信息
private String strFlagNum = "红旗数";
private String strMineNum = "正确率";
private String[] gameInfo = {"游戏中","游戏失败 按 0 重新开始","游戏胜利 按 0 进入下一关"};
private Font font = Font.getFont( Font.FACE_SYSTEM,Font.STYLE_BOLD, Font.SIZE_LARGE );

Game()
{
setFullScreenMode(true); //设置游戏为全屏幕模式,该函数只能在支持 midp2.0 的手机上使用

s_width = getWidth(); //得到屏幕尺寸
s_height= getHeight(); //得到屏幕尺寸

rePlay( 0 ); //游戏初始化//重新游戏
}

/** *//**
* 系统自动调用该绘图函数,并传入绘图设备g,通过该设备,我们可以绘制如直线,矩形快,字符串,图片等,
*/
public void paint(Graphics g)
{
g.setClip(0,0,s_width,s_height); //设置参数描述的区域为操作区
g.setColor(0x000000); //设置颜色为黑色,三个 16 进制数表示,RGB,如 0x00ff00为绿色
g.fillRect(0, 0, s_width, s_height); //绘制一个实心矩形区域
g.setColor(0xFFFFFF); //设置颜色为白色

//绘制雷区
for( int i=0; i<=map_y; i++ ) // | | //画 map_y+1 条竖线
{
g.drawLine(i*map_w, 0, i*map_w, map_h*map_x);
}
for( int i=0; i<=map_x; i++ ) // === //画 map_x+1 条横线
{
g.drawLine(0, i*map_h, map_y*map_w, i*map_h);
}

for( int i=0; i<map_x; i++ )
{
for( int j=0; j<map_y; j++ )
{
if( map_show[i][j] == MINE_ON_SHOW ) //遍历地图数组看该位置的雷数是否应该显示
{
if( map[i][j]==0 ) //周围没有雷
{
g.setColor(0x666666);
g.fillRect(j*map_h+2,i*map_w+2,map_w-3,map_h-3);
}
else if(map[i][j]<10) //显示周围的雷数
{
g.setColor(0x666666);
g.fillRect(j*map_h+2,i*map_w+2, map_w-3,map_h-3);
g.setColor(0x00ff00);
g.drawString(""+map[i][j], j*map_h+8,i*map_w+4, g.LEFT|g.TOP); //显示该位置的雷数

}
else //踩到雷了
{
g.setColor(0xff0000);
g.fillRect(j*map_h+2, i*map_w+2, map_w-3,map_h-3);
}
else if( map_show[i][j] == MINE_FLAG ) //显示红旗
{
paintFlag( g, j, i );
}
else if( map_show[i][j] == MINE_ASK ) //显示问号
{
paintInterrogation( g, j, i );
}
else if( map_show[i][j] == MINE_GUESS_ERR )//显示猜错
{
g.setColor(0x666666);

g.fillRect(j*map_h+2, i*map_w+2,map_w-3,map_h-3);
paintGuessErr( g, j, i );
}
}
}

g.setColor(0xFF0000); //设置颜色红
g.drawRect(key_x*map_w+1, key_y*map_h+1, map_w-2, map_h-2);
//绘制一个空心矩形框//为光标
g.drawRect(key_x*map_w+2, key_y*map_h+2, map_w-4, map_h-4);
//绘制一个空心矩形框//为光标

if( isShowInfo | gameState != STATEPLAY ) //如果游戏结束
{
g.setFont( font );
g.drawString( strFlagNum+":"+flagNum, 20, s_height-60,
g.LEFT|g.TOP ); //显示剩余旗数
g.drawString( strMineNum+":"+rightNum +"/"+ mine_num,
20, s_height-45, g.LEFT|g.TOP ); //显示正确率 猜对雷数/总雷数
g.drawString( gameInfo[ gameState ], 20, s_height-30,
g.LEFT|g.TOP ); //显示游戏状态
}
}
/** *//**
*系统自动调用该函数,当有键盘事件发生为按下某键,参数key为按下键的键值
*/
public void keyPressed(int key)
{
key = Math.abs(key);
System.out.println("key="+key);
//上下左右 为移动光标事件,只需要调整光标位置即可,但需要做边界判断
switch( key )
{
case KEY_NUM2:
case KEY_UP:
if( gameState != STATEPLAY ) //如果游戏没结束//结束了就不做确认键操作了
break;
else
{
key_y--;
if( key_y<0 )
key_y = map_x-1;
}
break;

case KEY_NUM8:
case KEY_DOWN:
if( gameState != STATEPLAY ) //如果游戏没结束//结束了就不做确认键操作了
break;
else
{
key_y++;
key_y %=map_x;
}
break;

case KEY_NUM4:
case KEY_LEFT:
if( gameState != STATEPLAY ) //如果游戏没结束//结束了就不做确认键操作了
break;
else
{
key_x--;
if( key_x<0 )

key_x = map_y-1;
}
break;

case KEY_NUM6:
case KEY_RIGHT:
if( gameState != STATEPLAY ) //如果游戏没结束//结束了就不做确认键操作了
break;
else
{
key_x++;
key_x %=map_y;
}
break;

case KEY_FIRE:
case KEY_NUM5:
if( gameState == STATEPLAY ) //如果游戏没结束就不做确认键操作了
{
if( map_show[key_y][key_x] == MINE_FLAG )
break;
showMap( key_y, key_x ); //显示该位置的雷数
if( map[key_y][key_x] >=10 )//如果雷数>=10为雷,
{
isWinGame();
addMine = 0;
isShowInfo = true;
gameState = STATELOST; //游戏失败

}
}
break;

case KEY_NUM1: //设置红旗//问号//取消
if( gameState != STATEPLAY ) //如果游戏没结束//结束了就不做确认键操作了
break;
switch( map_show[key_y][key_x] )
{
case MINE_OFF_SHOW:
map_show[key_y][key_x] = MINE_FLAG;
flagNum--;
if( flagNum == 0 )
{
if( isWinGame() )
{
addMine = 5;
isShowInfo = true;
gameState = STATEWIN;
}
else
{
addMine = 0;
isShowInfo = true;
gameState = STATELOST;
}
}
break;

case MINE_FLAG:
flagNum++;
map_show[key_y][key_x] = MINE_ASK;
break;
case MINE_ASK:
map_show[key_y][key_x] = MINE_OFF_SHOW;
break;
}
break;
case KEY_NUM3: //是否显示游戏信息
isShowInfo = !isShowInfo;
break;
case KEY_NUM0: //当按下 数字键 0
rePlay( addMine ); //重新开始游戏
break;
}
/** *//**
*重新执行 paint()但该函数是立刻返回,也就是说他不会等待paint()执行完毕就返回了,
*如果需要 paint()执行完毕才返回,可以使用serviceRepaints(),也可以两个都是用
* repaint()应该在 serviceRepaints()之前.
*/
this.repaint(); //本例为键盘事件驱动,刷新函数也就是每次按下键盘才作
}

boolean isWinGame()

{
boolean isWin = true;
for( int i=0; i<map_x; i++ )
{
for( int j=0; j<map_y; j++ )
{
if( map_show[i][j] == MINE_FLAG ) //显示红旗
{
if( map[i][j] < 10 ) //地雷猜错了
{
map_show[i][j] = MINE_GUESS_ERR;
isWin = false;
}
else
{
rightNum ++;
}
}
}
}
return isWin; //全部红旗都插对了才能通关
}

void paintFlag( Graphics g, int key_x, int key_y )
{
int x = key_x*map_h+9;
int y = key_y*map_w+5;
g.setColor( 0xFF0000 );

g.drawLine( x , y , x , y+11 ); // |
g.drawLine( x-2, y+11, x+3, y+11 ); // -
g.drawLine( x , y , x+5, y+ 2 ); // >
g.drawLine( x+5, y+2 , x , y+ 4 ); // >
x += 1;
y += 1;
g.drawLine( x , y , x , y+11 ); // |
g.drawLine( x-5, y+11, x+4, y+11 ); // -
g.drawLine( x , y , x+5, y+ 2 ); // >
g.drawLine( x+5, y+2 , x , y+ 4 ); // >
}

void paintInterrogation( Graphics g, int key_x, int key_y )
{
int x = key_x*map_h+8;
int y = key_y*map_w+5;
g.setColor( 0xFF0000 );
g.drawString("?", x, y, g.LEFT|g.TOP); // ?
}

void paintGuessErr( Graphics g, int key_x, int key_y )
{
int x = key_x*map_h+8;
int y = key_y*map_w+5;
g.setColor( 0xFF0000 );
g.drawString("x", x, y, g.LEFT|g.TOP); // x
}

//该函数是一个递归函数,把当前位置设置成显示,并判断当前位置雷数
//如果是 0 个雷,那么它周围的 8 个格子都要再作一次 showMap
void showMap(int x, int y)
{
if( map_show[x][y] == MINE_FLAG )
return;
if( map_show[x][y] == MINE_ON_SHOW )
return;
else
map_show[x][y] = MINE_ON_SHOW;

if( map[x][y] == 0 )
{
if( x-1 >= 0 )
{
showMap( x-1, y );
if( y-1 >= 0) showMap( x-1, y-1 );
if( y+1 < map_y) showMap( x-1, y+1 );
}
if( y-1 >= 0) showMap( x , y-1 );
if( y+1 < map_y) showMap( x , y+1 );
if( x+1 < map_x )
{
showMap( x+1, y );
if( y-1 >= 0) showMap( x+1, y-1 );
if( y+1 < map_y) showMap( x+1, y+1 );
}
}
}

//重新开始游戏
public void r