俄罗斯方块Java编写精髓
俄罗斯方块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)解决七、课程设计总结对于我们来讲,此次程序设计课程是一个挑战,同时也是一个超越自我的过程。
俄罗斯方块Java编写精髓(1)解读
旋转
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();
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 语言在俄罗斯方块游戏中的实现
浅析Java 语言在俄罗斯方块游戏中的实现作者:王立友来源:《发明与创新(职业教育)》 2019年第7期王立友(淮南联合大学,安徽淮南232001)摘要:《俄罗斯方块》作为一款益智类小游戏,一度风靡全球。
游戏操作简单灵活,趣味性强。
本文阐述了利用Java语言实现俄罗斯方块游戏的整个流程。
通过对游戏过程的分析,阐述《俄罗斯方块》实现过程中的架构设计和技术难点。
关键词:俄罗斯方块游戏;Java俄罗斯方块名字的来由源自于希腊语,含义为4,因为游戏中所有方块的设计均为四个方块的组合。
俄罗斯方块游戏是一款经久不衰的益智类小游戏[1],游戏规则简单明了,趣味性强。
对于 Java 编程爱好者而言,是一个不错的训练项目,难度适中,在游戏的开发设计过程中,不仅可以检验Java编程知识的综合运用,提升开发技能,同时还可以激发开发者的学习兴趣。
一、俄罗斯方块游戏总体设计(一)游戏功能模块系统构成游戏主要包括3个功能模块:方块控制功能、方块预览功能、游戏积分统计功能[2]。
1.方块控制功能:主要通过条件判断,来实现方块在下落的过程中向左移动、向右移动、方块旋转、方块触边、方块触块、方块触底及满行消除功能。
2.方块预览功能:当游戏界面出现一个游戏方块时,游戏方块预览区域中将随机生成下一个游戏方块,便于游戏玩家判断方块堆叠的走势,更好地布局方块的具体下落位置。
3.游戏积分统计功能:每消除一行得100分,如果一次消除两行则可以得100+200即300分,以此类推,当游戏分数累积到一定程度,系统游戏难度会增加,共有5个难度等级,难度系数1级最简单,5级最难。
当游戏失败时,记录当前分数与历史最高分相比较,如果超过历史最高分,则将当前分数记作历史最高分,并返回游戏初始界面。
(二)游戏运行流程游戏开始时,在控制面板顶部随机生成方块,方块自由下落,判断下落中是否到达顶部,如果到达顶部则表示游戏结束,否则判断是否到底或者是否碰到障碍物,如果没有碰到障碍物,方块继续下落,如果碰到障碍物,则停止下落,判断是否有满行,满行就消除并累加分数。
java课程设计——俄罗斯方块
一、程序功能介绍本程序实现了俄罗斯方块游戏的基本功能,游戏中玩家可以做的操作有:1.中间一个方块不变其他三个以90度为单位向右旋转方每一格块,此程序会判断方块有没有空间让他实现旋转,即判断是否越界,若越界则不可以实现旋转。
2.以格子为单位左右移动方块,下方向让方块加速落下,空格键则急速下落。
3.方块移到区域最下方或是着地到其他方块上无法移动时,就会固定在该处,而新的随机图形会出现在区域上方开始落下。
4.当区域中某一列横向格子全部由方块填满,则该列会自动消除并成为玩家的得分。
同时删除的列数越多,得分指数上升。
5.当固定的方块堆到区域最上方,则游戏结束。
(此功能尚未实现)6.此程序还不完善,开始,暂停,重来,结束都没有实现,有待改进。
二、课程设计过程1、总体概述:设计一个简单的游戏,能够将Java的面向对象程序思想应用到课程设计中,用到Java 中常用的组件以及相应的布局方式。
完成设计、编程、测试等过程,给出设计思路、设计说明书、主要的代码的说明、源代码以及可运行的游戏程序。
2、各个子类的定义:1.定义俄罗斯方块类,通过可视化界面设定一个游戏界面窗口,用一个10*20表示游戏区域。
public class TetrisGame extends JPanelJFrame jf=new JFrame("俄罗斯方块");jf.setSize(540,600);jf.setVisible(true);public static final int ROWS=20;public static final int COLS=10;2.定义7种俄罗斯方块的基本类型,分别以S、Z、L、J、I、O、T这7个字母的形状来命名。
先定义四方格主类:public class Tetromino;再定义它的7个子类:S、Z、L、J、I、O、Tprivate static class S extends Tetromino;private static class Z extends Tetromino;private static class L extends Tetromino;private static class J extends Tetromino;private static class I extends Tetromino;private static class O extends Tetromino;private static class T extends Tetromino;3.通过switch语句,随机输出方块到游戏区域顶部。
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的俄罗斯⽅块的设计和实现毕业论⽂本科⽣毕业论⽂(设计)基于Java的俄罗斯⽅块的设计与实现姓名学号专业指导教师2013年5⽉30⽇摘要俄罗斯⽅块作为⼀款风靡全球的多样化终端游戏,经久不衰。
俄罗斯⽅块简单的基本游戏规则是旋转、移动,游戏⾃动随机输出7种形状的⽅块,经旋转后可形成28种形状,⽅块堆叠在⼀起,排列成完整的⼀⾏或多⾏消除得分,积分达到⼀定程度会⾃动提升级别。
该游戏上⼿简单、⽼少皆宜、家喻户晓。
本论⽂在详尽分析传统俄罗斯实现的基本原理、基本规则基础上,更深⼀步地研究俄罗斯⽅块的创新模式,在经典模式基础上开发出等级可变的模式,以及进⼀步开发出颜⾊可变的模式,如随意改变界⾯的背景⾊、前景⾊等,本⽂对以上功能给出了实现流程、详尽描述、和部分源代码。
论⽂阐述了该游戏的历史、开发此游戏的意义和环境并根据软件⼯程的相关知识,进⾏系统的需求分析、概要设计、详细设计与实现、调试运⾏进⾏描述。
此设计是在Microsoft Windows XP系统下,以Java为开发语⾔,在MyEclipse开发平台上进⾏游戏的设计与实现。
关键词:游戏;俄罗斯⽅块;错误!未找到引⽤源。
软件⼯程;MyEclipse错误!未找到引⽤源。
AbstractTetris is a popular global diversification of terminal enduring game.Simple basic rules of the game is rotating, moving, automatic random output of 7 kinds of shape square game. It forms 28 kinds of shape, after rotating cube stacked together, forming complete one or more lines to eliminate score. Its level automatically rises with the score. The game is easy for young and old, has become a household name.This paper not only give the detailed analysis of the traditional Tetris which based on the basic principle and simple rules but also develop the color variable model, such as random change the background color and foreground color and so on. Further more, in this paper, the above functions are given the implementation process, the detailed description, and some source code.The paper expounds the history of the game, develops the meaning of the game and the environment of design. According to the relevant knowledge of software engineering, the author reports the demand analysis, outline design, detailed design, planning and execution of the test. This design is under Microsoft Windows XP system, based on Java development language, the MyEclipse development platforms to carry on the design and implementation of the game.Key Words: Game, Tetris, Software engineering, MyEclipse⽬录1 引⾔ (1)2 系统的需求分析 (2)2.1系统需求 (2)2.2接⼝控制 (3)3 系统的概要设计 (4)3.1软件运⾏和开发⼯具 (4)3.2系统功能设计 (4)3.2.1 ⼿⼯处理业务的基本流程 (4)3.2.2 基本流程的功能模块 (5)4 系统的详细设计与实现 (8)4.1游戏主界⾯显⽰模块 (8)4.2画布、⽅块显⽰模块 (9)4.2.1 背景画布模块设计 (10)4.2.2 预览⽅块模块设计 (11)4.2.3 ⽅块移动、旋转设计 (14)4.3控制⾯板模块 (18)4.3.1 菜单栏模块设计 (18)4.3.2 控制⾯板按钮设计 (20)5 系统的调试运⾏ (21)5.1测试的意义及注意事项 (21)5.2游戏代码、算法的测试 (21)5.3游戏界⾯菜单选项的功能测试 (22)5.4按键事件的功能测试 (24)5.5⽅块堆砌与消⾏测试 (25)5.6测试结果分析 (26)6 结论 (27)参考⽂献 (28)致谢 (29)1 引⾔俄罗斯⽅块的影响已⽏庸置疑, 当今世界的电脑、⼿机到处都有俄罗斯⽅块的踪迹,同时它更是每个游戏平台的必备游戏,相关的复制品不胜枚举。
俄罗斯方块Java编写精髓概要
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);
旋转,左移,右移(沈唯唯)
private int Index = 10000; 表示旋转状态下标.设置为10000防止旋转次数 过多而使游戏无法正常进行.
在Tetromino类中添加内部类State 属性:row0,col0,row1,col1,row2,col2,row3,col3 以上8个属性表示4个方块的相对坐标. 构造方法:public State(int row0…){…}
Cell
属性:row,col,Image 方法:drop(); // 向下降落一个单位 leftMove(); // 向左移动一个单位 rightMove(); // 向右移动一个单位
Tetromino
Cell[] cells = new Cell[4]; State[] states; Index; Protected class State {} ; 7个子类7种方块 rotateRight(); rotateLeft(); softDrop(); moveLeft(); moveRight(); RandomOne();
softDropAction(); //下落控制方法 canDrop(); //判断是否能够继续下落 landToWall(); //着陆到墙 destroyLines(); //销毁的行数 fullCells(int row); //判断一行是否满了 deleteLine(int row);//删除一行 checkGameOver(); //检查游戏结束状态 moveLeftAction(); //判断左移是否出界 moveRightAction(); //判断右移是否出界 rotateRightAction();//判断旋转是否出界 outOfBounds(); //检查是否出界 coincide(); //判断是否重合 hardDropAction(); //瞬间下降 startAction(); //开始动作流程
俄罗斯方块java代码
俄罗斯方块java代码俄罗斯方块是最经典的休闲益智游戏之一,现在很多人都不玩了,这里就来写一篇俄罗斯方块的Java代码。
首先,需要说明的是,Java代码中有两个类,一个是主类(Tetris.java),一个是方块类(Block.java)。
主类包含的功能是:显示游戏画面、游戏的主逻辑、处理键盘事件、以及控制游戏暂停、游戏结束等;方块类包含的功能是:初始化方块颜色、坐标、方向等,旋转方块。
那么我们来分析一下主类(Tetris.java)的代码。
首先是一些变量的定义:游戏区域的宽度和高度static final int Width = 10;static final int Height = 22;方块的颜色static Color blocksColor[] = {new Color(255, 255, 255), new Color(204, 102, 102),new Color(102, 204, 102), new Color(102, 102, 204),new Color(204, 204, 102), new Color(204, 102, 204),new Color(102, 204, 204), new Color(218, 170, 0) };游戏区域static int[][] wall = new int[Width][Height];当前方块static Block curBlock;下一个方块static Block nextBlock;游戏是否结束static boolean isOver;线程static MyThread t;接下来是一些初始化操作:初始化主窗体public Tetris() {initFrame();initUI();initGame();}初始化游戏界面private void initUI() {设置游戏面板和游戏区域pnlGame = new JPanel();pnlGame.setPreferredSize(new Dimension(blockSize * Width, blockSize * Height));pnlGame.setBorder(BorderFactory.createLineBorder(Color.gray));gameArea = new GameArea();pnlGame.add(gameArea);设置下一个方块显示面板和下一个方块区域pnlNextBlock = new JPanel();pnlNextBlock.setPreferredSize(new Dimension(blockSize * 4, blockSize * 4));pnlNextBlock.setBorder(BorderFactory.createTitledBorder("Next Block"));nextBlockArea = new BlockArea();pnlNextBlock.add(nextBlockArea);将游戏界面和下一个方块界面加入主窗体frmMain.getContentPane().add(pnlGame, BorderLayout.WEST);frmMain.getContentPane().add(pnlNextBlock, BorderLayout.EAST);显示窗体frmMain.pack();frmMain.setVisible(true);}初始化游戏private void initGame() {初始化积分、速度score = 0;speed = 1;初始化游戏区域for (int i = 0; i < Width; i++) {for (int j = 0; j < Height; j++) {wall[i][j] = 0;}}旋转T型方块,初始朝向为横向curBlock = new Block(1, 0);生成下一块方块nextBlock = new Block(0, 0);}我们可以看到,主类(Tetris.java)包含以下方法:1. initFrame()方法,用来初始化主窗体。
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编写俄罗斯方块方案和源码
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())如果(检查)能够下落就下落,否则就着陆到墙上,而新的方块出现在区域上方开始落下。
基于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技术的俄罗斯方块游戏的设计与实现摘要:俄罗斯方块是一款非常经典的游戏,曾经风靡全球,经久不衰,相信不少人都玩过,同时也是我们学习面向对象编程思想的理想实例。
《俄罗斯方块》程序编写超详细解释
Tc2.0 编写俄罗斯方块游戏很多编程爱好者都编写过俄罗斯方块的游戏程序。
很久以前,我用Tc2.0也做过一个;最近有好些朋友看见我以前的俄罗斯方块的程序后,问我是怎么做的。
我一直想把这个程序的整个过程写一份详细的东西,与各位编程爱好者分享,一直没空。
正好现在放假了,而且离回家还有几天。
于是我就把这个程序重新写了一遍,尽量使程序的结构比较清晰好懂一些。
同时写了下面的这份东西。
俄罗斯方块游戏的程序中用到了一些方法。
为了比较容易理解这些方法,我在讲述的同时写了些专门针对这些方法的示例程序。
这些示例程序力求短小,目的是用最小的代码能够清楚的示例所用的方法。
这些示例程序都经过tc2.0测试。
最后还附了完整的俄罗斯方块游戏的源代码,和最终的可执行程序。
如果你看了这份东东,有什么意见和想法,请发电子邮件告诉我。
我将会继续更新这分东东,最新的版本可以在我的个人主页上下载。
下面的问题是有关俄罗斯方块程序的,其中有些是朋友问我的,有些是我认为可能会被问到的。
我尽量按问题从易到难排列这些问题。
关于俄罗斯方块程序的一些问题:******************************************************Tc2.0中怎么样设置图形显示?Tc2.0中常用图形函数的用法?怎样获取鍵盘输入?怎样控制方块的移动?怎样控制时间间隔(用于游戏中控制形状的下落)?游戏中的各种形状及整个游戏空间怎么用数据表示?游戏中怎么判断左右及向下移动的可能性?游戏中怎么判断某一形状旋转的可能性?按向下方向键时加速某一形状下落速度的处理?怎么判断某一形状已经到底?怎么判断某一已经被填满?怎么消去已经被填满的一行?怎么消去某一形状落到底后能够消去的所有的行?(如长条最多可以消去四行)怎样修改游戏板的状态?怎样统计分数?怎样处理升级后的加速问题?怎样判断游戏结束?关于计分板设计的问题。
关于“下一个”形状取法的问题。
剩下的问题。
基于java的俄罗斯方块的设计与实现
摘要随着社会日新月异的变化和互联网的飞速发展,计算机已经普及到人们的日常生活中,网络也成为人们生活中的重要组成部分。
好的游戏能够给人们的生活带来健康愉快的补充,唯美的艺术享受,一定的教育功效。
俄罗斯方块游戏作为一款风靡全球的最经典的益智休闲游戏之一,已经成为老幼皆宜的小游戏。
对一般用户来说,它的规则简单,容易上手,但游戏过程却变化无穷。
本游戏的设计综合了单机版与双人对战版两种模式,用户可任选一种进行游戏。
与通常俄罗斯方块游戏的不同之处在于:在消除满行方块时,方块的颜色会发生变化,以此来提示用户。
另外,本游戏还增加了背景音乐和音效的播放功能。
单机版中增加了排行榜的功能,游戏结束时,用户可通过对话框输入自己的姓名并存储到排行榜数据表中,如果进入前50名,即可在排行榜上看到自己的游戏记录。
双人对战版,实现了人和人之间的对战,提高了游戏的互动性和娱乐性。
既能使用户享受到游戏中的乐趣,又能为用户提供一个展现高超技艺的场所。
本游戏是采用java的GUI ( 图形用户界面) 组件创建的,强调人—机—环境三者作为一个系统进行总体设计。
使操作更人性化,减轻了用户的认知负担,使其更适合用户的操作需求。
关键词俄罗斯方块;单机版;双人对战版;图形用户界面AbstractWith the rapid change of society and the development of Internet, the computer has already been run through in ours daily life, and the network also becomes one important part of people's life. The good game could bring the supplement with health and happy, exquisite enjoy of art, certain efficiency of education to people's life. Tetris, as one of the most classical games, which is illuminating and relaxing, is populared with all over the world, has became a little game that is suit both the young and the old. To general users, its rule is simple, easy to grasp, but the process of the game is changing infinitely. The design of this game includes two kinds of modes, both single - player games and double battles version, users can choose any of the game. The difference with common Tetris lies in: While eliminating the fully squares, the color of the square will change, so as to hint users. In addition, the broadcast function of the background music and sound are added in this game. The function of billboard also added into the single - player games, while game is over, users can input their own names through dialog box and store their scores in the table of billboard, if one enters the top of 50, he could see his own record of the game on the billboard. The function of interpersonal fighting is implemented in double battles version, which improves the interactional and recreational of the game. This game can not only makes user to enjoy fun in the game, but also can offer a place to represent superb skill to user. The component of GUI (Graphical User Interface) of Java is adopted in this game, it takes people - the machine - environmental as a system so as to design, that makes the operation of the system more humaniztion, the cognizant of burden of the users is lightened.And this of course makes it even more suitable for the demand of users'.KEY WORD Tetris; Single-player game; Double-players games; Graphical User Interface目录第一章绪言 (1)第一节选题背景及意义 (1)第二节选题目的 (1)第三节研究内容 (1)第二章可行性研究 (5)第一节引言 (5)第二节技术可行性 (5)第三节经济可行性 (5)第四节操作可行性 (5)第五节法律可行性 (6)第六节结论 (6)第三章需求分析 (6)第一节引言 (6)第二节开发意图 (6)第三节游戏功能分析 (7)第四节游戏的UML基本模型 (9)第四章总体设计 (15)第一节总体设计概述 (15)第二节总体设计思想 (15)第三节系统的类图 (16)第四节游戏的组件图 (19)第五节游戏的配置图 (19)第六节面向连接的Socket的通信机制 (19)第七节数据库设计 (20)第八节游戏的总体流程图 (21)第五章详细设计与实现 (22)第一节详细设计概述 (22)第二节游戏主界面设计与实现 (22)第三节俄罗斯方格类的设计与实现 (23)第四节游戏块的设计与实现 (24)第五节游戏控制的设计与实现 (25)第六节单机版俄罗斯方块游戏的设计与实现 (26)第七节双人对战俄罗斯方块游戏的设计与实现 (29)结束语33谢辞 36参考文献 (37)第一章绪言第一节选题背景及意义游戏软件是一种与文化背景密切联系的产品,具有很强的民族性和丰富的文化内涵。
基于java的俄罗斯方块的设计与实现
河北农业大学本科毕业论文题目:基于Java的俄罗斯方块的设计与实现摘要俄罗斯方块作为一款风靡全球的多样化终端游戏,经久不衰。
俄罗斯方块简单的基本游戏规则是旋转、移动,游戏自动随机输出7种形状的方块,经旋转后可形成28种形状,方块堆叠在一起,排列成完整的一行或多行消除得分,积分达到一定程度会自动提升级别。
该游戏上手简单、老少皆宜、家喻户晓。
本论文在详尽分析传统俄罗斯实现的基本原理、基本规则基础上,更深一步地研究俄罗斯方块的创新模式,在经典模式基础上开发出等级可变的模式,本文对以上功能给出了实现流程、详尽描述、和部分源代码。
程序是在Microsoft Windows 7系统下,以Java 为开发语言,在MyEclipse开发平台上进行游戏的设计与实现。
关键词:游戏;软件工程;MyEclipseAbstractTetris is a popular global diversification terminal game, enduring. The basic rules of the game Tetris simple is rotating, moving, the game automatically random output 7 shape box, the rotation can be formed after the 28 square shape, stacked together, arranged to complete one or more rows to eliminate the score, the integral to a certain extent will automatically upgrade the level of. The game started simple, suitable for all ages, make known to every family.In this paper a detailed analysis of the basic rules of traditional Russian basic principle, on the basis of the realization of innovation mode, further study of Tetris, developed a class variable model in the classical model, the above function gives the implementation process, detailed description, and part of the source code.This design is in the Microsoft Windows 7 system, taking Java as the development language, for game design and Implementation on MyEclipse platform.Keywords: Game; software engineering; MyEclipse目录1 绪论 (1)1.1 俄罗斯方块游戏的背景 (1)1.2俄罗斯方块游戏的规则 (1)1.3研究俄罗斯方块游戏的意义 (1)1.4 论文组织 (2)2 相关技术分析 (3)2.1 JAVA语言概述 (3)2.2 Eclipse简介 (4)3 需求分析 (6)3.1 系统需求 (6)3.2 接口控制 (6)4 系统设计 (7)4.1 软件运行和开发工具 (7)4.2 系统功能设计 (7)4.2.1 手工处理业务的基本流程 (7)4.2.2 基本流程的功能模块 (9)5 系统实现 (11)5.1 游戏主界面显示模块 (11)5.2 画布、方块显示模块 (12)5.2.1 背景画布模块设计 (12)5.2.2 预览方块模块设计 (14)5.2.3方块移动、旋转设计 (16)5.3 控制面板模块 (20)5.3.1菜单栏模块设计 (20)5.3.2控制面板按钮设计 (22)6 总结 (23)参考文献 (24)致谢 (25)1 绪论1.1 俄罗斯方块游戏的背景俄罗斯方块是俄罗斯人阿列克谢•帕基特诺夫(Alexey Pazhitnov)发明。
用Java写俄罗斯方块
键盘响应事件控制类/**-* File:ControPanel* Author:* Date:2011-90-12* Describe:键盘响应事件控制类*/package src;import javax.swing.*;import java.awt.*;import java.awt.event.*;public class ControlPanel extends JPanel {// 游戏的按钮控制键的监听器public ControlPanel(ErsBlockElement block){this .block =block;addKeyListener(new ControlKeyListener());}private ErsBlockElement block;//键盘响应事件//方向键上和shift键为方块变形,方向键左为左移,方向键右为右移,方向键下为加速向下private class ControlKeyListener extends KeyAdapter {public void keyPressed(KeyEvent ke) {switch (ke.getKeyCode()) {case KeyEvent.VK_DOWN:block.moveDown();break;case KeyEvent.VK_LEFT:block.moveLeft();break;case KeyEvent.VK_RIGHT:block.moveRight();break;case KeyEvent.VK_UP:block.turnAround();break;case KeyEvent.VK_SHIFT:block.turnAround();break;default:break;}}}}方块类/**-* File:ErsBlockElement* Author:* Date:2011-90-12* Describe:方块类*/package src;import javax.swing.*;import javax.swing.Timer;import javax.swing.border.Border;import javax.swing.border.EtchedBorder;import java.awt.*;import java.awt.event.*;import java.util.*;public class ErsBlockElement implements Runnable {//4x4矩阵在主容器中的坐标private int X=4;private int Y=0;//难度等级public int lvl = 1;//分数public int score = 0;//STYLES矩阵中方格图案坐标private int currentBlock=(int) (Math.random()*7);private int currentAngle=(int) (Math.random()*4);//随机产生新方块的坐标public int a=(int) (Math.random()*7);public int b=(int) (Math.random()*4);//定义一个布尔类型的变量,捕捉游戏是否开始private boolean play = true;//用一个2维数组装到底的方块坐标private byte[][] bt = new byte[18][12];//判断游戏是否结束private boolean gameover = false;//定时器Timer timer;//公布方块类坐标public int[] getAxis(){int[] Axis={X,Y,currentBlock,currentAngle};return Axis;}//事件发布者,获取订阅者信息private Collection listeners;public void addPaintListener(PaintListener listener){if (listeners == null){listeners = new HashSet();}listeners.add(listener);}//事件发布者激活事件,通知所有订阅者private void notifyListenters(Object object){Iterator iter=listeners.iterator();while(iter.hasNext()){PaintListener listener=(PaintListener)iter.next();listener.paintEvent(object);}}//方块下落线程public void run(){timer = new Timer(500, new ActionListener(){public void actionPerformed(ActionEvent ae){if(play){moveDown();}}});timer.start();//启动定时器}//下落public void moveDown(){if(gameover){gameover=!gameover;return;}if(IsMovable(X,Y+1)){Y++;notifyListenters(this);}else{int key = 0X8000;for(int i=0;i<4;i++){for(int j=0;j<4;j++){if((key & STYLES[currentBlock][currentAngle])!=0){bt[Y+i][X+j] = 1;}key>>=1;}}Isrowfull();newBlock();Gameover();}}//左移public void moveLeft(){if(IsMovable(X-1,Y)){X--;notifyListenters(this);}}//右移public void moveRight(){if(IsMovable(X+1,Y)){X++;notifyListenters(this);}}//暂停public void movePlay(){play = !play;}//翻转public void turnAround(){if(IsTurn((currentAngle+1)%4)){currentAngle = (currentAngle+1)%4;notifyListenters(this);}}//判断是否可以移动private boolean IsMovable(int x,int y){int key = 0X8000;for(int i=0;i<4;i++){for(int j=0;j<4;j++){if((key & STYLES[currentBlock][currentAngle])!=0){if(y+i>17||x+j<0||x+j>11){return false;}if(bt[y+i][x+j]==1){return false;}}key>>=1;}}return true;}//判断是否可以翻转private boolean IsTurn(int currentAngle){int key = 0X8000;for(int i=0;i<4;i++){for(int j=0;j<4;j++){if((key & STYLES[currentBlock][currentAngle])!=0){if(Y+i>17||X+j<0||X+j>11){return false;}}key>>=1;}}return true;}// 随机产生新的方块public void newBlock(){Y = 0;X = 4;currentBlock = a;currentAngle = b;a=(int) (Math.random()*7);b=(int) (Math.random()*4);notifyListenters(this);}//存储坐标,返回bt的值public byte[][] Getbt(){return bt;}//消去整行public void Isrowfull(){boolean flag = true;for(int i=0;i<bt.length;i++){flag = true;for(int j=0;j<bt[i].length;j++){if(bt[i][j]==0){flag = false;break;}}if(flag){for(int k=i;k>0;k--){for(int l=0;l<bt[k].length;l++){bt[k][l]=bt[k-1][l];}}//每消去一行,加100分score += 100;Getlvl();i = 0;}}}//游戏结束public void Gameover(){for(int j=0;j<bt[0].length;j++){if(bt[0][j]==1){gameover = true;JOptionPane.showMessageDialog(null, "GAMEOVER!","提示",RMA TION_MESSAGE);for(int i=0;i<18;i++){for(int k=0;k<12;k++){bt[i][k] = 0;}}break;}}}//根据分数增加难度private int c=500;public void Getlvl(){if(score%2000==0){lvl += 1;c=c-50;timer.stop();timer = new Timer(c, new ActionListener(){public void actionPerformed(ActionEvent ae){if(play&&!gameover){moveDown();}}});timer.start();//启动定时器}}public final static int[][] STYLES = {// 共28种状态{0x0f00, 0x4444, 0x0f00, 0x4444}, // 长条型的四种状态{0x04e0, 0x0464, 0x00e4, 0x04c4}, // 'T'型的四种状态{0x4620, 0x6c00, 0x4620, 0x6c00}, // 反'Z'型的四种状态{0x2640, 0xc600, 0x2640, 0xc600}, // 'Z'型的四种状态{0x6220, 0x1700, 0x2230, 0x0740}, // '7'型的四种状态{0x6440, 0x0e20, 0x44c0, 0x8e00}, // 反'7'型的四种状态{0x0660, 0x0660, 0x0660, 0x0660}, // 方块的四种状态};}主容器类/**-* File:ErsBlockTest* Author:* Date:2011-90-12* Describe:主容器类*/package src;import javax.swing.*;import java.awt.*;import java.awt.event.*;public class ErsBlockTest extends JFrame implements PaintListener {//布局主容器//顶部5个按钮实现操作功能private JButtonbtOne = new JButton("left"),btTwo = new JButton("right"),btThree = new JButton("down"),btFour = new JButton("pause"),btTurn = new JButton("turn");private JPanel main = new JPanel();private JPanel jpanel=new JPanel();// 4个按钮private JButtonbtStart = new JButton("开始"),btPause = new JButton("暂停"),btTurnLevelUp = new JButton("增加难度"),btTurnLevelDown = new JButton("降低难度");private JLabel lbnum= new JLabel("分数:0000");private JLabel lblvl = new JLabel("难度:1");private JLabel lbnext = new JLabel("下一个方块");private JPanel top = new JPanel();private JPanel center = new JPanel();private JPanel down = new JPanel();private JPanel east = new JPanel();// 声明并实例化方块类private ErsBlockElement ersBlockElement = new ErsBlockElement(); private ControlPanel con = new ControlPanel(ersBlockElement);private byte[][] bt = new byte[18][12];//设置容器大小为18X12的空间JButton button[][]=new JButton[18][12];//声明右边小方块的空间JButton btn[][] = new JButton[4][4];JPanel boxPanel=new JPanel(new GridLayout(18, 12));private void setTopButton(){//定义控件的响应事件btOne.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent ae) {ersBlockElement.moveLeft();con.requestFocus();}});btTwo.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent ae) {ersBlockElement.moveRight();con.requestFocus();}});btThree.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent ae) {ersBlockElement.moveDown();con.requestFocus();}});btFour.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent ae) {ersBlockElement.movePlay();con.requestFocus();}});btTurn.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent ae) {ersBlockElement.turnAround();con.requestFocus();}});jpanel.setLayout(new FlowLayout());jpanel.add(btOne);jpanel.add(btTwo);jpanel.add(btThree);jpanel.add(btFour);jpanel.add(btTurn);}//定义按钮private void setButtomButton(){for(int i=0;i<18;i++){for(int j=0;j<12;j++){button[i][j]=new JButton();boxPanel.add(button[i][j]);}}}//定义按钮的颜色变化private void setButtonBackgroud(){for(int i=0;i<button.length;i++){for(int j=0;j<button[i].length;j++){if(bt[i][j]==1){button[i][j].setBackground(Color.red);}else{button[i][j].setBackground(Color.black);}}}}public static void main(String[] args){ErsBlockTest ebt=new ErsBlockTest();}public ErsBlockTest(){super("俄罗斯方块");top.setLayout(new GridLayout(4,4));for(int i=0;i<4;i++){for(int j=0;j<4;j++){btn[i][j] = new JButton("\n");top.add(btn[i][j]);}}center.add(lbnum);down.add(lblvl);east.setLayout(new BorderLayout());east.add(top,BorderLayout.NORTH);east.add(center,BorderLayout.CENTER);east.add(down,BorderLayout.SOUTH);main.setLayout(new BorderLayout());setTopButton();setButtomButton();main.add(jpanel,BorderLayout.NORTH);main.add(boxPanel,BorderLayout.CENTER);main.add(east,BorderLayout.EAST);setSize(500,600);setLocation(200,120);setVisible(true);add(con);add(main);con.requestFocus();//订阅方块类发出的绘制事件ersBlockElement.addPaintListener(this);//启动方块类线程,即方块开始下落Thread thread = new Thread(ersBlockElement);thread.start();addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}});}public final static int[][] STYLES = {// 共28种状态{0x0f00, 0x4444, 0x0f00, 0x4444}, // 长条型的四种状态{0x04e0, 0x0464, 0x00e4, 0x04c4}, // 'T'型的四种状态{0x4620, 0x6c00, 0x4620, 0x6c00}, // 反'Z'型的四种状态{0x2640, 0xc600, 0x2640, 0xc600}, // 'Z'型的四种状态{0x6220, 0x1700, 0x2230, 0x0740}, // '7'型的四种状态{0x6440, 0x0e20, 0x44c0, 0x8e00}, // 反'7'型的四种状态{0x0660, 0x0660, 0x0660, 0x0660}, // 方块的四种状态};//方块类事件处理程序,在主容器中绘制图案public void paintEvent(Object object) {ErsBlockElement block=(ErsBlockElement)object;int[] axis=block.getAxis();this.bt = block.Getbt();boolean flag = true;setButtonBackgroud();//消去一行增加100分,修改分数lbnum.setText("分数:"+block.score);//得到难度等级lblvl.setText("难度:"+block.lvl);//得到方块坐标后在主容器中绘制图案int key = 0X8000;for(int i=0;i<4;i++){for(int j=0;j<4;j++){if((key & STYLES[axis[2]][axis[3]])!=0){flag = false;button[axis[1]+i][axis[0]+j].setBackground(Color.red);}key>>=1;}}//显示下一个小方块的绘制图案key = 0X8000;for(int i=0;i<4;i++){for(int j=0;j<4;j++){if((key & STYLES[block.a][block.b])!=0){btn[i][j].setBackground(Color.red);}else{btn[i][j].setBackground(Color.black);}key>>=1;}}if(flag){block.timer.stop();block.newBlock();block.timer.start();}repaint();}}接口类/**-* File:PaintListener* Author:* Date:2011-90-12* Describe:接口类*/package src;public interface PaintListener {public void paintEvent(Object object); }。
Java俄罗斯方块游戏的设计_java课设_含可运行程序
沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学}3设计结果与分析本游戏的操作简单,用户启动游戏后,即进入游戏,屏幕开始显示为欢迎画面。
用户选择[开始游戏],就可以开始玩游戏了,当用户想暂停时,再次按一下[stop]按钮,游戏就暂停了,在暂停的情况下再按[go on]按钮,游戏继续运行。
任何时候按[exit]按钮,游戏都会终止。
用户可以选择[lv up]或[lv down]。
在dos下运行游戏,结果如图所示图(4)进入游戏右边信息窗体的布局分别包括开始游戏、提高级数、降低级数、退出游戏5个按钮,使用者可以根据自己的需求选择不同的按钮。
游戏画布类:小方块边长:final int 0unitSize = 30正方格的行数:int rowNum方格的列数:int columnNum允许有多少行未削:int maxAllowRowNum新出现块的起始行坐标:int blockInitRow出现块的起始列坐标:int blockInitCol屏幕数组:int [][] scrArr沈阳大学游戏界面如图所示,方块自由下落,用户可以进行操作。
图5 开始游戏如果方块填满一行时,此行方块便可以消失,此时分数则加100,函数如下所示:void refresh(){//判断如果满行则消去此行,for (int i = 0; i<18;i++){if (isFullLine(i)){refresh(i);}}}boolean isFullLine(int m){//消行的具体方法,清空此行沈阳大学for (int i = 0; i<12; i++){if (map[i][m] == 0){return false;}}return true;}void refresh(int m){ShowScore+=100;//若满一行则加一百分,并将小方块下移一行for (int i = m; i>0; i--){for (int j = 0; j<12; j++){map [j][i] = map [j][i-1];}}显示分数如图所示图6得分后沈阳大学当方块占用首行时,系统认定游戏结束,你已经失败了,并显示所得分数图(7)游戏结束沈阳大学图(8)显示所得分数当游戏结束时,点击菜单选项,可以选择[新游戏]或者[退出游戏]、沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学沈阳大学。
基于Java的俄罗斯方块游戏的设计与实现
论文总结与致谢 Chapter
从本次课程设 计论文编写我 收获的知识
为了熟悉俄罗斯方块的相关功能和设计,我时常从各大 游戏下载网站下载单机版俄罗斯方块游戏,并研究其中 功能的实现和界面的设计,思考和查阅资料进行分析, 经过逐步的设计与反复的修改论证,才完成了整个游戏 的开发。 在游戏设计过程中,我采用从粗到精的设计模式,从小 到大测试的原则。先设计游戏框架,并逐层测试,而后 再添加具体实现代码并逐步进行更细化的测试。设计过 程中,经常会遇到难题,我会通过反复思考和测试,然后 找出自己的错误并加以改正,再进行下一个步骤,确保 万无一失,尽力减轻最后的调试工作量。
需求分析 之功能性需求
界面需求
本游戏的默认背景色是深 绿色,游戏主界面画面自 定义为自己的所喜欢的图 片,并可以更改,主界面 方块默认用橘黄色,预显 方块颜色默认为淡紫色。 以达到让玩家眼前一亮的 感觉。
形状需求
用数组作为存储方块52种 状态的数据结构,即初级 等级长条形、Z字形、反Z 形、田字形、7字形、反7 形、T字型一共7种形状的 向4个方向的旋转变形, 种不同的状态,高级等级 的三种方块12种不同的状
方块和数据信息是游戏中最基本的功能模块。本游戏用二维数组存储方块的28种 样式。值得注意的是:在传统的俄罗斯方块游戏的基础上,本游戏系统为了体现出创 新的思维,本着为了学习的原则,在传统游戏的基础上增加了中级三种其他的方块样 式和高级三种其他的方块样式。一共有52种方块样式,具体的存储方式主要实现代码
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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);
旋转
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);
softDropAction(); //下落控制方法 canDrop(); //判断是否能够继续下落 landToWall(); //着陆到墙 destroyLines(); //销毁的行数 fullCells(int row); //判断一行是否满了 deleteLine(int row);//删除一行 checkGameOver(); //检查游戏结束状态 moveLeftAction(); //判断左移是否出界 moveRightAction(); //判断右移是否出界 rotateRightAction();//判断旋转是否出界 outOfBounds(); //检查是否出界 coincide(); //判断是否重合 hardDropAction(); //瞬间下降 startAction(); //开始动作流程
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();//右移一格
coincide() //判断重合方法 Cell[] cells = tetromino.cells; 遍历当前四格方块对象的每个格子 如果(cell.getCol >= 0 && cell.getCol < COLS &&cell.getRow >= 0 && cell.getRow < ROWS&& wall[cell.getRow][cell.getCol]!=null)成立(在 长方形界面内部检查是否撞到其他方块),返回true. pauseAction(); //暂停游戏 timer.cancel(); //终止该计时器 pause = true; //将暂停标记设置为true
游戏结束
当方框到达顶端时 (Wall[0][4]!=null) ,判定游戏结束。 按下“S”可重新初 始化界面开始游戏
具体实现
Cell(格子类) Tetromino(四格方块类) 7个子类(T,I,O,S,Z,J,L) 一个内部类(State): 存放四个方块旋转时的坐标状态。 Tetris(俄罗斯方块类) extends Jpanel 逻辑处理及方法的具体实现
简单工厂模式实例化四格方块 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);
旋转,左移,右移(沈唯唯)
private int Index = 10000; 表示旋转状态下标.设置为10000防止旋转次数 过多而使游戏无法正常进行.
在Tetromino类中添加内部类State 属性:row0,col0,row1,col1,row2,col2,row3,col3 以上8个属性表示4个方块的相对坐标. 构造方法:public State(int row0„){„}
判断方法,暂停、继续、退出(田园)
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;
绘图方法(尹亮)
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是图形看起来顺眼.
landToWall(); //着陆到墙 Cell[] cells = tetromino.cells; 遍历当前四格方块对象将每一个格子对象赋值给墙 wall[cell.getRow][cell.getCol] = cell destroyLines(); //销毁行数 遍历每行的格子,如果fullCells(row)(遍历当 前行的各自是否是满的)为true,调用 deleteLine(row)消除这行; lines++; 最后加成绩this.score += scoreTable[lines]; scoreTable[]为得分表
左移、右移
moveLeftAction(); //左移 先调用tetromino.moveLeft(); 如果出界,或者重合再调用tetromino.moveRight(); 在moveLeft方法中遍历当前对象cells中所有cell对 象 循环调用cell.leftMove();
moveRightAction();
paintTetromino(Graphics g); //绘制四格方块 如果没有正在下落的方块就不绘制,否则遍历四格 方块对象的四个小格子并绘制. paintNextOne(Graphics g); //绘制下一个方块 如果没有正在下落的方块,就不绘制,否则遍历随 机生成的下一个四格方块的四个小格子并绘制. paintScore(Graphics g); //绘制成绩 paintLines(Graphics g); //绘制已消除行数 paintPause(Graphics g); //绘制暂停/继续提示 以上3个方法均是先设置字体格式,颜色,位置再 绘制.
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); //绘制暂/继续停提示
项目评审
俄罗斯方块
主讲人:雷凯 组员:沈唯唯,李有宁,田园 田亮,尹亮
界面展示
程序运行成功后, 进入游戏界面。 如左图所示。
游戏暂停
按下键盘按键“P” (pause)游戏进入 停止状态,等待用 户按下“C” (Continue)键继续 游戏。
退出游戏
按下键盘按键 “Q”(Quit)弹 出系统提示框 ,选择是否要 退出游戏。
//右移的原理同上
下落(李有宁)
softDropAction(); //一步一步下落 if(canDrop())为true(检查当前方块是否能够 继续下落),则调用tetromino.softDrop();在 softDrop()中遍历cells对象调用cell.drop(); hardDropAction(); //瞬间下降 while(canDrop())为true(检查当前方块是否能 够继续下落),则调用tetromino.softDrop();在 softDrop()中遍历cells对象调用cell.drop(); 否则调用方法: landToWall(); // 着陆到墙 destroyLines(); // 销毁行数 checkGameOver(); // 检查游on(); //继续游戏 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;