实训俄罗斯方块小游戏.docx

实训俄罗斯方块小游戏.docx

《实训俄罗斯方块小游戏.docx》由会员分享，可在线阅读，更多相关《实训俄罗斯方块小游戏.docx（20页珍藏版）》请在冰豆网上搜索。

实训俄罗斯方块小游戏

Tarena

[键入文档标题]

[键入文档副标题]

实训成绩

批阅教师

日期

实训报告

课程名称Java设计模式实训

专业班级

学号

学生姓名

指导教师

实训地点

2013年10月25日

《俄罗斯方块》需求说明书

目录

1引言2

2游戏功能需求2

2.1游戏界面需求2

2.2游戏控制需求2

2.3图形显示需求2

2.4规则说明需求2

3运行环境及系统性能的需求3

4接口需求3

5.主要功能代码3

6.功能截图9

1引言

对软件需求完全理解对于软件开发工作的成功是至关重要的，需求说明的任务是发现、规范的过程，有益于提高软件开发过程中的能见度，便于对软件开发过程中的控制与管理，便于采用工程方法开发软件，提高软件的质量，便于开发人员、维护人员、管理人员之间的交流、协作，并作为工作成果的原始依据，并且在向潜在用户传递软件功能、性能需求，使其能够判断该软件是否与自己的需求相关。

2游戏功能需求

本设计所开发的是基于Java的一个俄罗斯方块游戏，主要实现游戏的开始、暂停、退出等功能。

2.1游戏界面需求

良好的用户界面设计。

本游戏主要有两个模块，一是用于主游戏区的游戏画布，用来显示游戏时运动和落下去的方块，二是用于控制游戏的各种控件以及显现游戏信息的一些组件，这是一个面板。

2.2游戏控制需求

运行游戏时进入游戏界面，则在图形界面有随机出现的下落的方块，在下落过程中，可通过键盘方向键上（↑）、下（↓）、左（←）、右键（→）对该方块进行向上（变形）,向下（加速）、向左、向右移动。

2.3图形显示需求

一个用于摆放小型正方形的平面虚拟场地，其标准大小：

行宽为10，列高为20，以每个小正方形为单位。

随机给出不同的形状（分别以S、Z、L、J、I、O、T这7个字母的形状来命名）下落填充给定的区域。

2.4规则说明需求

（1）玩家操作有：

旋转方块，以格子为单位左右移动方块，让方块加速落下。

（2）方块移到区域最下方或是着地到其他方块上无法移动时，就会固定在该处，而新的方块出现在区域上方开始落下。

（3）当区域中某一列横向格子全部由方块填满，则该列会消失并成为玩家的得分。

同时删除的列数越多，得分指数上升。

（4）当固定的方块堆到区域最上方而无法消除层数时，则游戏结束。

（6）一般来说，游戏还会提示下一个要落下的方块，熟练的玩家会计算到下一个方块，评估要如何进行。

由于游戏能不断进行下去对商业用游戏不太理想，所以一般还会随着游戏的进行而加速提高难度。

（7）预先设置的随机发生器不断地输出单个方块到场地顶部

3运行环境及系统性能的需求

本游戏对运行环境及系统性能的需求如表3.1所示：

表3.1游戏对运行环境及系统性能需求分析表

操作系统

Windows98/me/2000/XP/2003

内存容量

64MB

显卡要求

8M

声卡要求

支持DirectX8.0声卡

交互工具

键盘/鼠标

CPU

奔腾133以上

光驱

8倍速以上

硬盘空间

400MB

显示器

VGA以上显示器

开发及运行软件

JDK1.5以上版本

4接口需求

本软件需求通过键盘进行操作，在Windows的操作系统下，利用键盘的上、下、左、右键对方块进行移动变形，要使用键盘的接口事件。

5.主要功能代码

Tetris.java

/**

*俄罗斯方块

*JPanel图形界面上能够显示的空白面板（空白矩形区域）

*扩展了面板为俄罗斯方块,扩展出分数和正在下落的

*方块,以及下一个下落的方块.

*/

