Java俄罗斯方块思想与实现

本文中的代码只是部分代码,全部代码及用到的图片下载地址:链接: https://pan.baidu.com/s/1Ryvr0uxPVX22Ag3aVzGQKQ 密码: tm48

1、我们来分析一下游戏界面,从中能抽象出来:小方块类型,组合方块类型  

先来创建 Cell() 小方块类型,此类代表的时游戏中的最小单位(自身的属性有:row--行号 , col--列号 , image--图片)(行为方法有:left()--左移 , right()--右移 , drop()--下移),下面是具体代码:

 package com.tetris2;

import java.awt.image.BufferedImage;

public class Cell {
	
	/*
	 * 俄罗斯方块中最小单位
	 */
	private int row; //行号
	private int col; //列号
	private BufferedImage image;
	
	public Cell() {
		
	}
	//有参构造器,用来接收小方块的行列坐标和图片
	public Cell(int row, int col, BufferedImage image) {
		super();
		this.row = row;
		this.col = col;
		this.image = image;
	}
	
	public int getRow() {
		return row;
	}
	public void setRow(int row) {
		this.row = row;
	}
	public int getCol() {
		return col;
	}
	public void setCol(int col) {
		this.col = col;
	}
	public BufferedImage getImage() {
		return image;
	}
	public void setImage(BufferedImage image) {
		this.image = image;
	}
	@Override
	public String toString() {
		return "(" + row + ", " + col + ")";
	}
	//小方块向左移动
	public void left(){
		col--;
	}
	//小方块向右移动
	public void rigth(){
		col++;
	}
	//小方块向下移动
	public void drop(){
		row++;
	}
}

2、通过游戏中的7种不同的方块,可以抽象出它们的父类Tetromino(),这7中不同的方块有着共同的特征:都是由4个小方块Cell()组成的,都可以左/右/下移动并且旋转,代码如下:

package com.tetris2;

import java.util.Arrays;

public class Tetromino {
	//组合的方块都是有最小单位的4个方块组成的
	protected Cell[] cells = new Cell[4];
	
	public Cell[] getCells() {
		return cells;
	}
	public void setCells(Cell[] cells) {
		this.cells = cells;
	}
	//方块向左移动
	public void moveLeft(){
		for(Cell c:cells){
			c.left();
		}
	}
	//方块向右移动
	public void moveRigth(){
		for(Cell c:cells){
			c.rigth();
		}
	}
	//方块向下移动
	public void softDrop(){
		for(Cell c:cells){
			c.drop();
		}
	}
	@Override
	public String toString() {
		return "[" + Arrays.toString(cells) + "]";
	}
	
	/*
	 * 随机生成一个四个方块
	 */
	public static Tetromino randomOne(){
		Tetromino t = null;
		int num = (int)(Math.random()*7);//生成0~6随机数,来生成7种不同的随机方块
		switch (num) {
		case 0:t = new T();break;
		case 1:t = new Z();break;
		case 2:t = new O();break;
		case 3:t = new I();break;
		case 4:t = new J();break;
		case 5:t = new L();break;
		case 6:t = new S();break;
		
		}
		return t;
	}
}

3、让7中不同方块子类来继承父类Tetromino()7种方块都有着自己的坐标和图片,所以在写7种方的类时提供一个构造器用来进行初始化(7中不同方块初始位置可参考图Enter.PNG),下面代码只给出T的代码如下:

package com.tetris2;

public class T extends Tetromino {
	//T型位置
	public T() {
		cells[0] = new Cell(0,4,Tetris.T);
		cells[1] = new Cell(0,3,Tetris.T);
		cells[2] = new Cell(0,5,Tetris.T);
		cells[3] = new Cell(1,4,Tetris.T);
	}
}

4、还需要定义一个主类Tetris() 来传入方块的图片

    一、显示出一个窗口作为游戏的界面,要绘制出背景,及游戏区域的网格(程序完事后可注释掉)

public static void main(String[] args) {
		// 1:创建一个窗口对象
		JFrame frame = new JFrame("火拼俄罗斯");

		// 创建游戏界面,即面板
		Tetris panel = new Tetris();
		// 将面板嵌入窗口
		frame.add(panel);

		// 2:设置为可见
		frame.setVisible(true);
		// 3:设置窗口的尺寸
		frame.setSize(535, 580);
		// 4:设置窗口居中
		frame.setLocationRelativeTo(null);
		// 5:设置窗口关闭,即程序终止
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		// 游戏的主要逻辑封装在start方法中
		panel.start();

	}

            在创建窗口时要重写paint()方法来进行墙,方块的绘制

