简单俄罗斯方块游戏设计课程设计论文

课程小论文
教学院计算机学院
课程名称Java应用技术
题目简单俄罗斯方块游戏设计
专业
班级
学号
姓名
指导教师
毕业设计（论文）原创性声明和使用授权说明
原创性声明
本人郑重承诺：所呈交的毕业设计（论文），是我个人在指导教师的指导下进行的研究工作及取得的成果。

尽我所知，除文中特别加以标注和致谢的地方外，不包含其他人或组织已经发表或公布过的研究成果，也不包含我为获得及其它教育机构的学位或学历而使用过的材料。

对本研究提供过帮助和做出过贡献的个人或集体，均已在文中作了明确的说明并表示了谢意。

作者签名：日期：
指导教师签名：日期：
使用授权说明
本人完全了解大学关于收集、保存、使用毕业设计（论文）的规定，即：按照学校要求提交毕业设计（论文）的印刷本和电子版本；学校有权保存毕业设计（论文）的印刷本和电子版，并提供目录检索与阅览服务；学校可以采用影印、缩印、数字化或其它复制手段保存论文；在不以赢利为目的前提下，学校可以公布论文的部分或全部内容。

作者签名：日期：
学位论文原创性声明
本人郑重声明：所呈交的论文是本人在导师的指导下独立进行研究所取得的研究成果。

除了文中特别加以标注引用的内容外，本论文不包含任何其他个人或集体已经发表或撰写的成果作品。

对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式标明。

本人完全意识到本声明的法律后果由本人承担。

作者签名：日期：年月日
学位论文版权使用授权书
本学位论文作者完全了解学校有关保留、使用学位论文的规定，同意学校保留并向国家有关部门或机构送交论文的复印件和电子版，允许论文被查阅和借阅。

本人授权大学可以将本学位论文的全部或部分内容编入有关数据库进行检索，可以采用影印、缩印或扫描等复制手段保存和汇编本学位论文。

涉密论文按学校规定处理。

作者签名：日期：年月日
导师签名：日期：年月日
注意事项
1.设计（论文）的内容包括：
1）封面（按教务处制定的标准封面格式制作）
2）原创性声明
3）中文摘要（300字左右）、关键词
4）外文摘要、关键词
5）目次页（附件不统一编入）
6）论文主体部分：引言（或绪论）、正文、结论
7）参考文献
8）致谢
9）附录（对论文支持必要时）
2.论文字数要求：理工类设计（论文）正文字数不少于1万字（不包括图纸、程序清单等），文科类论文正文字数不少于1.2万字。

3.附件包括：任务书、开题报告、外文译文、译文原文（复印件）。

4.文字、图表要求：
1）文字通顺，语言流畅，书写字迹工整，打印字体及大小符合要求，无错别字，不准请他人代写
2）工程设计类题目的图纸，要求部分用尺规绘制，部分用计算机绘制，所有图纸应符合国家技术标准规范。

图表整洁，布局合理，文字注释必须使用工程字书写，不准用徒手画
3）毕业论文须用A4单面打印，论文50页以上的双面打印
4）图表应绘制于无格子的页面上
5）软件工程类课题应有程序清单，并提供电子文档
5.装订顺序
1）设计（论文）
2）附件：按照任务书、开题报告、外文译文、译文原文（复印件）次序装订
教研室（或答辩小组）及教学系意见
目录
一问题分析和任务定义 (3)
1．问题分析 (3)
2．课程报告所用软件 (3)
3．设计目的 (4)
3．任务定义 (4)
二逻辑设计 (5)
1．游戏流程图 (5)
2．游戏功能叙述 (5)
三详细设计 (7)
1．游戏界面设计 (7)
2．游戏控制设计................................................................................... 错误！未定义书签。

3.主类的实现......................................................................................... 错误！未定义书签。

4．基本类设计....................................................................................... 错误！未定义书签。

四程序编码.. (11)
程序调试与测试 (19)
六结果分析 (20)
本次课程设计让我学习到了很多，也体会到编写程序的不易，但我绝不会放弃。

希望能在这条路上，走的更远。

附录（程序代码） (22)
参考文献 (36)
一问题分析和任务定义
1．问题分析
游戏这个名称一直就存在于每个人的日常生活中,如猜拳游戏、猜谜游戏、大地游戏、球类游戏等,林林总总,不胜枚举,甚至于有些流行歌曲把人生也比喻为游戏,好比“一场游戏一场梦”。

因此,游戏对于现代人的成长历程,绝对是一个不可或缺的重要角色。

“游戏”,最简单的定义,就是一种供人们娱乐休闲的快乐元素。

从更专业的角度形容, “游戏”是具有特定行为模式、规则条件、身心娱乐及输赢的一种行为表现。

而俄罗斯方块是一款风靡全球的电视游戏机和掌上游戏机游戏，它曾经造成的轰动与经济价值可以说是游戏史上的一件大事。

这款游戏最是由苏联的游戏Alex Pajitnow制作的，它看似简单却变化无穷，令人着迷，相信大多数人都还记得为它的规则简单，容易上手，且游戏过程变化无穷。

而在“联众俄罗斯方块”中，游戏人既能感受到游戏中的乐趣，也能提供一个展现自己高超技艺的场所，究其历史，俄罗斯方块最早还是出现在PC机上，无数人进入游戏编程的世界都是从编写俄罗斯方块游戏开始的，因为这是检验一个人对开发语言，环境和基本数据结构知识熟练程度的便捷途径。