publicclassTetrisextendsJPanel{

publicstaticfinalintROWS=20;

publicstaticfinalintCOLS=10;

/**格子的绘制大小*/

publicstaticfinalintCELL_SIZE=26;

privateintlines;

privateintscore;

/**墙*/

privateCell[][]wall=newCell[20][10];

/**正在下落的方块*/

privateTetrominotetromino;

/**下一个方块*/

privateTetrominonextOne;

/**

*在Tetris类中添加

*利用静态代码块静态加载图片资源

*将磁盘上图片文件,加载到内存中的图片对象

**/

publicstaticImagebackground;//背景图片对象

publicstaticImagegameOverImg;

publicstaticImageI;

publicstaticImageT;

publicstaticImageS;

publicstaticImageZ;

publicstaticImageL;

publicstaticImageJ;

publicstaticImageO;

static{

//Class类提供了一个方法getResource（）可以找到//package中的文件位置,利用这个位置可以读取//图片文件到内存中的对象

//tetris.png文件与Tetris.class在同一个包中

try{

Classcls=Tetris.class;

background=

ImageIO.read（cls.getResource（"tetris.p"）;

I=ImageIO.read（cls.getResource（"I.png"））;

T=ImageIO.read（cls.getResource（"T.png"））;

S=ImageIO.read（cls.getResource（"S.png"））;

Z=ImageIO.read（cls.getResource（"Z.png"））;

L=ImageIO.read（cls.getResource（"L.png"））;

J=ImageIO.read（cls.getResource（"J.png"））;

O=ImageIO.read（cls.getResource（"O.png"））;

gameOverImg=ImageIO.read（cls.getResource（"game-over.png"））;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

/*Tetris类中重写JPanel类的paint（）方法

*paint:

涂画,这个是JPanel的绘图方法

*重写了以后就修改了父类的paint方法,目的是实现

*自定义绘制.

*Graphics理解为一个绑定到当前面板的画笔.

**/

publicvoidpaint（Graphicsg）{

g.drawImage（background,0,0,null）;

g.translate（15,15）;//坐标系平移

paintWall（g）;

paintTetromino（g）;

paintNextOne（g）;

paintScore（g）;

g.translate（-15,-15）;

if（gameOver）{

g.drawImage（gameOverImg,0,0,null）;

}

}

publicstaticfinalint

FONT_COLOR=0x667799;

publicstaticfinalintFONT_SIZE=25;

/**绘制分数*/

privatevoidpaintScore（Graphicsg）{

intx=289;

inty=160;

g.setColor（newColor（FONT_COLOR））;

Fontfont=getFont（）;//获得系统字体（Font）

font=newFont（font.getName（）,Font.BOLD,FONT_SIZE）;

g.setFont（font）;

Stringstr="SCORE:

"+score;

g.drawString（str,x,y）;//绘制字符串

y+=56;

str="LINES:

"+lines;

g.drawString（str,x,y）;

y+=56;

str="[P]Pause";

if（pause）{

str="[C]Continue";

}

if（gameOver）{

str="[S]Start";

}

g.drawString（str,x,y）;

}

/**Tetris类上添加绘制正在下落方块的方法*/

privatevoidpaintTetromino（Graphicsg）{

if（tetromino==null）{//如果没有正在下落的方块,就不绘制

return;

}

Cell[]cells=tetromino.cells;

for（inti=0;i

Cellcell=cells[i];//cell代表每个小格子

intx=cell.getCol（）*CELL_SIZE;

inty=cell.getRow（）*CELL_SIZE;

//System.out.println（x+","+y+","+cell.getImage（））;

g.drawImage（cell.getImage（）,x-1,y-1,null）;

}

}

privatevoidpaintNextOne（Graphicsg）{

if（nextOne==null）{//如果没有正在下落的方块,就不绘制

return;

}

Cell[]cells=nextOne.cells;

for（inti=0;i

Cellcell=cells[i];//cell代表每个小格子

intx=（cell.getCol（）+10）*CELL_SIZE;

inty=（cell.getRow（）+1）*CELL_SIZE;

//System.out.println（x+","+y+","+cell.getImage（））;

g.drawImage（cell.getImage（）,x-1,y-1,null）;

}

}

/**绘制墙,就是将wall数据的内容绘制到界面*/

privatevoidpaintWall（Graphicsg）{

for（introw=0;row

//row=012...19=1

Cell[]line=wall[row];

for（intcol=0;col

//col=012...9=2

Cellcell=line[col];

//cell=wall[1][2]

intx=col*CELL_SIZE;

inty=row*CELL_SIZE;

if（cell==null）{

g.setColor（newColor（0））;//黑色

g.drawRect（x,y,CELL_SIZE,CELL_SIZE）;

}else{

g.drawImage（cell.getImage（）,x-1,y-1,null）;

}

}

}

}

/**Tetris类中添加方法action启动软件*/

publicvoidaction（）{

//wall[19][2]=newCell（19,2,T）;

//tetromino=Tetromino.randomOne（）;

//nextOne=Tetromino.randomOne（）;

startAction（）;

repaint（）;//JPanel中的重绘方法,会尽快调用paint

//键盘按键监听器对象

KeyListenerl=newKeyAdapter（）{

/**如果有按键按下完成时候（Pressed）就会执行*/

publicvoidkeyPressed（KeyEvente）{

//longtime=e.getWhen（）;

intkey=e.getKeyCode（）;

if（key==KeyEvent.VK_Q）{

System.exit（0）;//结束Java进程

}

if（gameOver）{

if（key==KeyEvent.VK_S）{

startAction（）;

repaint（）;

}

return;

}

if（pause）{

if（key==KeyEvent.VK_C）{

continueAction（）;

repaint（）;

}

return;//提前结束方法,不在处理后续事件

}

//System.out.println（key）;

switch（key）{

caseKeyEvent.VK_DOWN:

softDropAction（）;break;

caseKeyEvent.VK_RIGHT:

moveRightAction（）;

break;

case:

KeyEvent.VK_LEFT:

moveLeftAction（）;break;

caseKeyEvent.VK_UP:

rotateRightAction（）;break;

case:

KeyEvent.VK_SPACE:

hardDropAction（）;break;

caseKeyEvent.VK_P:

pauseAction（）;break;

}

repaint（）;

}

};//将键盘监听器对象添加到面板上.

this.addKeyListener（l）;//this代表当前俄罗斯方块面板

this.requestFocus（）;//Focus焦点

}