public void paint(Graphics g) {
		// 绘制背景
		/*
		 * g:画笔 g.drawImage(image,x,y,null) image:绘制的图片 x:开始绘制的横坐标 y:开始绘制的纵坐标
		 */
		g.drawImage(background, 0, 0, null);
		// 平移坐标轴
		g.translate(15, 15);
		// 绘制墙
		paintWall(g);
		// 绘制正在下落的四格方块
		paintCurrentOne(g);
		// 绘制下一个将要下落的四格方块
		paintNextOne(g);

		paintScore(g);
		paintState(g);
	}


    二、绘制出正在下落的方块和即将下落的方块(这两个方块时随机生成的),在绘制方块是方块的长款是相同的,这是

           就可以定义一个常量来存放方块的宽,因为每个大方块有4个小方块租场,所以要循环来确定每个小方块的初始下

           落坐标(每个大方块的初始下落的位置是不变的)。代码如下:

public void paintCurrentOne(Graphics g) {
		Cell[] cells = currentOne.cells;
		for (Cell c : cells) {
			int x = c.getCol() * CELL_SIZE;
			int y = c.getRow() * CELL_SIZE;
			g.drawImage(c.getImage(), x, y, null);
		}
	}
public void paintNextOne(Graphics g) {
		// 获取nextOne对象的四个元素
		Cell[] cells = nextOne.cells;
		for (Cell c : cells) {
			// 获取每一个元素的行号和列号
			int row = c.getRow();
			int col = c.getCol();
			// 横坐标和纵坐标
			int x = col * CELL_SIZE + 260;
			int y = row * CELL_SIZE + 26;
			g.drawImage(c.getImage(), x, y, null);
		}
	}


    三、让大方块开始下落,停止下落条件:大方块到达底部  或  大方块中任意一个小方块下面有小方块时,大方块停止下落,当大方块停止下落时,将大方块嵌入到墙中,在下落时,要进行进程休眠,这样才能看到下落过程。

          停止下落停止下落有两种状态:

                        1是方块到底后停止(判断大方块中的小方块有任意一个坐标到达底边界时,停止下落方块)

                        2是碰到其他方块(这个判断是要在下方已有下落到底的方块的前提下进行的,方块下落倒底后,

                                                    会嵌入到墙的二维数组中,之后在下落的方块只需判断在下落中的大方块下方的

                                                    墙的二维数组是否为空就行,不为空就无法在下落了)

                    代码如下:

while (true) {
			/**
			 * 当程序运行到此,会进入睡眠状态, 睡眠时间为300毫秒,单位为毫秒 300毫秒后,会自动执行后续代码
			 */
			try {
				Thread.sleep(800);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			if (game_state == PLAYING) {
				if (canDrop()) {
					currentOne.softDrop();
				} else {
					landToWall();
					destroyLine();
					// 将下一个下落的四格方块赋值给正在下落的变量
					if (!isGameOver()) {
						currentOne = nextOne;
						nextOne = Tetromino.randomOne();
					} else {
						game_state = GAMEOVER;
					}
				}
				repaint();
				/*
				 * 下落之后,要重新进行绘制,才会看到下落后的 位置 repaint方法 也是JPanel类中提供的 此方法中调用了paint方法
				 */
			}
		}

    四、开启键盘监听事件来控制方块的移动(下左右翻转都要判断停止下落)

        (1)向下:判断能否继续下落,调用下落方法,每次按键调用后都要重新绘制,以保证画面流畅

public void softDropAction() {
		if (canDrop()) {
			currentOne.softDrop();
		} else {
			landToWall();
			destroyLine();
			currentOne = nextOne;
			nextOne = Tetromino.randomOne();
		}
	}

        (2)向左:如果大方块不越界,或不与其它方块重合,就可向左移动(如果出现数组下标越界异常,可以先向左移,

                如果越界,再向右移回来)

protected void moveLeftAction() {
		currentOne.moveLeft();
		if (outOfBounds() || coincide()) {
			currentOne.moveRight();
		}
	}

       (3)向右:和向左原理相同但方向不同

       (4)旋转:方块旋转的方向是顺时针的,不同方块有着不同的旋转后的状态(T,L,J行方块有4种,I,S,

                        Z行方块有2种,O型方块有一种)因为大方块是由4格小方块组成,所以大方块旋转就是小方块

                        的位置发生变化,我们要定义一个类来存放大方块在旋转时,小方块的相对坐标位置,并且要在

                        每一个大方块类中写出不同状态下1-3号方块相对于0号方块的相对位置(每一个大方块都有4个小

                        方块,每个小方块都有行列坐标,所以要定义8个属性来存放小方格的坐标),想要确定当前大方

                        块的旋转位置,需要统计旋转按键的点击次数, 之后和4进行取余(因为大方块最多只有4种旋转状态)

                        旋转方块时是以其中的一个小方块为轴来进行旋转的,所以在旋转之前要确定轴的行号和列号

                        (1-3号小方块的坐标为行/列 + 相对坐标)

                    注:方块的相对坐标参考图“Enter.PNG”。参考代码:

public void rotateRight() {
		//旋转有一次,计算器增长1
		count++;//100001
		State s = states[count%states.length];
		//需要获取轴的行号和列号
		Cell c = cells[0];
		int row = c.getRow();
		int col = c.getCol();
		cells[1].setRow(row+s.row1);
		cells[1].setCol(col+s.col1);
		cells[2].setRow(row+s.row2);
		cells[2].setCol(col+s.col2);
		cells[3].setRow(row+s.row3);
		cells[3].setCol(col+s.col3);
		
		
		
	}
public class State{
		/**
		 * 设计八个属性,分别存储四格方块元素的相对
		 * 位置
		 */
		int row0,col0,row1,col1,row2,col2,row3,col3;
		public State() {}
		public State(int row0, int col0, int row1, int col1, int row2, int col2, int row3, int col3) {
			super();
			this.row0 = row0;
			this.col0 = col0;
			this.row1 = row1;
			this.col1 = col1;
			this.row2 = row2;
			this.col2 = col2;
			this.row3 = row3;
			this.col3 = col3;
		}
}

       (5)快速下落多次无休眠调用方块下移(要判断方块能否下落),当大方块不能下移时,将大方块嵌入到墙中.

            代码如下:

public void softDropAction() {
		if (canDrop()) {
			currentOne.softDrop();
		} else {
			landToWall();
			destroyLine();
			currentOne = nextOne;
			nextOne = Tetromino.randomOne();
		}
	}

       (6)满行消除下落

           方法1:

                           清空行:循环检查下落后的四格方块大行坐标,根据大方块下落停止后所在的位置的行号,

                                        还循环判断这个行号上对应的墙上的数组是否为空,如果为空,则表示次行未满,

                                        跳出循环判断下一行。

                           向下平移行:将清空后的行的上一行的空满状态赋值给清空的这一行,以此类推直到最上面一行,

                                         在清空行和向下平移行外面加一个row<20的循环,这样可以避免在清空行并且向下

                                        平移后行号改变,导致的原来行上已满但平移后原来已满的行的行号现在没有满,

                                        导致的不能被清空的现象。

            方法2:
            先进行判断行是否满了,满了后进行清空,并记住行号,之后再从小的行号开始向下平移。
            方法3:

            先找出大方块停止下落后中的小方块所在最小的行,以最小的行开始到最后一行结束为循环,

                            进行清空行和平移行操作;

            方法1代码:

public void destroyLine() {
		// 统计销毁行的行数
		int lines = 0;

		Cell[] cells = currentOne.cells;
		for (Cell c : cells) {
			int row = c.getRow();
			while (row < 20) {
				if (isFullLine(row)) {
					lines++;
					wall[row] = new Cell[10];
					for (int i = row; i > 0; i--) {
						System.arraycopy(wall[i - 1], 0, wall[i], 0, 10);
					}
					wall[0] = new Cell[10];
				}
				row++;
			}
		}
		// 从分数池中取出分数,加入总分数
		totalScore += scores_pool[lines];
		totalLine += lines;

	}
       (7)游戏状态:
                游戏状态有 结束(GAMEOVER = 2),暂停(PAUSE = 1),从新开始(PLAYING = 0)
                结束:

                      如果下一个大方块初始的位置的墙上不为空,游戏结束,显示结束画面;

                             (结束的判断要加在,自动下落,快速下落处)

                暂停:
                       在自动下落中添加一条判断游戏状态的if语句=1时游戏暂停(也就是不走下落的方法);
                重新开始:
                        游戏结束后显示结束界面,点击重新开始后,墙清空,下落开始


       (8)游戏计分/消行数:

                消除不同数量的行分数是不相同的;分数与消行数在从新开始后清0;



阅读更多
换一批

没有更多推荐了,返回首页