于此同时俄罗斯方块是一款我们大家小时候经常玩的游戏，非常的具有趣味，代表了我们的一段童年时光。

此次，我所选的课题就是简单俄罗斯方块的设计，用来追忆它陪我度过的一段童年时光。

2．课程报告所用软件
Eclipse最初是由IBM公司开发的替代商业软件Visual Age for Java的下一代IDE开发环境，2001年11月贡献给开源社区，现在它由非营利软件供应商联盟Eclipse基金会（Eclipse Foundation）管理。

2003年，Eclipse 3.0选择OSGi服务平台规范为运行时架构。

2007年6月，稳定版3.3发布；2008年6月发布代号为Ganymede的3.4版；2009年6月发布代号为Galileo的3.5版；2010年6月发布代号为Helios的3.6版；2011年6月发布代号为Indigo的3.7版；2012年6月发布代号为Juno的4.2版；2013年6月发布代号为Kepler的4.3版；2014年6月发布代号为Luna的4.4版；2015年6月项目发布代号为Mars
的4.5版。

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。

就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。

幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

Eclipse 可以作为Java 集成开发环境（IDE），但 Eclipse 的目标却不仅限于此。

Eclipse 还包括插件开发环境（Plug-in Development Environment，PDE），它允许他们构建与 Eclipse 环境无缝集成的工具。

Exclipse的平等和一致性并不仅限于 Java 开发工具。

尽管 Eclipse 是使用Java语言开发的，但它的用途并不限于 Java 语言；例如，支持诸如C/C++、COBOL、PHP、Android等编程语言的插件已经可用，或预计将会推出。

Eclipse 框架还可用来作为与软件开发无关的其他应用程序类型的基础，比如内容管理系统。

3．设计目的
综合运用在校期间所学理论知识和技能，设计开发俄罗斯方块，使自己熟悉应用系统的开发过程，培养独立思考能力，检验学习效果和动手能力，提高工程实践能力，为将来实际工作打下坚实的基础。

3．任务定义
通过研究分析俄罗斯方块所具备的能力及实现的方法、确定主体结构。

利用现阶段我所能达到的能力，以最简洁、最容易的办法，边开发边测试边修改，实现一个初级游戏软件。

开发过程遵循软件工程规范，可采用结构化或面向对象分析设计方法。

主要实现windows的GUI程序开发，对游戏中的图形图像进行键盘控制。

游戏者可以通过上下左右键来对游戏进行操作。

二逻辑设计
1．游戏流程图
图1
2．游戏功能叙述
1、当程序运行时，用户进入主界面，进行游戏。

游戏具有开始游戏，暂停游戏，提高或降低级数以及退出游戏的功能。

2、游戏开始，游戏区域上方不断地出现预定义形状的下坠物件。

3、下坠物件可以通过旋转改变其显示形态，并且不断地往下坠，直到它接触到游戏区域底部或其他之前已经垒叠起的下坠物件。

当一个下坠物件到达底部
后，其位置则确定下来并占有该空间的位置区域。

4、当游戏区域的某一行被下坠物件完全填充，则消除该行的所有下坠物，垒在其上面的物件将掉下代替该行空间。

5、游戏的结束是以下坠物件的顶部到达游戏区域的顶部作为判断依据，表示装满溢出。

并且在某一瞬间，下一个方块的形态在游戏区域的右上方有预先提示，同时每抵消一行空间积分自增。

三详细设计
1．界面设计
首先进行游戏区域的设计，一般为12*22或者10*22，在这里我设计的是12*22。

主要的游戏功能都在游戏区域显示，比如方块的随机选择，画布的背景显示等等。

其次是系统功能显示区域，这里显示了当前所玩游戏的等级，右方可以选择不同的游戏级别，一共有1、2、3、4、5五种游戏级别的选择；下方是游戏画布背景的选择，一共有浅绿、浅黄、黑色三种背景颜色的选择；最下方有开始游戏、暂停游戏、结束游戏和退出游戏四中功能选项。

2.游戏功能设计
在无人操作时，游戏开始后会随机产生一个下坠物，先显示在界面右上角的显示区域，然后转到游戏区域，右上角又随机产生一个新的下坠物，当该下坠物下落到底后，新的下坠物再次进入游戏区域，如此循环，直到游戏结束／暂停，这就是游戏的正常工作。

上述过程是在无人操作时游戏自动运行的，当用户进行一定的操作交互的时候，运行程序可以根据用户的操作指示进行当前下坠物的控制。

而这些操作都是响应相关的功能键而执行的，所以这里可以把它看成一种“中断”的操作。

在中断过程中，可以通过键盘包括按某些键进行操作。

为了便于用户操作，用户可以自主选择操作键，但他们的作用不变。

但还是应该设置默认键来方便操作。

例如：光标向上键，光标向下键，光标向左键，光标向右键。

（1）按光标向上键
此事件产生下坠物旋转操作，下坠物并非任何情况都能旋转，如果旋转后与小方格矩阵显示的下坠物有冲突或超出边界时，均不能发生旋转。

因此首先要判断是否有足够的空间进行旋转，然后选择是否旋转。

（2）按光标向下键
此事件产生下坠物加速下落操作，如果下坠物已经到达游戏区域底部或者已经有其他方块遮挡，则下坠物停止下降。