/**Tetris类的main方法*/

publicstaticvoidmain（String[]args）{

JFrameframe=newJFrame（"俄罗斯方块"）;//窗口框

Tetristetris=newTetris（）;//Tetris继承了JPanel

//Tetris也是面板,面板可以放到frame中显示

tetris.setBackground（newColor（0x00ff00））;

frame.add（tetris）;

frame.setSize（525,550）;//Size大小

frame.setUndecorated（true）;//去除窗口装饰

frame.setLocationRelativeTo（null）;//居中了!

//Default:

默认Close关闭Operation操作

//设置窗口的默认关闭操作是退出程序

frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）;

frame.setVisible（true）;//显示窗口

//frame在显示的时候会尽快的调用paint方法

tetris.action（）;//开始动作

}

/*在Tetris类中添加下落流程控制方法*/

publicvoidsoftDropAction（）{

//System.out.println（"CallsoftDrop"）;

if（canDrop（））{

//System.out.println（"candrop"）;

tetromino.softDrop（）;

}else{

//System.out.println（"cannotdrop"）;

landToWall（）;

destroyLines（）;

checkGameOver（）;

tetromino=nextOne;

nextOne=Tetromino.randomOne（）;

}}

publicvoidhardDropAction（）{

//当能够下落时候就下落一步

while（canDrop（））{

tetromino.softDrop（）;

}

landToWall（）;//着陆到墙上

destroyLines（）;//消行

checkGameOver（）;//检查游戏结束

tetromino=nextOne;//当前换成下一个

nextOne=Tetromino.randomOne（）;

}

/**检查当前方块是否能够继续下落

*1）方块是否到达底部

*2）方块下方墙上是否有格子.**/

privatebooleancanDrop（）{

Cell[]cells=tetromino.cells;

//检查当前方块是否到达底部

for（Cellcell:

cells）{

introw=cell.getRow（）;

if（row==ROWS-1）{

returnfalse;

}

}

for（Cellcell:

cells）{

introw=cell.getRow（）;

intcol=cell.getCol（）;

if（wall[row+1][col]!

=null）{

returnfalse;

}

}

returntrue;

}

/**着陆到墙*/

privatevoidlandToWall（）{

Cell[]cells=tetromino.cells;

for（Cellcell:

cells）{

introw=cell.getRow（）;

intcol=cell.getCol（）;

wall[row][col]=cell;

}}

privateint[]scoreTable={0,1,10,50,200};

privatevoiddestroyLines（）{

intlines=0;

for（introw=0;row

if（fullCells（row））{

deleteLine（row）;

lines++;

}

}

this.lines+=lines;

this.score+=scoreTable[lines];

}

privatevoiddeleteLine（introw）{

for（inti=row;i>=1;i--）{

//wall[i-1]->wall[i]

System.arraycopy（wall[i-1],0,wall[i],0,COLS）;

}

Arrays.fill（wall[0],null）;

}

privatebooleanfullCells（introw）{

Cell[]line=wall[row];

for（Cellcell:

line）{

if（cell==null）{

returnfalse;

}

}

returntrue;

}

privatevoidcheckGameOver（）{

if（wall[0][4]!

=null）{

gameOver=true;

timer.cancel（）;

repaint（）;

}}

/**在Tetris中添加方法*/

privatevoidmoveLeftAction（）{

tetromino.moveLeft（）;

if（outOfBounds（）||coincide（））{//出界检查方法

tetromino.moveRight（）;

}

}

privatevoidmoveRightAction（）{

tetromino.moveRight（）;

if（outOfBounds（）||coincide（））{//出界检查方法

tetromino.moveLeft（）;

}

}

privatebooleanoutOfBounds（）{

Cell[]cells=tetromino.cells;

for（Cellcell:

cells）{

intcol=cell.getCol（）;

introw=cell.getRow（）;

if（col<0||col>=COLS||row>=ROWS）{

returntrue;

}

}

returnfalse;

}

/**检查重合*/

privatebooleancoincide（）{

Cell[]cells=tetromino.cells;

for（Cellcell:

cells）{

introw=cell.getRow（）;

intcol=cell.getCol（）;

//System.out.println（row+","+col）;

if（row>=0&&row=0&&col

=null）{

returntrue;//在墙上找到格子,就发生重合

}

}

returnfalse;

}

privatevoidr