俄罗斯方块Java编写精髓(1)解读
java课程设计报告-俄罗斯方块
JAVA程序设计课程设计之俄罗斯方块目录摘要................................................................. 第一章课程设计要求..................................................第二章设计概要......................................................2.1 功能设计......................................................2.2 功能分析......................................................2.2.1 系统操作界面...............................................2.2.2 程序主要功能说明...........................................第三章调试分析与测试结果............................................3.1 游戏运行界面..................................................3.2 测试项目......................................................3.2.1 功能区按键测试............................................3.2.2 键盘功能测试..............................................3.2.3 游戏结束测试..............................................第四章设计总结......................................................4.1 改进意见......................................................4.2 《Java课程设计》心得体会 ......................................摘要在现代,高科技的飞跃发展,人们工作习惯的改变,特别是电脑的大量普及,人们生活节奏越来越快,一些有趣的桌面游戏已经成为人们在使用计算机进行工作或学习之余休闲娱乐的首选,而俄罗斯方块游戏是人们最熟悉的小游戏之一。
java俄罗斯方块开发文档
俄罗斯方块游戏项目介绍俄罗斯方块(Tetris, 俄文:Тетрис)是一款风靡全球的电视游戏机和掌上游戏机游戏,它由俄罗斯人阿列克谢•帕基特诺夫发明,故得此名。
俄罗斯方块的基本规则是移动、旋转和摆放游戏自动输出的各种方块,使之排列成完整的一行或多行并且消除得分。
由于上手简单、老少皆宜,从而家喻户晓,风靡世界。
本项目将需要使用Java语言完成一个俄罗斯方块的游戏开发。
任务一需求分析游戏场景是一个用于摆放正方形的平面虚拟场地,其标准大小为:行宽为10,列高为20,以每个小正方形为单位。
一组由4个小型正方形组成的规则图形,共有7种,分别为I、L、J、O、S、T、Z 这7个字母形状来命名。
其具体形状如图。
I:一次最多消除四层J:最多消除三层,或消除两层L:最多消除三层,或消除两层O:消除一至两层Z:最多两层,容易造成孔洞T:最多两层游戏规则(1)部分游戏有单格方块,可以穿透固定的方块到达最下层空位。
其他的改版中出现更多特别的造型。
方块会从区域上方开始缓慢继续落下。
(2)玩家可以做的操作有:以90度为单位旋转方块,以格子为单位左右移动方块,让方块加速落下。
(3)方块移到区域最下方或是着地到其他方块上无法移动时,就会固定在该处,而新的方块出现在区域上方开始落下。
(4)当区域中某一列横向格子全部由方块填满,则该列会消失并成为玩家的得分。
同时删除的列数越多,得分指数上升。
(5)当固定的方块堆到区域最上方而无法消除层数时,则游戏结束。
(6)一般来说,游戏还会提示下一个要落下的方块,熟练的玩家会计算到下一个方块,评估要如何进行。
由于游戏能不断进行下去对商业用游戏不太理想,所以一般还会随着游戏的进行而加速提高难度。
(7)通过设计者预先设置的随机发生器不断地输出单个方块到场地顶部,以一定的规则进行移动、旋转、下落和摆放,锁定并填充到场地中。
每次摆放如果将场地的一行或多行完全填满,则组成这些行的所有小正方形将被消除,并且以此来换取一定的积分或者其他形式的奖励。
JAVA课程设计 俄罗斯方块
JAVA语言实现俄罗斯方块的代码实现
初始化游戏界面:创建JFrame对象,设 置大小和标题
游戏结束处理:判断游戏是否结束,显 示得分和重新开始按钮
绘制游戏网格:使用二维数组存储游戏 状态,绘制每个方块
优化游戏性能:使用双缓冲技术,提高 游戏流畅度
控制游戏逻辑:监听键盘事件,实现方 块的移动、旋转和消除
游戏逻辑的实现
游戏界面:显示游戏区域、得分、等级等信息 游戏操作:通过键盘或鼠标控制方块的移动和旋转 游戏规则:方块掉落、消除、得分等规则 游戏结束:当游戏区域被填满或达到一定分数时结束游戏
游戏音效和动画效果的实现
音效:使用Java的 Audio类播放音效 文件
动画效果:使用 Java的Swing库中 的JPanel和JLabel 组件实现动画效果
易 于 学 习 : J AVA 具 有 简 洁 的 语 法 和 丰 富 的类库,使得学习JAVA语言相对容易。
JAVA语言在游戏开发中的应用
JAVA语言具有跨平台性,可以在多种操作系统上运行,适合游戏开发。 JAVA语言具有丰富的API,可以方便地实现游戏功能。 JAVA语言具有强大的图形处理能力,可以方便地实现游戏画面。 JAVA语言具有良好的安全性和稳定性,适合大型游戏的开发。
Hale Waihona Puke 05 课程设计的总结和展望
课程设计的收获和不足
收获:掌握了JAVA编程的基本知识和技能,提高了逻辑思维能力和解决问题的能力。
不足:在课程设计中遇到了一些困难,如代码编写错误、程序运行异常等,需要加强实践和 经验积累。
展望:希望在未来的课程设计中能够更加熟练地运用 JAVA编程,提高程序设计的质量和效率。
打包发布:使用JAR文件打包游戏,方 便分发和运行
JAVA课程设计俄罗斯方块(含代码)
Java程序课程设计任务书俄罗斯方块游戏的开发1、主要内容:俄罗斯方块游戏具有广泛的游戏人群,因为它比较简单有趣,无论老少都比较适合。
俄罗斯方块游戏的设计对于每一个Java语言设计者进行语言提高和进阶都是一个很好的锻炼机会。
俄罗斯方块游戏的设计工作是非常复杂和重要的,它涉及面逛,牵涉面多,如果不好好考虑和设计,将难以成功开发出这个游戏。
在这个游戏的设计中,将牵涉到图形界面的显示与更新,数据的收集与更新并且在这个游戏的开发中还会应用类的继承机制以及一些设计模式。
因此,如何设计和开发好这个俄罗斯方块游戏,对于提高Java开发水平和系统的设计能力有极大的帮助。
在设计开发过程中,开发者需要处理好各个类之间的集成关系,还要处理各个类的相应的封装,并且还要协调好各个模块之间的逻辑依赖关系和数据通信关系。
2、具体要求(包括技术要求等):系统的功能设计要求:本课程设计将实现以下几种功能。
1.游戏界面主框架游戏界面主框架主要包括游戏图形区域界面,游戏速度的选择更新界面,,游戏分数的显示更新界面,下一个图形方块的显示更新区域,开始游戏按钮,重新开始游戏按钮以及退出游戏按钮游戏界面主框架的主要结构如下图所示。
2.游戏图形区域界面的显示更新功能游戏图形区域界面主要是一个图形显示更新区域,主要包括游戏方块显示更新,整行方块的删除和更新,进行中和游戏结束时的分数更新和游戏图形区域界面的清除。
在这个游戏图形区域界面中,主要是一个表格,根据相应格子的设置标志来显示相应的图形图片,这样就实现了俄罗斯方块的实时显示。
3.游戏方块的设计在俄罗斯方块游戏中,具体的游戏方块图形的设计是比较重要的一个方面。
因为俄罗斯方块游戏中主要的动作就是控制游戏方块的移动和翻转,以便于组成一行行连续的方块从而增加游的分数。
由于主要的游戏动作都集中在这个游戏方块上,因此游戏方块的设计就显得格外重要了。
为了增加程序的可扩展性,这里设计一个游戏方块的基类,各个具体的游戏方块都从这个基类开始继承。
俄罗斯方块游戏设计(Java版)
软件092、093实训题目:俄罗斯方块游戏设计(Java版)开发工具要求:Jcreate 3.5 或以上参考:java帮助文档,tutorial文档知识: 程序主框架,事件发生与处理模型,时间日期类及时间格式化输出、图形绘制接口(类)及各类绘图成员函数、窗体的重绘机制、进程及线程的初步概念。
要求:完成以下游戏内容,满分为85分,若加以扩展,满分为100分。
一、设计要点:1.游戏数据与界面显示相分离,用游戏结构数据描述游戏的状态,玩家操作或游戏自行走一步,程序中都通过修改游戏数据来体现,即每走一步,程序会修改当前的游戏数据,判断游戏是否结束了,也是通过对游戏数据的分析来作出结论。
游戏界面是根据当时游戏数据来绘制的,当数据改变时,要清除原图形并重绘。
总之,游戏的逻辑设计是针对游戏数据,而不是游戏界面。
界面只是间接地向玩家显示结果。
2.因此,在设计函数时,大致分二类:与玩家操作事件有关的数据处理函数,与界面效果有关的图形绘制函数。
游戏运行过程由窗体监听到的键盘事件控制。
3.在游戏程序中,我们可以将它看成3个对象,分别是程序窗体主类对象、方块数据管理对象、控制游戏自动下落的定时器线程对象。
窗体界面主类对象:负责绘制游戏图象、包含游戏设置的各种控件(如:设置速度的文本框、显示得分的标签、开始及暂停按钮),负责游戏的各种属性数据的读入及显示输出,最重要的是:它还是一个键盘事件处理类,监听玩家的键盘操作,处理键盘事件,在键盘事件处理函数中调用游戏数据管理对象的方法,控制游戏的运行。
我们还把游戏数据管理对象、控制游戏自动下落的定时器线程对象作为它的成员变量。
游戏数据管理对象:主要管理着两方面数据:方块的坐标数据和游戏空间数据。
用成员数组变量描述游戏空间状态,根据游戏空间状态判断游戏是否结束。
用它的成员变量保存方块的形状数据及坐标数据,定义当方块走动方块数据变化的处理方法。
此外,还把各种游戏属性数据作为其成员变量。
基于Java的俄罗斯方块游戏的设计与实现
基于Java的俄罗斯方块游戏的设计与实现作者:高成珍来源:《科技经济市场》2017年第02期摘要:俄罗斯方块是一款简单有趣的益智类小游戏,通过对游戏中包含的元素及其关系的分析,抽象出相应的类和接口,通过对游戏过程的分析,抽象出关键的流程,并通过Java语言编程实现。
关键词:俄罗斯方块;Java0引言俄罗斯方块是一款经久不衰的益智类小游戏,游戏规则简单、有趣,老少皆宜。
对于Java 初学者来说是一个不错的练习项目,难度适中,不仅可以检验知识的综合运用,提升开发技能,培养面向对象编程思维,同时还可以激发学习兴趣,增强自我效能感。
1俄罗斯方块游戏中核心元素游戏中核心元素包括3个:各种形状的方块、底部障碍物以及游戏面板。
游戏主要是控制方块在面板上的移动与变化以及障碍物的增加和消除。
1.1方块经典的俄罗斯方块游戏中方块主要有7种类型,如图1所示,每一种类型又有若干种变形,如图2所示。
根据图2形状的分析可以得出,所有的方块都可以用一个4*4的格子表示,格子有两种状态:空白和填充。
对于不同的形状,填充部分不同而已,所以可以用一个包含16个整型元素的一维数组来表示一种具体的形状。
当需要填充时,对应的位置上的数字为1,否则位置上的数字为0。
采用二维数组存储一种类型的方块,第一维表示的是第几种变体,第二维表示具体形状的数值。
采用三维数组存储所有的方块,第一维表示哪一种类型,第二维表示该类型的第几种变体,第三维表示具体形状的数值。
对于方块来说除了要知道它的形状以外,还需要知道它的位置,并且能够根据需要进行移动和变形,所以方块类(Shape)的设计如图3所示。
1.2障碍物障碍物实际上就是不能移动的方块组合,障碍物会随着游戏执行过程而不断增加或减少。
与方块类似可以采用一个二维数组来保存障碍物,数组的大小即为整个面板中横向和纵向上格子的个数,对于需要填充的格子数值标记为1,空白格子对应的数值为0。
障碍物添加后需要判断是否超出边界,如果超出则游戏结束,同时需要判断是否有满行,有则需要删除等等,障碍物类(Ground)的关键属性和方法如图4所示。
Java编写俄罗斯方块方案和源码
Java编程俄罗斯方块方案和源码开发过程:1)软件的功能描述俄罗斯方块的基本规则:1、一个用于摆放小型正方形的平面虚拟场地,其标准大小:行宽为10,列高为20,以每个小正方形为单位。
2、一组由4个小型正方形组成的规则图形,英文称为Tetromino,中文通称为方块共有7种,分别以S、Z、L、J、I、O、T这7个字母的形状来命名。
I:一次最多消除四层J(左右):最多消除三层,或消除二层L:最多消除三层,或消除二层O:消除一至二层S(左右):最多二层,容易造成孔洞Z (左右):最多二层,容易造成孔洞T:最多二层(1)玩家操作有:旋转方块,以格子为单位左右移动方块,让方块加速落下。
(2)方块移到区域最下方或是着地到其他方块上无法移动时,就会固定在该处,而新的方块出现在区域上方开始落下。
(3)当区域中某一列横向格子全部由方块填满,则该列会消失并成为玩家的得分。
同时删除的列数越多,得分指数上升。
(4)当固定的方块堆到区域最上方而无法消除层数时,则游戏结束。
(6)一般来说,游戏还会提示下一个要落下的方块,熟练的玩家会计算到下一个方块,评估要如何进行。
由于游戏能不断进行下去对商业用游戏不太理想,所以一般还会随着游戏的进行而加速提高难度。
(7)预先设置的随机发生器不断地输出单个方块到场地顶部2)需求分析2.1 找对象,找东西对象关系模型tetris (俄罗斯方块)|-- tetromino 一个正在下落的方块| |-- cells 4个格子|-- nextOne 下一个准备下落的方块| |-- cells 4个格子|-- wall 墙, 是方块下落到底部打散着陆到墙上|-- rows 20行|-- cols 10列个格子2.2 数学模型设计2.3 类的设计: 是根据数学模型设计的属性Tetris (俄罗斯方块)类继承JPanel|-- Tetromino tetromino 正在下落的方块|-- Tetromino nextOne 下一个准备下落的方块|-- Cell[][] wall 是2维数组Tetromino 类|-- Cell[] cells 4个格子T 型方块继承Tetromino 类I 型方块继承Tetromino 类...Cell 类|-- int row 行号|-- int col 列号3)功能分析算法实现功能分析映射到数学模型的数据计算数学模型的数据计算:算法分析策略:功能就是方法,功能的描述中的动词也是方法3.1 下落功能:(softDropAction())如果(检查)能够下落就下落,否则就着陆到墙上,而新的方块出现在区域上方开始落下。
45分钟教你学会编制俄罗斯方块
第一;程序架构我们来编写俄罗斯方块这个程序,那我们就先来个庖丁解牛,将俄罗斯反怪分解为我们需要解决的各个1、构建方块,2、初始化3、随机生成方块4、方块进入操作界面5、判断方块所处环境6、移动操控的方块7、变形按键处理8、消除处理9、时间处理10、其余杂项处理以上就是我们将俄罗斯方块分解后的几个模块,这样,整个程序的架构就基本完成了。
第二:程序设计也就是程序的主要部分了,我们可以先新建一个模块,0、公共变量罗列(建议琢磨时间30秒)我们先把我这个程序涉及到的变量罗列一下,不用刻意去看啥意思。
后面我们在每个模块当中都会提到Public Declare Function SetTimer Lib "user32.dll" (ByVal hWnd As Long, ByVal nIDEvent As Long, ByVal uElapse As Long, ByVal lpTimerFunc As Long) As Long Public Declare Function KillTimer Lib "user32.dll" (ByVal hWnd As Long, ByVal nIDEvent As Long) As Long''以上两个函数可能有人没见过。
是用来设定每隔多少时间执行一个过程的函数。
不晓得的话照抄还不会吗?settimer就是设定间隔并生效执行,killtimer就是去除这个设定。
Public CurrentBlock, NextBlock, TempBlock''CurrentBlock 当前方块NextBlock 下一个方块TempBlock 临时方块Public CurrentColor, NextColor ''当前方块颜色,下一个方块颜色Public InterTime ''间隔时间,就是方块自然下降的速度。
基于Java的游戏“俄罗斯方块”的设计与实现毕业设计
基于Java的游戏“俄罗斯方块”的设计与实现毕业设计基于Java的游戏“俄罗斯方块”的设计与实现毕业设计目录第1章绪论 (1)1.1 本设计的目的和意义 (1)1.2 国外研究现状 (1)1.3 设计研究的主要容、目标与工具 (2)1.3.1 设计的主要容 (2)1.3.2 设计要达到的目标 (3)1.3.3 设计方法介绍 (3)第2章可行性分析 (7)2.1 可行性分析 (7)2.1.1 可行性研究的前提 (7)2.1.1.1 要求 (7)2.1.1.2 目标 (8)2.1.1.3 条件、假定和限制 (8)2.1.2 对现有软件的分析 (8)2.2 所建议的软件 (9)2.2.2 社会可行性分析 (10)2.2.3 技术可行性分析 (11)2.2.3.1 执行平台方面 (11)2.2.3.2 执行速度方面 (12)2.2.3.3 语言特性与功能方面 (12)2.2.3.4 开发环境方面 (13)2.2.3.5 JBuilder开发工具 (13)2.2.4 经济可行性 (13)第3章需求分析 (14)3.1 任务概述 (14)3.1.1 目标 (14)3.1.2 用户的特点 (14)3.2 具体需求 (14)3.2.1 功能需求 (14)3.2.1.1 游戏主界面模块需求 (14)3.2.1.2 游戏图形区域界面的需求 (15)3.2.1.3 方块下落速度需求 (15)3.2.1.4 游戏分数需求 (15)3.2.1.5 游戏排行榜需求 (15)3.2.2 属性需求 (15)第4章概要设计 (16)4.2 功能模块设计 (16)4.2.1 总设计模块的划分 (16)4.2.2 游戏主界面模块 (17)4.2.3 游戏控制模块 (17)4.2.4 游戏设置模块 (18)4.2.5 游戏排行榜模块 (18)4.3 类模块设计 (19)4.3.1 类模块之间关系 (19)4.3.2 各类模块设计概要 (19)4.3.3 类和Java源文件对应关系 (20)4.4 程序设计的重点 (21)4.4.1 游戏图形界面的图形显示更新功能 (21) 4.4.2 游戏方块的设计 (21)4.5 接口设计 (22)4.5.1 外部接口 (22)4.5.2 外部接口 (22)4.6 维护设计 (22)4.7 故障处理 (22)第5章详细设计 (24)5.1 程序主结构 (24)5.2 开发环境配置 (24)5.2.1 Java2的标准运行环境 (24)5.2.1.1 J2SE SDK (24)5.2.1.2 J2SE JRE (25)5.2.1.3 J2SE Documentation (25)5.2.2 J2SE的安装与配置 (25)5.2.2.1安装过程 (25)5.2.2.2 配置环境变量 (28)5.3 类模块程序流程图 (31)5.3.1 BlockGame类 (31)5.3.2 BlockFrame类 (32)5.3.3 Square类 (32)5.3.4 LevelDialog类 (32)5.3.5 Game类 (32)5.3.6 Score类 (34)5.3.7 SaveScoreDialog类 (34)5.3.8 ReportDialog类 (35)5.3.9 AboutDialog类 (35)5.4 类模块具体设计 (35)5.4.1 BlockGame.java程序 (35)5.4.2 BlockFrame.java程序 (36)5.4.2.1 BlockFrame类程序 (36)5.4.2.2 Game类程序 (37)5.4.2.3 LevelDialog类程序 (40)5.4.2.4 BlockFrame.java的UML图 (40) 5.4.3 Score.java程序 (42)5.4.4 SaveScoreDialog.java程序 (43) 5.4.5 Reportdialog.java程序 (46)5.4.6 AboutDialog.java程序 (48)5.4.7 Square.java程序 (49)5.5 安装文件的生成 (50)5.5.1 inno setup简介 (50)5.5.2 安装文件制作步骤 (50)5.6 游戏界面展示 (54)第6章软件测试 (58)6.1 程序代码调试 (58)6.1.1 用正常数据调试 (58)6.1.2 异常数据调试 (58)6.1.3 用错误数据调试 (58)6.2 程序功能测试 (58)6.2.1 模块功能测试 (59)6.2.2 确认测试 (60)第7章软件维护 (61)结论 (62)致谢 (63)参考文献 (64)附录“俄罗斯方块游戏”程序源代码 (65)第1章绪论1.1 本设计的目的和意义俄罗斯方块游戏具有广泛的用户群,因为它比较简单有趣,无论老少都比较适合。
《俄罗斯方块》程序编写超详细解释
Tc2.0 编写俄罗斯方块游戏很多编程爱好者都编写过俄罗斯方块的游戏程序。
很久以前,我用Tc2.0也做过一个;最近有好些朋友看见我以前的俄罗斯方块的程序后,问我是怎么做的。
我一直想把这个程序的整个过程写一份详细的东西,与各位编程爱好者分享,一直没空。
正好现在放假了,而且离回家还有几天。
于是我就把这个程序重新写了一遍,尽量使程序的结构比较清晰好懂一些。
同时写了下面的这份东西。
俄罗斯方块游戏的程序中用到了一些方法。
为了比较容易理解这些方法,我在讲述的同时写了些专门针对这些方法的示例程序。
这些示例程序力求短小,目的是用最小的代码能够清楚的示例所用的方法。
这些示例程序都经过tc2.0测试。
最后还附了完整的俄罗斯方块游戏的源代码,和最终的可执行程序。
如果你看了这份东东,有什么意见和想法,请发电子邮件告诉我。
我将会继续更新这分东东,最新的版本可以在我的个人主页上下载。
下面的问题是有关俄罗斯方块程序的,其中有些是朋友问我的,有些是我认为可能会被问到的。
我尽量按问题从易到难排列这些问题。
关于俄罗斯方块程序的一些问题:******************************************************Tc2.0中怎么样设置图形显示?Tc2.0中常用图形函数的用法?怎样获取鍵盘输入?怎样控制方块的移动?怎样控制时间间隔(用于游戏中控制形状的下落)?游戏中的各种形状及整个游戏空间怎么用数据表示?游戏中怎么判断左右及向下移动的可能性?游戏中怎么判断某一形状旋转的可能性?按向下方向键时加速某一形状下落速度的处理?怎么判断某一形状已经到底?怎么判断某一已经被填满?怎么消去已经被填满的一行?怎么消去某一形状落到底后能够消去的所有的行?(如长条最多可以消去四行)怎样修改游戏板的状态?怎样统计分数?怎样处理升级后的加速问题?怎样判断游戏结束?关于计分板设计的问题。
关于“下一个”形状取法的问题。
剩下的问题。
浅析Java 语言在俄罗斯方块游戏中的实现
浅析Java 语言在俄罗斯方块游戏中的实现作者:王立友来源:《发明与创新(职业教育)》 2019年第7期王立友(淮南联合大学,安徽淮南232001)摘要:《俄罗斯方块》作为一款益智类小游戏,一度风靡全球。
游戏操作简单灵活,趣味性强。
本文阐述了利用Java语言实现俄罗斯方块游戏的整个流程。
通过对游戏过程的分析,阐述《俄罗斯方块》实现过程中的架构设计和技术难点。
关键词:俄罗斯方块游戏;Java俄罗斯方块名字的来由源自于希腊语,含义为4,因为游戏中所有方块的设计均为四个方块的组合。
俄罗斯方块游戏是一款经久不衰的益智类小游戏[1],游戏规则简单明了,趣味性强。
对于 Java 编程爱好者而言,是一个不错的训练项目,难度适中,在游戏的开发设计过程中,不仅可以检验Java编程知识的综合运用,提升开发技能,同时还可以激发开发者的学习兴趣。
一、俄罗斯方块游戏总体设计(一)游戏功能模块系统构成游戏主要包括3个功能模块:方块控制功能、方块预览功能、游戏积分统计功能[2]。
1.方块控制功能:主要通过条件判断,来实现方块在下落的过程中向左移动、向右移动、方块旋转、方块触边、方块触块、方块触底及满行消除功能。
2.方块预览功能:当游戏界面出现一个游戏方块时,游戏方块预览区域中将随机生成下一个游戏方块,便于游戏玩家判断方块堆叠的走势,更好地布局方块的具体下落位置。
3.游戏积分统计功能:每消除一行得100分,如果一次消除两行则可以得100+200即300分,以此类推,当游戏分数累积到一定程度,系统游戏难度会增加,共有5个难度等级,难度系数1级最简单,5级最难。
当游戏失败时,记录当前分数与历史最高分相比较,如果超过历史最高分,则将当前分数记作历史最高分,并返回游戏初始界面。
(二)游戏运行流程游戏开始时,在控制面板顶部随机生成方块,方块自由下落,判断下落中是否到达顶部,如果到达顶部则表示游戏结束,否则判断是否到底或者是否碰到障碍物,如果没有碰到障碍物,方块继续下落,如果碰到障碍物,则停止下落,判断是否有满行,满行就消除并累加分数。
JAVA俄罗斯方块游戏设计与实现
第一章绪论1.1游戏的历史游戏开发至今已经有30多年,在这个短暂的时期里,随着硬件水平的提高,游戏开发新技术层出不穷,经典游戏比比皆是。
1.1.1 从头谈起真正的电子游戏机产生于20世纪70年代。
1971年,麻省理工学院的学生Nolan Bushnell设计了世界上的第一个业务用游戏机(俗名街机),叫做《电脑空间》。
这台游戏机用一台黑白电视机作为显示屏,用一个控制柄作为操纵器,不过由于市场因素这款游戏以失败告终。
但是最后他在电子游戏的发展上取得了非凡的成就。
上面介绍的是专用机游戏的历史,而最早的电脑游戏可以追溯到1972年,一个叫Crowther的工程师用当时最流行的主机――DEC公司的PDP-10编写一段简单的FORTRAN程序。
在这个程序里,Crowther设计了一张地图,地图上不规则的分布着陷阱,游戏者必须寻找路径避开陷阱。
这个程序被公认为是最早的电脑游戏程序。
1989年,BroderBund公司的设计师乔丹.麦克纳根据阿拉伯民族的古老传说《一千零一夜》在Apple平台上制作了一部动作冒险相结合的电脑游戏――波斯王子。
这个游戏获得了第一作,它代表了当时电脑技术的最高水平。
1986年,任天堂公司发售了一款真正的游戏巨作――超级马里奥。
20世纪80年代IBM PC兼容机的出现打破了Apple公司的垄断地位。
到了20世纪90年代,游戏业才真正成熟起来,成为了一种产业。
由于PC机价格非常低而且硬件速度越来越快,游戏逐渐成为人们生活中不可缺少的一部分。
游戏产业也逐渐发展成熟。
1.1.2 图形硬件的革命图形硬件的飞速发展是近些年来的事情,部分原因是来自工业方面的压力,例如在军事和医疗方面对于实时图形的需求很强烈,而交互娱乐产业也极大的推动了图形硬件的发展。
技术上的因素同样也推动着图形硬件的发展,许多图形算法可以很容易地表达为并行方式,这样硬件执行的效率变得很高。
摩乐定律也起了作用,越来越多的晶体管可以集成到一块单独的芯片上。
Java实现俄罗斯方块游戏简单版
Java实现俄罗斯⽅块游戏简单版本⽂实例为⼤家分享了Java实现俄罗斯⽅块游戏的具体代码,供⼤家参考,具体内容如下游戏页⾯效果如下:俄罗斯⽅块游戏本⾝的逻辑:俄罗斯⽅块游戏的逻辑是⽐较简单的。
它就类似于堆砌房⼦⼀样,各种各样的⽅地形状是不同的。
但是,俄罗斯⽅块游戏的界⾯被等均的分为若⼲⾏和若⼲列,因此⽅块的本质就是占⽤了多少个单元。
⾸先来考虑⼀下数据的问题。
对于界⾯来说,需要⼀个⼆维的 int 型数组,它保存着那些地⽅应该有着⾊,哪些没有;然后是⽅块本⾝,尽管它们的形状不统⼀,但是它们可以⽤⼀个4X4⽐例的⽅块所包围,因此⽤16个字节就可以把⼀个⽅块的信息保存者,注意:其实⽅块的数据也可以⽤int 数组表⽰,但是涉及到效率问题,⽤位操作⽐⽤普通的算术运算要快⼀点。
接下来思考⼀下动作具体有下⾯⼏点:(1)⽅块的诞⽣。
它的诞⽣是需要⽤随机原理的,另外,它如何初始化的被放置在游戏界⾯的顶部?(2)⽅块是需要⾃动的往下掉的,它在掉的过程中,还需要判断它是否与周围的环境是否发⽣了冲突,能不能继续往下。
(3)⽅块本⾝还可以变形,变形以后的⽅块具有不同的数据,判断的⽅式⼜会不⼀样。
(4)当⽤户⼀直按住s键的时候,⽅块还需要持续往下掉。
然后就是过程,玩家主要操作的地⽅有以下⼏个⽅⾯:(1)左右操作。
需要监听KeyEvent,让⽅块左右移动,直到碰到边界。
(2)变形操作。
也要监听KeyEvent,让⽅块⾃动的变形。
(3)下降操作。
也要监听KeyEvent,让⽅块快速的下降。
⾄于游戏的结束,只有⼀种情况,那就是诞⽣的⽅块出世就与其他⽅块冲突了。
源程序代码如下:注释详细package tetris;import java.awt.BorderLayout;import java.awt.Color;import java.awt.GridLayout;import java.awt.event.KeyEvent;import java.awt.event.KeyListener;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.JTextArea;import javax.swing.JTextField;public class Main extends JFrame implements KeyListener {private JTextArea[][] grids;// 把整个界⾯变为⼀个⽂本区域,整个游戏在⾥⾯进⾏private int data[][]; // 对于每个格⼦的数据,1代表有⽅块,0代表为空⽩区private int[] allRect; // 所有的⽅块类型,⽤16个字节来存储,俄罗斯⽅块图形都是在4*4格⼦⾥private int rect; // 当前游戏下落的⽅块类型;private int x, y; // 当前⽅块的坐标位置,x代表⾏,y代表列private int score = 0; // 记录当前游戏得分情况,每消⼀层得10分private JLabel label; // 显⽰分数的标签private JLabel label1;// 显⽰游戏是否结束private boolean running; // ⽤于判断游戏是否结束/*⽆参构造函数*/public Main() {grids = new JTextArea[26][12];//设置游戏区域⾏和列data = new int[26][12];//开辟data数组空间与游戏区域⾏和列⼀致allRect = new int[] { 0x00cc, 0x8888, 0x000f, 0x0c44, 0x002e, 0x088c, 0x00e8, 0x0c88, 0x00e2, 0x044c, 0x008e,0x08c4, 0x006c, 0x04c8, 0x00c6, 0x08c8, 0x004e, 0x04c4, 0x00e4 };//19种⽅块形状,如0x00cc就是 0000 表⽰⼀个2*2的正⽅形⽅块//0000//1100//1100label = new JLabel("score: 0"); //此标签存放得分情况,初始化为0分label1 = new JLabel("开始游戏"); //此标签为提⽰游戏状态:开始还是结束running = false; //为标志变量,false为游戏结束,true为游戏正在进⾏init(); // 游戏界⾯初始化}/*游戏界⾯初始化函数*/public void init() {JPanel center = new JPanel(); //此⾯板为游戏核⼼区域JPanel right = new JPanel(); //此⾯板为游戏说明区域center.setLayout(new GridLayout(26, 12, 1, 1)); //给游戏核⼼区域划分⾏、列共26⾏,12列for (int i = 0; i < grids.length; i++) {//初始化⾯板for (int j = 0; j < grids[i].length; j++) {grids[i][j] = new JTextArea(20, 20);grids[i][j].setBackground(Color.WHITE);grids[i][j].addKeyListener(this);// 添加键盘监听事件//初始化游戏边界if (j == 0 || j == grids[i].length - 1 || i == grids.length - 1) {grids[i][j].setBackground(Color.PINK);data[i][j] = 1;}grids[i][j].setEditable(false);// ⽂本区域不可编辑center.add(grids[i][j]); //把⽂本区域添加到主⾯板上}}//初始化游戏说明⾯板right.setLayout(new GridLayout(4, 1));right.add(new JLabel(" a : left d : right"));right.add(new JLabel(" s : down w : change"));right.add(label);label1.setForeground(Color.RED);// 设置标签内容为红⾊字体right.add(label1);//把主⾯板和说明⾯板添加到窗体中this.setLayout(new BorderLayout());this.add(center, BorderLayout.CENTER);this.add(right, BorderLayout.EAST);running = true; //初始化running状态为true,表⽰程序运⾏即游戏开始this.setSize(600, 850);// 设置窗体⼤⼩this.setVisible(true);// 窗体可见this.setLocationRelativeTo(null);// 设置窗体居中this.setResizable(false);// 窗体⼤⼩不可改变this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 释放窗体}/*主函数*/public static void main(String[] args) {Main m = new Main(); //创建Main对象,主要⽤于初始化数据m.go();// 开始游戏}/*开始游戏*/public void go() {// 开始游戏while (true) {//游戏开始直到游戏失败才结束,否则⼀直执⾏if (running == false) {//如果游戏失败break;}ranRect();// 绘制下落⽅格形状start();// 开始游戏}label1.setText("游戏结束!");//则游戏结束}/*绘制下落⽅格形状*/public void ranRect() {rect = allRect[(int) (Math.random() * 19)];// 随机⽣成⽅块类型(共7种,19个形状)}/*游戏开始函数*/public void start() {x = 0;y = 5; //初始化下落⽅块的位置for (int i = 0; i < 26; i++) {//共26层,⼀层⼀层下落try {Thread.sleep(1000);//每层延时1秒if (canFall(x, y) == false) {// 如果不可以掉落saveData(x, y);//把此⽅块区域data[][]标志为1,表⽰有数据for (int k = x; k < x + 4; k++) {//循环遍历4层,看是否有哪⼀层都有⽅块的情况,以便消除那⼀⾏⽅格和统计得分 int sum = 0;for (int j = 1; j <= 10; j++) {if (data[k][j] == 1) {sum++;}}if (sum == 10) {//如果k层都有⽅块,则消除k层⽅块removeRow(k);}}for (int j = 1; j <= 10; j++) {//游戏最上⾯的4层不能有⽅块,否则游戏失败 if (data[3][j] == 1) {running = false;break;}}break;}// 如果可以掉落x++;// 层加⼀fall(x, y);// 掉下来⼀层} catch (InterruptedException e) {e.printStackTrace();}}}/*判断正下落的⽅块是否可以下落*/public boolean canFall(int m, int n) {int temp = 0x8000;//表⽰1000 0000 0000 0000for (int i = 0; i < 4; i++) {//循环遍历16个⽅格(4*4)for (int j = 0; j < 4; j++) {if ((temp & rect) != 0) {// 此处有⽅块时if (data[m + 1][n] == 1)// 如果下⼀个地⽅有⽅块,则直接返回falsereturn false;}n++;//列加⼀temp >>= 1;}m++;// 下⼀⾏n = n - 4;// 回到⾸列}return true;//可以掉落返回true}/*把不可下降的⽅块的对应的data存储为1,表⽰此坐标有⽅块*/public void saveData(int m, int n) {int temp = 0x8000;//表⽰1000 0000 0000 0000for (int i = 0; i < 4; i++) {//循环遍历16个⽅格(4*4)for (int j = 0; j < 4; j++) {if ((temp & rect) != 0) {// 此处有⽅块时data[m][n] = 1;//data数组存放为1}n++;//下⼀列temp >>= 1;}m++;// 下⼀⾏n = n - 4;// 回到⾸列}}/*移除row⾏所有⽅块,以上的依次往下降*/public void removeRow(int row) {for (int i = row; i >= 1; i--) {for (int j = 1; j <= 10; j++) {data[i][j] = data[i - 1][j];//}}reflesh();// 刷新移除row⾏⽅块后的游戏主⾯板区域score += 10;// 分数加10;label.setText("score: " + score);//显⽰得分}/* 刷新移除row⾏⽅块后的游戏主⾯板区域*/public void reflesh() {for (int i = 1; i < 25; i++) {for (int j = 1; j < 11; j++) {if (data[i][j] == 1) {//有⽅块的地⽅把⽅块设置为绿⾊grids[i][j].setBackground(Color.GREEN);} else {//⽆⽅块的地⽅把⽅块设置为⽩⾊grids[i][j].setBackground(Color.WHITE);}}}}/*⽅块掉落⼀层*/public void fall(int m, int n) {if (m > 0)// ⽅块下落⼀层时clear(m - 1, n);// 清除上⼀层有颜⾊的⽅块draw(m, n);// 重新绘制⽅块图像}/*清除⽅块掉落之前有颜⾊的地⽅*/public void clear(int m, int n) {int temp = 0x8000;//表⽰1000 0000 0000 0000for (int i = 0; i < 4; i++) {//循环遍历16个⽅格(4*4)for (int j = 0; j < 4; j++) {if ((temp & rect) != 0) {// 此处有⽅块时grids[m][n].setBackground(Color.WHITE);//清除颜⾊,变为⽩⾊ }n++;//下⼀列temp >>= 1;}m++;//下⼀⾏n = n - 4;//回到⾸列}}/*绘制掉落后⽅块图像*/public void draw(int m, int n) {int temp = 0x8000;//表⽰1000 0000 0000 0000for (int i = 0; i < 4; i++) {//循环遍历16个⽅格(4*4)for (int j = 0; j < 4; j++) {if ((temp & rect) != 0) {// 此处有⽅块时grids[m][n].setBackground(Color.GREEN);//有⽅块的地⽅变为绿⾊ }n++;//下⼀列temp >>= 1;}m++;//下⼀⾏n = n - 4;//回到⾸列}}@Overridepublic void keyPressed(KeyEvent e) {}@Overridepublic void keyReleased(KeyEvent e) {}@Overridepublic void keyTyped(KeyEvent e) {if (e.getKeyChar() == 'a') {// ⽅格进⾏左移if (running == false) {return;}if (y <= 1)//碰到左边墙壁时return;int temp = 0x8000;//表⽰1000 0000 0000 0000for (int i = x; i < x + 4; i++) {//循环遍历16个⽅格(4*4)for (int j = y; j < y + 4; j++) {if ((rect & temp) != 0) {// 此处有⽅块时if (data[i][j - 1] == 1) {//如果左移⼀格有⽅块时return;}}temp >>= 1;}}clear(x, y);//可以进⾏左移操作时,清除左移前⽅块颜⾊y--;draw(x, y);//然后重新绘制左移后⽅块的图像}if (e.getKeyChar() == 'd') {//⽅块进⾏右移操作if (running == false) {return;}int temp = 0x8000;int m = x, n = y;int num = 7;for (int i = 0; i < 4; i++) {for (int j = 0; j < 4; j++) {if ((temp & rect) != 0) {if (n > num) {num = n;}}temp >>= 1;n++;}m++;n = n - 4;}if (num >= 10) {return;}temp = 0x8000;for (int i = x; i < x + 4; i++) {for (int j = y; j < y + 4; j++) {if ((rect & temp) != 0) {if (data[i][j + 1] == 1) {return;}}temp >>= 1;}}clear(x, y);//可以进⾏右移操作时,清除右移前⽅块颜⾊y++;draw(x, y);//然后重新绘制右移后⽅块的图像}if (e.getKeyChar() == 's') {//⽅块进⾏下移操作if (running == false) {return;}if (canFall(x, y) == false) {saveData(x, y);return;}clear(x, y);//可以进⾏下移操作时,清除下移前⽅块颜⾊x++;draw(x, y);//然后重新绘制下移后⽅块的图像}if (e.getKeyChar() == 'w') {//改变⽅块形状if (running == false) {return;}int i = 0;for (i = 0; i < allRect.length; i++) {//循环遍历19个⽅块形状if (allRect[i] == rect)//找到下落的⽅块对应的形状,然后进⾏形状改变 break;}if (i == 0)//为正⽅形⽅块⽆需形状改变,为⽅块图形种类1return;clear(x, y);if (i == 1 || i == 2) {//为⽅块图形种类2rect = allRect[i == 1 ? 2 : 1];if (y > 7)y = 7;}if (i >= 3 && i <= 6) {//为⽅块图形种类3rect = allRect[i + 1 > 6 ? 3 : i + 1];}if (i >= 7 && i <= 10) {//为⽅块图形种类4rect = allRect[i + 1 > 10 ? 7 : i + 1];}if (i == 11 || i == 12) {//为⽅块图形种类5rect = allRect[i == 11 ? 12 : 11];}if (i == 13 || i == 14) {//为⽅块图形种类6rect = allRect[i == 13 ? 14 : 13];}if (i >= 15 && i <= 18) {//为⽅块图形种类7rect = allRect[i + 1 > 18 ? 15 : i + 1];}draw(x, y);}}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
基于JAVA技术的俄罗斯方块游戏的设计与实现
目录摘要 (1)关键词 (1)1 前言 (1)2 需求分析 (2)2.1 系统开发环境 (2)2。
2 系统玩法及规则 (3)2。
3 系统设计分析 (4)2.4 注意事项 (5)3 概要设计 (5)3。
1 系统介绍 (5)3.2 系统简单设计 (6)3.3 系统功能设计 (6)3.4 系统流程 (8)4 系统详细设计 (9)4.1 设计游戏框架 (9)4.2 设计游戏界面 (12)4。
3 游戏内容设计 (13)4。
3.1 方块描述 (13)4。
3。
2 地图描述 (15)4.3。
3 地图方块阻碍描述 (16)4.3.4 满行判断及删除 (16)4。
3.5 线程控制的实现 (16)4。
3.6 控制游戏开始 (17)4.3。
7 控制游戏暂停 (17)4。
3。
8 控制游戏结束 (17)4.3.9 控制方块自动下降 (18)4。
3。
10 预备方块区的上移效果 (19)4.3。
11 键盘事件处理 (19)4。
4 游戏其它功能的实现 (19)4.4.1 添加状态栏 (19)4。
4。
2 添加关于对话框 (20)4.4.3 添加音响效果 (22)4.4.4 得分情况封装 (23)4。
4。
5 成绩的录入 (25)5 系统实现 (27)5.1 登入界面 (27)5。
2 游戏主界面 (28)5.3 游戏结束显示框 (29)5.4 成绩排行榜 (30)6 系统测试 (30)6.1 测试举例 (30)6.2 测试项目 (31)6.3 测试方法 (32)7 设计小结 (33)7。
1 出现的问题及解决方法 (33)7.2 游戏存在的不足 (35)7.3 结论 (35)参考文献 (36)致谢................................................ 错误!未定义书签。
附录 (38)基于JAVA技术的俄罗斯方块游戏的设计与实现摘要:俄罗斯方块是一款非常经典的游戏,曾经风靡全球,经久不衰,相信不少人都玩过,同时也是我们学习面向对象编程思想的理想实例。
Java俄罗斯方块
一、作品题目《趣味俄罗斯》二、实现功能1.键盘控制方块运动2.方块显示和隐藏3.碰撞检测4.分数的统计三、程序创新点及特点(突然自己的创新)1.色彩温和的搭配2.简单易懂的操作步骤3. 用了很多定义构造函数来节约代码四、设计思路(自己设计的过程)1.第一步就是认清自己需要做什么2.先定义方块的图形,和出现的方式(随机生成)3.设计游戏所会触发的所有事件(触碰边界,底部相同消除,按键盘↑→←→键产生的效果等)五、程序结构(文件名,方法等各部分完成什么功能)//创建图形的形状var over=false,shapes=("0,1,1,1,2,1,3,1; 1,0,1,1,1,2,2,2; 2,0,2,1,2,2,1,2; 0,1,1,1,1,2,2,2; 1,2,2,2,2,1,3,1;1,1,2,1,1,2,2,2;0,2,1,2,1,1,2,2").split(";");//创建图形的组合和属性function create(tag,css){var elm=document.createElement(tag);elm.className = css;document.body.appendChild(elm);return elm;}//定义下落的图形的事件function Tetris(appear, t, x, y){appear=appear?appear:"appear";//用div来创建一些小方块this.divs =[create("div",appear),create("div",appear),create("div",appear), create("div",appear)];this.reset = function(){//图形下落的初始位置this.x = typeof x != 'undefined'?x:4;this.y = typeof y != 'undefined'?y:1;//随机生成下落的图形this.shape =t?t:shapes[Math.floor(Math.random()*(shapes.length-0.00001) )].split(",");//this.show();if(this.field&&this.field.check(this.shape,this.x,this.y,'v')=='D'){over=true;this.field.fixShape(this.shape,this.x,this.y);alert('游戏结束,你得到:' +document.buzzy.txtScore.value + '分');}}//定义由方块组成的图形this.show = function(){for(var i in this.divs){this.divs[i].style.left =(this.shape[i*2]*1+this.x)*20+'px';this.divs[i].style.top =(this.shape[i*2+1]*1+this.y)*20+'px';}}this.field=null;//键盘方向键←→触发的事件this.hMove = function(step){var r = this.field.check(this.shape,this.x--step,this.y,'h');if(r!='N'&&r==0){this.x-=-step;this.show();}}//键盘方向键↓触发的事件this.vMove = function(){if(this.field.check(this.shape,this.x,this.y--1,'v')=='N'){this.y+=1;this.show();}else{this.field.fixShape(this.shape,this.x,this.y);this.field.findFull();this.reset();}}//键盘方向键↑触发的事件this.rotate = function(){var s=this.shape;varnewShape=[3-s[1],s[0],3-s[3],s[2],3-s[5],s[4],3-s[7],s[6]];var r =this.field.check(newShape,this.x,this.y,'h');if(r=='D')return;if(r==0){this.shape=newShape;this.show();}elseif(this.field.check(newShape,this.x-r,this.y,'h')==0){this.x-=r;this.shape=newShape;this.show();}};this.reset();}//背景的属性function Field(w,h){//底层12个方块可以占满this.width = w?w:12;//总高度为20个方块this.height = h?h:20;//背景的大小this.show = function(){var content = create("div","content")content.style.width=this.width*20+'px';content.style.height=372+'px';}//消除相同的底层的事件this.findFull = function(){for(var l=0;l<this.height;l++){var s=0;for(var i=0;i<this.width;i++){s+=this[l*this.width+i]?1:0;}//如果底层的相同,则消除,且分数增加1if(s==this.width){document.buzzy.txtScore.value = eval(document.buzzy.txtScore.value) + 1;this.removeLine(l);}}}//左右移动的事件this.removeLine = function(line){for(var i=0;i<this.width;i++){document.body.removeChild(this[line*this.width+i]);}for(var l=line;l>0;l--){for(i=0;i<this.width;i++){this[l*this.width- -i]=this[(l-1)*this.width- -i];if(this[l*this.width- -i])this[l*this.width- -i].style.top = l*20+'px';}}} //检查图形是否已经到边界this.check = function(shape, x, y, disappear){var r1=0,r2='N';for(var i=0;i<8;i+=2){if(shape[i]- -x < 0 && shape[i]- -x <r1){r1 = shape[i]- -x;}else if(shape[i]- -x>=this.width && shape[i]- -x>r1){r1 = shape[i]- -x;}if(shape[i+1]- -y>=this.height || this[shape[i]- -x- -(shape[i+1]- -y)*this.width]){r2='D';}}if(disappear=='h'&&r2=='N')return r1>0?r1-this.width- -1:r1;elsereturn r2;}//定义已经不能动的图形的事件this.fixShape = function(shape,x,y){var disappear=new Tetris("disappear",shape,x,y);disappear.show();for(var i=0;i<8;i+=2){this[shape[i]- -x- -(shape[i+1]--y)*this.width]=disappear.divs[i/2];}}}var content = new Field();content.show();var s = new Tetris();s.field = content;s.show();//方块下落速度0.5秒一个单位window.setInterval("if(!over)s.vMove();",500);//键盘触发事件document.onkeydown = function(e){e = window.event ? window.event : e;switch(e.keyCode){case 38: //按键盘↑s.rotate();break;case 40: //按键盘↓s.vMove();break;case 37: //按键盘←s.hMove(-1);break;case 39: //按键盘→s.hMove(1);break;}}六、运行方法和效果图(如果是网站指出首页名)。
俄罗斯方块Java程序设计
俄罗斯方块游戏一、课题内容和要求课题内容:俄罗斯方块游戏(Tetris)是一款经典单机游戏,早期常见于各个平台。
设计一个俄罗斯方块,玩家根据下落的不同方块形状,通过上、下、左、右四个键实现对方块的左右移动、旋转、下落等控制。
游戏中,一共有7种不同的方块形状、每种方块以1/7的概率随机出现,一旦方块到达顶部,游戏结束。
当某一个行布满方块时,改行消除。
基本要求:通过图形界面实现俄罗斯方块游戏;能以图形显示游戏运行的过程;实现相应四个键游戏玩家的控制;记录消除的行数。
扩展要求:在上述功能要求的基础上,为了提高成绩,可以添加一些额外的功能;变量、方法命名符合规范;注释详细:每个变量都要求有注释说明用途;函数有注释说明功能,对参数、返回值也要以注释的形式说明用途;关键的语句段要求有注释解释;程序的层次清晰,可读性强。
系统功能要求:(1)界面设定玩家可以在界面左侧的游戏区中堆积方块,游戏区上面有“游戏”“帮助”两个选项,界面右侧为游戏得分,玩家在游戏过程中随时可以查看游戏得分。
(2)游戏控制不同的随机图形会从区域上方缓慢落下,通过键盘的左、右、下键可以控制方块以一格为单位左右移动,长按实现快速移动;上键能以90度为单位旋转每一方块;区域中横向格子方块填满,则该行会自动消除并为玩家的得分;当固定的方块推到区域最上方,则游戏结束。
二、需求分析1.需求分析图-1 俄罗斯方块游戏需求分析2.任务及实现方式(1)绘制游戏区域通过绘制地图方块、已经固定的方块和运动中的方块来实现(2)实现键盘对方块的实时控制添加键盘监听者和方块位置移动的函数(3)记录消除行数添加记分函数和Graphics类的drawString函数实现(4)游戏结束添加判断游戏结束函数并给出提示3.预期效果(1)实现俄罗斯方块游戏的动态显示(2)实现键盘对方块各种操作(3)实现消行、记分(4)游戏能够正确结束三、概要设计1.主要功能流程图说明:游戏流程较为复杂,流程图粗略显示部分流程图-2 主要功能流程图2.主要类及类之间的关系的UML图图-3 Class Tetris图-4 Class Tetrisblok图-5 RelationShip 四、源程序代码import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyEvent;import java.awt.event.KeyListener;import javax.swing.*;import javax.swing.Timer;public class Tetris extends JFrame {public Tetris() {Tetrisblok a = new Tetrisblok();addKeyListener(a);add(a);}public static void main(String[] args) {Tetris frame = new Tetris();//菜单条JMenuBar menu = new JMenuBar();//添加菜单条frame.setJMenuBar(menu);//菜单JMenu game = new JMenu("游戏");//菜单项JMenuItem newgame = game.add("新游戏");JMenuItem pause = game.add("暂停");JMenuItem goon = game.add("继续");JMenuItem exit = game.add("退出");//菜单JMenu help = new JMenu("帮助");JMenuItem about = help.add("关于");//添加菜单至菜单条menu.add(game);menu.add(help);//对窗口设置//居中frame.setLocationRelativeTo(null);//关闭程序frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//大小frame.setSize(220, 275);//标题frame.setTitle("俄罗斯方块");//可见性frame.setVisible(true);//不可更改大小frame.setResizable(false);}}// 创建俄罗斯方块类class Tetrisblok extends JPanel implements KeyListener {// blockType 代表方块类型// turnState代表方块状态private int blockType;private int turnState;private int score = 0;private int x;private int y;private int i = 0;int j = 0;int flag = 0;// 定义已经放下的方块x=0-11,y=0-21;int[][] map = new int[13][23];// 7种方块类型,每一个方块有4种旋转状态,使用16位数字表示一种旋转状态private final int shapes[][][] = new int[][][] {// i{ { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },{ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 } },// s{ { 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },{ 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 } }, // z{ { 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 } }, // j{ { 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },{ 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, // o{ { 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, // l{ { 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },{ 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },{ 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, // t{ { 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },{ 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 } } };// 生成新方块的方法public void newblock() {blockType = (int) (Math.random() * 1000) % 7;turnState = (int) (Math.random() * 1000) % 4;x = 4;y = 0;if (gameover(x, y) == 1) {newmap();drawwall();score = 0;JOptionPane.showMessageDialog(null, "GAME OVER");}}// 初始化地图public void newmap() {for (i = 0; i < 12; i++) {for (j = 0; j < 22; j++) {map[i][j] = 0;}}}// 画围墙public void drawwall() {for (i = 0; i < 12; i++) {map[i][21] = 2;}for (j = 0; j < 22; j++) {map[11][j] = 2;map[0][j] = 2;}}// 初始化构造方法Tetrisblok() {newblock();newmap();drawwall();Timer timer = new Timer(1000, new TimerListener());timer.start();}// 旋转的方法public void turn() {int tempturnState = turnState;turnState = (turnState + 1) % 4;if (blow(x, y, blockType, turnState) == 1) {}if (blow(x, y, blockType, turnState) == 0) {turnState = tempturnState;}repaint();}// 左移的方法public void left() {if (blow(x - 1, y, blockType, turnState) == 1) {x = x - 1;};repaint();}// 右移的方法public void right() {if (blow(x + 1, y, blockType, turnState) == 1) {x = x + 1;};repaint();}// 下落的方法public void down() {if (blow(x, y + 1, blockType, turnState) == 1) {y = y + 1;delline();};if (blow(x, y + 1, blockType, turnState) == 0) {add(x, y, blockType, turnState);newblock();delline();};repaint();}// 是否合法的方法(是否碰到墙壁或者其他方块)public int blow(int x, int y, int blockType, int turnState) {for (int a = 0; a < 4; a++) {for (int b = 0; b < 4; b++) {if (((shapes[blockType][turnState][a * 4 + b] == 1) && (map[x+ b + 1][y + a] == 1))|| ((shapes[blockType][turnState][a * 4 + b] == 1) && (map[x+ b + 1][y + a] == 2))) {return 0;}}return 1;}// 消行的方法public void delline() {int c = 0;for (int b = 0; b < 22; b++) {for (int a = 0; a < 12; a++) {if (map[a][b] == 1) {c = c + 1;if (c == 10) {score += 10;for (int d = b; d > 0; d--) {for (int e = 0; e < 11; e++) {map[e][d] = map[e][d - 1];}}}}}c = 0;}}// 判断你挂的方法public int gameover(int x, int y) {if (blow(x, y, blockType, turnState) == 0) {return 1;}return 0;}// 把当前添加mappublic void add(int x, int y, int blockType, int turnState) {int j = 0;for (int a = 0; a < 4; a++) {for (int b = 0; b < 4; b++) {if (map[x + b + 1][y + a] == 0) {map[x + b + 1][y + a] = shapes[blockType][turnState][j];;j++;}}}// 画方块的的方法public void paintComponent(Graphics g) {super.paintComponent(g);// 画当前方块for (j = 0; j < 16; j++) {if (shapes[blockType][turnState][j] == 1) {g.fillRect((j % 4 + x + 1) * 10, (j / 4 + y) * 10, 10, 10);}}// 画已经固定的方块for (j = 0; j < 22; j++) {for (i = 0; i < 12; i++) {if (map[i][j] == 1) {g.fillRect(i * 10, j * 10, 10, 10);}if (map[i][j] == 2) {g.drawRect(i * 10, j * 10, 10, 10);}}}g.drawString("行数=" + score/10, 125, 10);g.drawString("*——*", 125, 50);g.drawString("加油", 125, 70);g.drawString("*——*", 125, 90);}// 键盘监听public void keyPressed(KeyEvent e) {switch (e.getKeyCode()) {case KeyEvent.VK_DOWN:down();break;case KeyEvent.VK_UP:turn();break;case KeyEvent.VK_RIGHT:right();break;case KeyEvent.VK_LEFT:left();break;}}// 无用public void keyReleased(KeyEvent e) {}// 无用public void keyTyped(KeyEvent e) {}// 定时器监听class TimerListener implements ActionListener {public void actionPerformed(ActionEvent e) {repaint();if (blow(x, y + 1, blockType, turnState) == 1) {y = y + 1;delline();};if (blow(x, y + 1, blockType, turnState) == 0) {if (flag == 1) {add(x, y, blockType, turnState);delline();newblock();flag = 0;}flag = 1;};}}}五、测试数据及其分析结果(1)游戏进行中图-6 游戏进行中(2)游戏消行图-7 游戏消行(3)游戏结束图-8 游戏结束(4)自然进行状态图-9 自然下落六、调试中出现的问题(1)方块移动超出了边界为程序添加判断移动是否合法函数(2)如何绘制方块查询资料了解到可以使用Graphics类的方法绘制(3)运行过程中,虽无报错,但在控制台闪烁“Exception in thread ‘AWT-EventQueue-0’ng.Error:Unresolved compilation :The type Tetrisblok must implement the inherited abstract method KeyListener.keyReleased(KeyEvent)”查询资料后添加public void keyReleased(KeyEvent e) 函数和public void keyTyped(KeyEvent e)解决七、课程设计总结对于我们来讲,此次程序设计课程是一个挑战,同时也是一个超越自我的过程。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
旋转
rotateRight(); 下标Index自增 rotateLeft(); 下标Index自减 State s = states[index%states.length]; 当前状态s为四格方块旋转[index%states.length] 次的状态. 以cells[0]为旋转轴,根据初始化的相对坐标 cells[1].setRow(cells[0]. getRow() + s.row1); cells[1].setCol(cells[0]. getCol() + s.col1); cells[2].setRow(cells[0]. getRow() + s.row2); cells[2].setCol(cells[0]. getCol() + s.col2); cells[3].setRow(cells[0]. getRow() + s.row3); cells[3].setCol(cells[0]. getCol() + s.col3);
程序启动方法(雷凯)
通过静态代码块将背景图片,7种方块图片和游戏结 束图片加载进来,这会节省很多时间. static{ Class cls = Tetris.class; background = ImageIO.read(cls.getResource(image)); //可以读取图片文件到内存中的对象 … … } 该静态代码块需捕捉异常(IOException)
左移、右移
moveLeftAction(); //左移 先调用tetromino.moveLeft(); 如果出界,或者重合再调用tetromino.moveRight(); 在moveLeft方法中遍历当前对象cells中所有cell对 象 循环调用cell.leftMove();
moveRightAction();
continueAction(); //继续游戏 pause = false; //设置暂停标记为false timer = new Timer(); //创建一个新的计时器对象 timer.schedule(new TimerTask(){ public void run() { softDropAction(); repaint(); } }, inteval, inteval); schedule(TimerTask task,long delay,long period) 安排指定的任务从指定的延迟后开始进行重复的固定延 迟执行 Inteval为间隔时间800ms;
游戏结束
当方框到达顶端时 (Wall[0][4]!=null) ,判定游戏结束。 按下“S”可重Βιβλιοθήκη 初 始化界面开始游戏具体实现
Cell(格子类) Tetromino(四格方块类) 7个子类(T,I,O,S,Z,J,L) 一个内部类(State): 存放四个方块旋转时的坐标状态。 Tetris(俄罗斯方块类) extends Jpanel 逻辑处理及方法的具体实现
action(); //启动软件 调用startAction()开始动作流程. 创建键盘按键监听对象new KeyAdapter(){ keyPressed(KeyEvent e); }; 如果有按键按下 完成时候(pressed)就会执行 VK_Q:quit(); //退出 VK_S:startAction(); //重新开始游戏 VK_C:continueAction(); //继续游戏 VK_P:pauseAction(); //暂停游戏 VK_DOWN:softDropAction(); //下落一格 VK_UP:rotateRightAction(); //旋转 VK_SPACE:hardDropAction(); //下落到底部 VK_LEFT moveLeftAction(); //左移一格 VK_RIGHT: moveRightAction();//右移一格
项目评审
俄罗斯方块
主讲人:雷凯 组员:沈唯唯,李有宁,田园 田亮,尹亮
界面展示
程序运行成功后, 进入游戏界面。 如左图所示。
游戏暂停
按下键盘按键“P” (pause)游戏进入 停止状态,等待用 户按下“C” (Continue)键继续 游戏。
退出游戏
按下键盘按键 “Q”(Quit)弹 出系统提示框 ,选择是否要 退出游戏。
绘图方法(尹亮)
paint(Graphics g); //重写绘图方法 g.drawImage(background, 0, 0, null); //画背景 g.translate(15, 15); //将图形上下文的原点平移到 当前坐标系中的点 (x, y) 绘制墙,四格方块,下一个方块,成绩,已消除行 数,暂停/继续提示 如果游戏结束标记为true,绘制游戏结束的图片 paintWall(Graphics g); //绘制墙 将长方形区域划分成20行,10列.遍历每个方块对 象,若cell不为空g.drawImage(cell.getImage(), x-1, y-1, null); 图像大小x-1,y-1是图形看起来顺眼.
判断方法,暂停、继续、退出(田园)
checkGameOver(); //检查游戏是否结束 如果wall[0][4] != null成立,调用 timer.cancle() 关闭计时器,游戏结束. outOfBounds(); //出界检查方法 Cell[] cells = tetromino.cells; 遍历当前四格方块对象的每个格子 如果(cell.getCol<0 || cell.getCol>=COLS || cell.getRow < 0 || cell.getRow >= ROWS)成 立(方块是否出了长方形界面),返回true;
states[0]
states[1]
states[2]
states[3]
以编号为“0”的格子为旋转轴,计算其他格子的相对坐标: states[0] = (0,0,0,-1,0,1,1,-1); states[1] = (0,0,-1,0,1,0,-1,-1); states[2] = (0,0,0,1,0,-1,-1,1); states[3] = (0,0,1,0,-1,0,1,1);
Tetris
paint(Graphics g); //重写绘图方法 paintWall(Graphics g); //绘制墙 action(); //通过调用该方法 启动软件 Quit(); //退出 pauseAction(); //暂停 continueAction(); //继续 paintTetromino(Graphics g); //绘制四格方块 paintNextOne(Graphics g); //绘制下一个方块 paintScore(Graphics g); //绘制成绩 paintLines(Graphics g); //绘制已消除行数 paintPause(Graphics g); //绘制暂/继续停提示
旋转,左移,右移(沈唯唯)
private int Index = 10000; 表示旋转状态下标.设置为10000防止旋转次数 过多而使游戏无法正常进行.
在Tetromino类中添加内部类State 属性:row0,col0,row1,col1,row2,col2,row3,col3 以上8个属性表示4个方块的相对坐标. 构造方法:public State(int row0…){…}
softDropAction(); //下落控制方法 canDrop(); //判断是否能够继续下落 landToWall(); //着陆到墙 destroyLines(); //销毁的行数 fullCells(int row); //判断一行是否满了 deleteLine(int row);//删除一行 checkGameOver(); //检查游戏结束状态 moveLeftAction(); //判断左移是否出界 moveRightAction(); //判断右移是否出界 rotateRightAction();//判断旋转是否出界 outOfBounds(); //检查是否出界 coincide(); //判断是否重合 hardDropAction(); //瞬间下降 startAction(); //开始动作流程
landToWall(); //着陆到墙 Cell[] cells = tetromino.cells; 遍历当前四格方块对象将每一个格子对象赋值给墙 wall[cell.getRow][cell.getCol] = cell destroyLines(); //销毁行数 遍历每行的格子,如果fullCells(row)(遍历当 前行的各自是否是满的)为true,调用 deleteLine(row)消除这行; lines++; 最后加成绩this.score += scoreTable[lines]; scoreTable[]为得分表
简单工厂模式实例化四格方块 T,I,O,S,Z,J,L(田亮)
将7个子类封装到类Tetromino,在构造方法里初始 化四格方块的初始位置(row,col)和相对位置.
以“L”型四格方块为例:
初始位置: cell[0] = (0,4); cell[1] = (0,3); cell[2] = (0,5); cell[3] = (1,3);
//右移的原理同上
下落(李有宁)
softDropAction(); //一步一步下落 if(canDrop())为true(检查当前方块是否能够 继续下落),则调用tetromino.softDrop();在 softDrop()中遍历cells对象调用cell.drop(); hardDropAction(); //瞬间下降 while(canDrop())为true(检查当前方块是否能 够继续下落),则调用tetromino.softDrop();在 softDrop()中遍历cells对象调用cell.drop(); 否则调用方法: landToWall(); // 着陆到墙 destroyLines(); // 销毁行数 checkGameOver(); // 检查游戏是否结束