（3）按光标向左键
此事件产生下落下坠物左移操作。

首先要判断此下坠物是否能够发生左移，当越界或被其他显示下坠物阻挡时，则不能左移。

（4）按光标向右键
此事件产生下落下坠物右移操作。

首先要判断此下坠物是否能够发生右移，当越界或被其他显示下坠物阻挡时，则不能右移。

3.方块的定义
在此，我用type类来进行方块的类型定义，一共定义了长条、直角左、直角右、直角中、正方形五中方块类型
private final int types[][][]={ //游戏方块{{-1,0},{0,0},{1,0},{2,0}}, //长条
{{0,-1},{0,0},{0,1},{0,2}},
{{-1,0},{0,0},{1,0},{1,1}}, //直角（右）
{{0,1},{0,0},{0,-1},{1,-1}},
{{1,0},{0,0},{-1,0},{-1,-1}},
{{0,-1},{0,0},{0,1},{-1,1}},
{{-1,0},{0,0},{0,1},{1,0}}, //直角（中）
{{0,1},{0,0},{1,0},{0,-1}},
{{1,0},{0,0},{0,-1},{-1,0}},
{{0,-1},{0,0},{-1,0},{0,1}},
{{-1,1},{-1,0},{0,0},{1,0}}, //直接（左）
{{1,1},{0,1},{0,0},{0,-1}},
{{1,-1},{1,0},{0,0},{-1,0}},
{{-1,-1},{0,-1},{0,0},{0,1}},
{{0,-1},{0,0},{1,0},{1,1}},
{{-1,0},{0,0},{0,-1},{1,-1}},
{{0,1},{0,0},{1,0},{1,-1}},
{{1,0},{0,0},{0,-1},{-1,-1}},
{{0,0},{0,1},{1,0},{1,1}} //正方形
};
4.方块的随机出现
我用makenewblock()函数来实现方块的随机出现
public void makenewblock() //随机出现方块
{
aa=(int)(Math.random()*100%7+1);
ic=aa*10+1;
switch(aa)
{
case 1:
block_type=0;
break;
block_type=2;
break;
case 3:
block_type=6;
break;
case 4:
block_type=10;
break;
case 5:
block_type=14;
break;
case 6:
block_type=16;
break;
case 7:
block_type=18;
break;
}
block_x=1;
block_y=sp_width/2;
for(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
block_box[i][1]=block_y+types[block_type][i][0];
}
}
5.方块的旋转
public void turnright()
{
int[][] block_box_temp=new int[4][2];
int ic_temp=ic;
int block_type_temp=block_type;
int id=ic%10;
for(int i=0;i<4;i++)
{
block_box_temp[i][0]=block_box[i][0];
block_box_temp[i][1]=block_box[i][1];
}
if(aa==7)
return;
else if(aa==1||aa==5||aa==6)
{
if(id==2)
block_type--;
ic--;
}
else
{
block_type++;
ic++;
}
}
else
{
if(id==4)
{
block_type=block_type-3;
ic=ic-3;
}
else
{
block_type++;
ic++;
}
}
for(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
block_box[i][1]=block_y+types[block_type][i][0];
}
if(Iscanmoveto()==false)
{
ic=ic_temp;
block_type=block_type_temp;
for(int i=0;i<4;i++)
{
block_box[i][0]=block_box_temp[i][0];
block_box[i][1]=block_box_temp[i][1];
}
}
}
四程序编码
程序主要代码
public class BlockGame
{
private int aa=0;
private int ic=0;
private final int sp_width=10; //游戏界面宽格private final int sp_height=20; //游戏界面高格private final int types[][][]={ //游戏方块{{-1,0},{0,0},{1,0},{2,0}}, //长条
{{0,-1},{0,0},{0,1},{0,2}},
{{-1,0},{0,0},{1,0},{1,1}}, //直角（右）
{{0,1},{0,0},{0,-1},{1,-1}},
{{1,0},{0,0},{-1,0},{-1,-1}},
{{0,-1},{0,0},{0,1},{-1,1}},
{{-1,0},{0,0},{0,1},{1,0}}, //直角（中）
{{0,1},{0,0},{1,0},{0,-1}},
{{1,0},{0,0},{0,-1},{-1,0}},
{{0,-1},{0,0},{-1,0},{0,1}},
{{-1,1},{-1,0},{0,0},{1,0}}, //直接（左）
{{1,1},{0,1},{0,0},{0,-1}},
{{1,-1},{1,0},{0,0},{-1,0}},
{{-1,-1},{0,-1},{0,0},{0,1}},
{{0,-1},{0,0},{1,0},{1,1}},
{{-1,0},{0,0},{0,-1},{1,-1}},
{{0,1},{0,0},{1,0},{1,-1}},
{{1,0},{0,0},{0,-1},{-1,-1}},
{{0,0},{0,1},{1,0},{1,1}} //正方形
};
private int[][] block_box=new int[4][2]; //四个方块坐标private int[][] block_box_tt=new int[4][2];
private int block_x=0,block_y=0; //游戏方块在游戏界面中的坐标
private int block_type=0; //方块类别
private int[][] game_space=new int[20][10]; //空间数据private int movetype=0;
private int scroe=0;
private int speed=5;
public BlockGame()
{
c learspace();
m akenewblock();
}
public void clearspace() //初始化空间数据 {
f or(int i=0;i<sp_height;i++)
for(int j=0;j<sp_width;j++)
game_space[i][j]=0;
}
public void makenewblock() //随机出现方块 {
aa=(int)(Math.random()*100%7+1);
ic=aa*10+1;
s witch(aa)
{
c ase 1:
block_type=0;
break;
c ase 2:
block_type=2;
break;
c ase 3:
block_type=6;
break;
c ase 4:
block_type=10;
break;
c ase 5:
block_type=14;
break;
c ase 6:
block_type=16;
break;
c ase 7:
block_type=18;
break;
}
b lock_x=1;
b lock_y=sp_width/2;
f or(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
block_box[i][1]=block_y+types[block_type][i][0];
}
}
public void movedown()
{
b lock_x++;
f or(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
}
m ovetype=1;
}
public void moveleft()
{
b lock_y--;
f or(int i=0;i<4;i++)
{
block_box[i][1]=block_y+types[block_type][i][0];
}
m ovetype=2;
}
public void moveright()
{
b lock_y++;
f or(int i=0;i<4;i++)
{
block_box[i][1]=block_y+types[block_type][i][0];
}
m ovetype=3;
}
public void turnright()
{
i nt[][] block_box_temp=new int[4][2];
i nt ic_temp=ic;
i nt block_type_temp=block_type;
i nt id=ic%10;
f or(int i=0;i<4;i++)
{
block_box_temp[i][0]=block_box[i][0];
block_box_temp[i][1]=block_box[i][1];
}
i f(aa==7)
return;
e lse if(aa==1||aa==5||aa==6)
{
if(id==2)
{
block_type--;
ic--;
}
else
{
block_type++;
ic++;
}
}
e lse
{
if(id==4)
{
block_type=block_type-3;
ic=ic-3;
}
else
{
block_type++;
ic++;
}
}
f or(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
block_box[i][1]=block_y+types[block_type][i][0];
}
i f(Iscanmoveto()==false)
{
ic=ic_temp;
block_type=block_type_temp;
for(int i=0;i<4;i++)
{
block_box[i][0]=block_box_temp[i][0];
block_box[i][1]=block_box_temp[i][1];
}
}
}
public void moveback()
{
i f(movetype==1)
{
block_x--;
for(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
}
}
e lse if(movetype==2)
{
block_y++;
for(int m=0;m<4;m++)
{
block_box[m][1]=block_y+types[block_type][m][0];
}
}
e lse if(movetype==3)
{
block_y--;
for(int n=0;n<4;n++)
{
block_box[n][1]=block_y+types[block_type][n][0];
}
}
}
public boolean Iscanmoveto()
{
f or(int i=0;i<4;i++)
{
if(block_box[i][0]<0||block_box[i][0]>19)
{
moveback();
return false;
}
else if(block_box[i][1]<0||block_box[i][1]>9)
{
moveback();
return false;
}
else if(game_space[block_box[i][0]][block_box[i][1]]==1)
{
moveback();
return false;
}
}
r eturn true;
}
public boolean Ishitbottom()
{
f or(int i=0;i<4;i++)
{
if(block_box[i][0]+1>19)
{
f or(int m=0;m<4;m++)
{
game_space[block_box[m][0]][block_box[m][1]]=1;
block_box_tt[m][0]=block_box[m][0];
block_box_tt[m][1]=block_box[m][1];
block_box[m][0]=0;
block_box[m][1]=0;
}
r eturn true;
}
}
f or(int i=0;i<4;i++)
{
if(game_space[block_box[i][0]+1][block_box[i][1]]==1) {
f or(int m=0;m<4;m++)
{
game_space[block_box[m][0]][block_box[m][1]]=1;
block_box_tt[m][0]=block_box[m][0];
block_box_tt[m][1]=block_box[m][1];
block_box[m][0]=0;
block_box[m][1]=0;
}
r eturn true;
}
}
r eturn false;
}
public void CheckAndCutLine()
{
i nt
a[]={block_box_tt[0][0],block_box_tt[1][0],block_box_tt[2][0],block_box_tt[
3][0]};
i nt b[]={30,30,30,30};
i nt temp=0;
i nt temp1=0;
i nt count=0;
i nt ss=0;
f or(int i=0;i<4;i++)
{
for(int j=0;j<10;j++)
{
if(game_space[a[i]][j]==1)
temp++;
}
if(temp==10)
{
for(int m=0;m<4;m++)
if(b[m]==a[i])
{
break;
}
else
ss++;
if(ss==4)
{
b[count]=a[i];
count++;
}
}
temp=0;
ss=0;
}
f or(int i=0;i<3;i++)
for(int j=i+1;j<4;j++)
{
if(b[i]>b[j])
{
temp1=b[i];
b[i]=b[j];
b[j]=temp1;
}
}
f or(int n=0;n<4;n++)
{
if(b[n]==30)
break;
else
{
for(int aa=b[n]-1;aa>=0;aa--)
{
for(int bb=0;bb<10;bb++)
{
game_space[aa+1][bb]=game_space[aa][bb];
}
}
for(int cc=0;cc<10;cc++)
game_space[0][cc]=0;
}
}
}
public boolean IsGameOver()
{
b oolean flag=false;
f or(int i=0;i<sp_width;i++)
{
if(game_space[0][i]==1)
{
flag=true;
break;
}
}
r eturn flag;
}
public void sure()
{
f or(int i=0;i<4;i++)
game_space[block_box[i][0]][block_box[i][1]]=1; }
public void notsure()
{
f or(int i=0;i<4;i++)
game_space[block_box[i][0]][block_box[i][1]]=0; }
public boolean judge(int i,int j) {
i f(game_space[i][j]==1)
return true;
e lse
return false;
}
}
五程序调试与测试
图2
我运行程序后，进行了一小段时间的游戏，发现基本游戏功能都能实现，但是还是有一部分的功能未能成功，但是程序设计已经基本成功。

六结果分析
通过短短的几个周的时间，我从一个对JAVA编程懵懂的学生到现在可以试着用JAVA进行简单程序的设计与编写，虽然在实验过程中，我遇到了许多的困难，特别是还不太适应面向对象的编程风格和思想，看待问题时总是想到用什么结构来实现该功能，而没有将问题看成一个封装的整体来考虑，所以在这次课程设计中我接触、体验了面向对象设计，使得思维在向面过程向面向对象过度。

因为这次的论文，使我对JAVA面向对象的编程有了深一步的了解，因为这次的课程设计，使我在今后的工作和学习中，都有了很到的启发。

但是我设计的程序还是有很大的问题，相对于现在身份成熟的俄罗斯方块游戏编程，我设计的程序还有很大的欠缺，很多功能没有实现，比如积分功能，但是在我不屑的努力下，我还是基本完成了实验，并最终运行成功。

附录（程序代码）
public class BlockGame
{
private int aa=0;
private int ic=0;
private final int sp_width=10; //游戏界面宽格private final int sp_height=20; //游戏界面高格private final int types[][][]={ //游戏方块{{-1,0},{0,0},{1,0},{2,0}}, //长条
{{0,-1},{0,0},{0,1},{0,2}},
{{-1,0},{0,0},{1,0},{1,1}}, //直角（右）
{{0,1},{0,0},{0,-1},{1,-1}},
{{1,0},{0,0},{-1,0},{-1,-1}},
{{0,-1},{0,0},{0,1},{-1,1}},
{{-1,0},{0,0},{0,1},{1,0}}, //直角（中）
{{0,1},{0,0},{1,0},{0,-1}},
{{1,0},{0,0},{0,-1},{-1,0}},
{{0,-1},{0,0},{-1,0},{0,1}},
{{-1,1},{-1,0},{0,0},{1,0}}, //直接（左）
{{1,1},{0,1},{0,0},{0,-1}},
{{1,-1},{1,0},{0,0},{-1,0}},
{{-1,-1},{0,-1},{0,0},{0,1}},
{{0,-1},{0,0},{1,0},{1,1}},
{{-1,0},{0,0},{0,-1},{1,-1}},
{{0,1},{0,0},{1,0},{1,-1}},
{{1,0},{0,0},{0,-1},{-1,-1}},
{{0,0},{0,1},{1,0},{1,1}} //正方形
};
private int[][] block_box=new int[4][2]; //四个方块坐标private int[][] block_box_tt=new int[4][2];
private int block_x=0,block_y=0; //游戏方块在游戏界面中的坐标
private int block_type=0; //方块类别
private int[][] game_space=new int[20][10]; //空间数据private int movetype=0;
private int scroe=0;
private int speed=5;
public BlockGame()
{
c learspace();
m akenewblock();
public void clearspace() //初始化空间数据 {
f or(int i=0;i<sp_height;i++)
for(int j=0;j<sp_width;j++)
game_space[i][j]=0;
}
public void makenewblock() //随机出现方块 {
aa=(int)(Math.random()*100%7+1);
ic=aa*10+1;
s witch(aa)
{
c ase 1:
block_type=0;
break;
c ase 2:
block_type=2;
break;
c ase 3:
block_type=6;
break;
c ase 4:
block_type=10;
break;
c ase 5:
block_type=14;
break;
c ase 6:
block_type=16;
break;
c ase 7:
block_type=18;
break;
}
b lock_x=1;
b lock_y=sp_width/2;
f or(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
block_box[i][1]=block_y+types[block_type][i][0];
}
public void movedown()
{
b lock_x++;
f or(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
}
m ovetype=1;
}
public void moveleft()
{
b lock_y--;
f or(int i=0;i<4;i++)
{
block_box[i][1]=block_y+types[block_type][i][0];
}
m ovetype=2;
}
public void moveright()
{
b lock_y++;
f or(int i=0;i<4;i++)
{
block_box[i][1]=block_y+types[block_type][i][0];
}
m ovetype=3;
}
public void turnright()
{
i nt[][] block_box_temp=new int[4][2];
i nt ic_temp=ic;
i nt block_type_temp=block_type;
i nt id=ic%10;
f or(int i=0;i<4;i++)
{
block_box_temp[i][0]=block_box[i][0];
block_box_temp[i][1]=block_box[i][1];
}
i f(aa==7)
return;
e lse if(aa==1||aa==5||aa==6)
{
if(id==2)
{
block_type--;
ic--;
}
else
{
block_type++;
ic++;
}
}
e lse
{
if(id==4)
{
block_type=block_type-3;
ic=ic-3;
}
else
{
block_type++;
ic++;
}
}
f or(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
block_box[i][1]=block_y+types[block_type][i][0];
}
i f(Iscanmoveto()==false)
{
ic=ic_temp;
block_type=block_type_temp;
for(int i=0;i<4;i++)
{
block_box[i][0]=block_box_temp[i][0];
block_box[i][1]=block_box_temp[i][1];
}
}
}
public void moveback()
{
i f(movetype==1)
{
block_x--;
for(int i=0;i<4;i++)
{
block_box[i][0]=block_x-types[block_type][i][1];
}
}
e lse if(movetype==2)
{
block_y++;
for(int m=0;m<4;m++)
{
block_box[m][1]=block_y+types[block_type][m][0];
}
}
e lse if(movetype==3)
{
block_y--;
for(int n=0;n<4;n++)
{
block_box[n][1]=block_y+types[block_type][n][0];
}
}
}
public boolean Iscanmoveto()
{
f or(int i=0;i<4;i++)
{
if(block_box[i][0]<0||block_box[i][0]>19)
{
moveback();
return false;
}
else if(block_box[i][1]<0||block_box[i][1]>9)
{
moveback();
return false;
}
else if(game_space[block_box[i][0]][block_box[i][1]]==1)
{
moveback();
return false;
}
}
r eturn true;
}
public boolean Ishitbottom()
{
f or(int i=0;i<4;i++)
{
if(block_box[i][0]+1>19)
{
f or(int m=0;m<4;m++)
{
game_space[block_box[m][0]][block_box[m][1]]=1;
block_box_tt[m][0]=block_box[m][0];
block_box_tt[m][1]=block_box[m][1];
block_box[m][0]=0;
block_box[m][1]=0;
}
r eturn true;
}
}
f or(int i=0;i<4;i++)
{
if(game_space[block_box[i][0]+1][block_box[i][1]]==1) {
f or(int m=0;m<4;m++)
{
game_space[block_box[m][0]][block_box[m][1]]=1;
block_box_tt[m][0]=block_box[m][0];
block_box_tt[m][1]=block_box[m][1];
block_box[m][0]=0;
block_box[m][1]=0;
}
r eturn true;
}
}
r eturn false;
}
public void CheckAndCutLine()
{
a[]={block_box_tt[0][0],block_box_tt[1][0],block_box_tt[2][0],block_box_tt[
3][0]};
i nt b[]={30,30,30,30};
i nt temp=0;
i nt temp1=0;
i nt count=0;
i nt ss=0;
f or(int i=0;i<4;i++)
{
for(int j=0;j<10;j++)
{
if(game_space[a[i]][j]==1)
temp++;
}
if(temp==10)
{
for(int m=0;m<4;m++)
if(b[m]==a[i])
{
break;
}
else
ss++;
if(ss==4)
{
b[count]=a[i];
count++;
}
}
temp=0;
ss=0;
}
f or(int i=0;i<3;i++)
for(int j=i+1;j<4;j++)
{
if(b[i]>b[j])
{
temp1=b[i];
b[i]=b[j];
b[j]=temp1;
}
}
f or(int n=0;n<4;n++)
if(b[n]==30)
break;
else
{
for(int aa=b[n]-1;aa>=0;aa--)
{
for(int bb=0;bb<10;bb++)
{
game_space[aa+1][bb]=game_space[aa][bb];
}
}
for(int cc=0;cc<10;cc++)
game_space[0][cc]=0;
}
}
}
public boolean IsGameOver()
{
b oolean flag=false;
f or(int i=0;i<sp_width;i++)
{
if(game_space[0][i]==1)
{
flag=true;
break;
}
}
r eturn flag;
}
public void sure()
{
f or(int i=0;i<4;i++)
game_space[block_box[i][0]][block_box[i][1]]=1; }
public void notsure()
{
f or(int i=0;i<4;i++)
game_space[block_box[i][0]][block_box[i][1]]=0; }
public boolean judge(int i,int j)
{
i f(game_space[i][j]==1)
return true;
e lse
return false;
}
}
package com.peng;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
public class Class
{
public static void main(String[] args)
{
GameWin frame=new GameWin();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true);
}
public static boolean isplaying=true;
}
class GameWin extends JFrame
{
public GameWin()
{
this.setFocusable(true);
getContentPane().requestFocus();
this.setAlwaysOnTop(true);
setTitle("super russionBlock");
setBounds(350,90,Default_X,Default_Y);
setResizable(false);
add(jpy1);
jpy1.setDividerLocation(304);
jpy1.setDividerSize(4);
addKeyListener(jpy2);
Thread t=new Thread(jpy2);
t.start();
}
public static final int Default_X=500;
public static final int Default_Y=630;
private left jpy2=new left();
private right jpy3=new right();
private JSplitPane jpy1=new
JSplitPane(JSplitPane.HORIZONTAL_SPLIT,jpy2,jpy3); }
class right extends JPanel implements ActionListener {
public right()
{
initialframe();
initialListener();
}
public void initialframe()
{
setLayout(null);
add(jlArray[0]);
jlArray[0].setBounds(30,60,70,30);
jlArray[0].setFocusable(false);
add(jlArray[1]);
jlArray[1].setBounds(30,140,70,30);
jlArray[1].setFocusable(false);
add(jcArray[0]);
jcArray[0].setBounds(100,60,70,30);
jcArray[0].setFocusable(false);
add(jcArray[1]);
jcArray[1].setBounds(100,140,70,30);
jcArray[1].setFocusable(false);
add(jbArray[0]);
jbArray[0].setBounds(50,240,100,35);
jbArray[0].setFocusable(false);
add(jbArray[1]);
jbArray[1].setBounds(50,310,100,35);
jbArray[1].setFocusable(false);
add(jbArray[2]);
jbArray[2].setBounds(50,380,100,35);
jbArray[2].setFocusable(false);
add(jbArray[3]);
jbArray[3].setBounds(50,450,100,35);
jbArray[3].setFocusable(false);
}
public void initialListener()
{
for(int i=0;i<4;i++)
jbArray[i].addActionListener(this);
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==jbArray[0])
{
Class.isplaying=true;
}
else if(e.getSource()==jbArray[1])
{
Class.isplaying=false;
}
else if(e.getSource()==jbArray[2])
{
Class.isplaying=false;
}
else if(e.getSource()==jbArray[3])
{
System.exit(0);
}
}
private String[] level={"1","2","3","4","5"};
private String[] color={"浅绿","浅黄","黑色"};
private JComboBox[] jcArray={new JComboBox(level),new JComboBox(color)};
private JLabel[] jlArray={new JLabel("游戏等级"),new JLabel("背景熊昌杰")};
private JButton[] jbArray={new JButton("开始游戏"),new JButton("暂停游戏") ,new JButton("结束游戏"),new JButton("退出游戏")}; }
class left extends JComponent implements KeyListener,Runnable
{
public left()
{
game=new BlockGame();
}
public void paintComponent(Graphics g)
{
Graphics2D g2=(Graphics2D)g;
super.paintComponent(g);
double width=300,height=600;
Rectangle2D rect=new Rectangle2D.Double(0,0,width,height);
g2.setColor(Color.black);
g2.draw(rect);
g2.setColor(Color.yellow);
g2.fill(rect);
g2.setColor(Color.black);
g2.draw(rect);
for(int i=0;i<20;i++)
for(int j=0;j<10;j++)
{
if(game.judge(i,j)==true)
{
Rectangle2D rect3=new
Rectangle2D.Double(j*boxSize,i*boxSize,boxSize,boxSize);
g2.setColor(Color.black);
g2.draw(rect3);
g2.setColor(Color.red);
g2.fill(rect3);
g2.setColor(Color.black);
g2.draw(rect3);
}
}
game.notsure();
}
public void keyTyped(KeyEvent e)
{}
public void keyPressed(KeyEvent e)
{
if(Class.isplaying==false)
return;
switch(e.getKeyCode())
{
case KeyEvent.VK_LEFT: //LEFT game.moveleft();
movejudge();
break;
case KeyEvent.VK_UP: //UP game.turnright();
movejudge();
break;
case KeyEvent.VK_RIGHT: //RIGHT game.moveright();
movejudge();
break;
case KeyEvent.VK_DOWN: //DOWN game.movedown();
movejudge();
break;
}
}
public void keyReleased(KeyEvent e)
{}
public void movejudge()
{
i f(game.Iscanmoveto()==true)
{
game.sure();
repaint();
}
e lse if(game.Ishitbottom()==true)
{
game.CheckAndCutLine();
game.makenewblock();
repaint();
if(game.IsGameOver()==true)
Class.isplaying=false;
}
}
public void run()
{
try
{
while(Class.isplaying)
{
Thread.sleep(500);
game.movedown();
movejudge();
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
private BlockGame game;
public static final int boxSize=30; }
参考文献
1.耿祥义、张跃平编著《JAVA2实用教程》（第4版）北京：清华大学出版社
2.张跃平、耿祥义编著《Java 2实用教程（第4版）实验指导与习题解答》北京：清华大学出版社
3．齐治昌、谭庆平编著《软件工程[M].电脑编程技巧与维护》北京：北京教育出版社，2004年:7-26
毕业设计（论文）原创性声明和使用授权说明
原创性声明
本人郑重承诺：所呈交的毕业设计（论文），是我个人在指导教师的指导下进行的研究工作及取得的成果。

尽我所知，除文中特别加以标注和致谢的地方外，不包含其他人或组织已经发表或公布过的研究成果，也不包含我为获得及其它教育机构的学位或学历而使用过的材料。

对本研究提供过帮助和做出过贡献的个人或集体，均已在文中作了明确的说明并表示了谢意。

作者签名：日期：
指导教师签名：日期：
使用授权说明
本人完全了解大学关于收集、保存、使用毕业设计（论文）的规定，即：按照学校要求提交毕业设计（论文）的印刷本和电子版本；学校有权保存毕业设计（论文）的印刷本和电子版，并提供目录检索与阅览服务；学校可以采用影印、缩印、数字化或其它复制手段保存论文；在不以赢利为目的前提下，学校可以公布论文的部分或全部内容。

作者签名：日期：
学位论文原创性声明
本人郑重声明：所呈交的论文是本人在导师的指导下独立进行研究所取得的研究成果。

除了文中特别加以标注引用的内容外，本论文不包含任何其他个人或集体已经发表或撰写的成果作品。

对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式标明。

本人完全意识到本声明的法律后果由本人承担。

作者签名：日期：年月日
学位论文版权使用授权书
本学位论文作者完全了解学校有关保留、使用学位论文的规定，同意学校保留并向国家有关部门或机构送交论文的复印件和电子版，允许论文被查阅和借阅。

本人授权大学可以将本学位论文的全部或部分内容编入有关数据库进行检索，可以采用影印、缩印或扫描等复制手段保存和汇编本学位论文。

涉密论文按学校规定处理。

作者签名：日期：年月日
导师签名：日期：年月日
指导教师评阅书
评阅教师评阅书
教研室（或答辩小组）及教学系意见
学位论文原创性声明
本人郑重声明：所呈交的学位论文，是本人在导师的指导下进行的研究工作所取得的成果。

尽我所知，除文中已经特别注明引用的内容和致谢的地方外，本论文不包含任何其他个人或集体已经发表或撰写过的研究成果。

对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式注明并表示感谢。

本人完全意识到本声明的法律结果由本人承担。

学位论文作者（本人签名）：年月日
学位论文出版授权书
本人及导师完全同意《中国博士学位论文全文数据库出版章程》、《中国优秀硕士学位论文全文数据库出版章程》(以下简称“章程”)，愿意将本人的学位论文提交“中国学术期刊（光盘版）电子杂志社”在《中国博士学位论文全文数据库》、《中国优秀硕士学位论文全文数据库》中全文发表和以电子、网络形式公开出版，并同意编入CNKI《中国知识资源总库》，在《中国博硕士学位论文评价数据库》中使用和在互联网上传播，同意按“章程”规定享受相关权益。

论文密级：
□公开□保密（___年__月至__年__月）(保密的学位论文在解密后应遵守此协议)
作者签名：_______ 导师签名：_______
_______年_____月_____日_______年_____月_____日
独创声明
本人郑重声明：所呈交的毕业设计(论文)，是本人在指导老师的指导下，独立进行研究工作所取得的成果，成果不存在知识产权争议。

尽我所知，除文中已经注明引用的内容外，本设计（论文）不含任何其他个人或集体已经发表或撰写过的作品成果。

对本文的研究做出重要贡献的个人和集体均已在文中以明确方式标明。

本声明的法律后果由本人承担。

作者签名:
二〇一〇年九月二十日
毕业设计（论文）使用授权声明
本人完全了解滨州学院关于收集、保存、使用毕业设计（论文）的规定。

本人愿意按照学校要求提交学位论文的印刷本和电子版，同意学校保存学位论文的印刷本和电子版，或采用影印、数字化或其它复制手段保存设计（论文）；同意学校在不以营利为目的的前提下，建立目录检索与阅览服务系统，公布设计（论文）的部分或全部内容，允许他人依法合理使用。

（保密论文在解密后遵守此规定）
作者签名:
二〇一〇年九月二十日
致谢
时间飞逝，大学的学习生活很快就要过去，在这四年的学习生活中，收获了很多，而这些成绩的取得是和一直关心帮助我的人分不开的。

首先非常感谢学校开设这个课题，为本人日后从事计算机方面的工作提供了经验，奠定了基础。

本次毕业设计大概持续了半年，现在终于到结尾了。

本次毕业设计是对我大学四年学习下来最好的检验。

经过这次毕业设计，我的能力有了很大的提高，比如操作能力、分析问题的能力、合作精神、严谨的工作作风等方方面面都有很大的进步。

这期间凝聚了很多人的心血，在此我表示由衷的感谢。

没有他们的帮助，我将无法顺利完成这次设计。

首先，我要特别感谢我的知道郭谦功老师对我的悉心指导，在我的论文书写及设计过程中给了我大量的帮助和指导，为我理清了设计思路和操作方法，并对我所做的课题提出了有效的改进方案。

郭谦功老师渊博的知识、严谨的作风和诲人不倦的态度给我留下了深刻的印象。

从他身上，我学到了许多能受益终生的东西。

再次对周巍老师表示衷心的感谢。

其次，我要感谢大学四年中所有的任课老师和辅导员在学习期间对我的严格要求，感谢他们对我学习上和生活上的帮助，使我了解了许多专业知识和为人的道理，能够在今后的生活道路上有继续奋斗的力量。

另外，我还要感谢大学四年和我一起走过的同学朋友对我的关心与支持，与他们一起学习、生活，让我在大学期间生活的很充实，给我留下了很多难忘的回忆。

最后，我要感谢我的父母对我的关系和理解，如果没有他们在我的学习生涯中的无私奉献和默默支持，我将无法顺利完成今天的学业。

四年的大学生活就快走入尾声，我们的校园生活就要划上句号，心中是无尽的难舍与眷恋。

从这里走出，对我的人生来说，将是踏上一个新的征程，要把所学的知识应用到实际工作中去。

回首四年，取得了些许成绩，生活中有快乐也有艰辛。

感谢老师四年来对我孜孜不倦的教诲，对我成长的关心和爱护。

学友情深，情同兄妹。

四年的风风雨雨，我们一同走过，充满着关爱，给我留下了值得珍藏的最美好的记忆。

在我的十几年求学历程里，离不开父母的鼓励和支持，是他们辛勤的劳作，无私的付出，为我创造良好的学习条件，我才能顺利完成完成学业，感激他们一直以来对我的抚养与培育。

最后，我要特别感谢我的导师赵达睿老师、和研究生助教熊伟丽老师。

是他们在我毕业的最后关头给了我们巨大的帮助与鼓励，给了我很多解决问题的思路，在此表示衷心的感激。

老师们认真负责的工作态度，严谨的治学精神和深厚的理论水平都使我收益匪浅。

他无论在理论上还是在实践中，都给与我很大的帮助，使我得到不少的提高这对于我以后的工作和学习都有一种巨大的帮助，感谢他耐心的辅导。

在论文的撰写过程中老师们给予我很大的帮助，帮助解决了不少的难点，使得论文能够及时完成，这里一并表示真诚的感谢。