JAVA版俄罗斯方块学习

软件的开发过程

  1) 需求(软件功能的文字描述)
  2) 需求分析(找对象)
  3) 概要设计
    3.1) 数学模型
    3.2) 类的设计
  4) 详细功能的设计
    4.1) 数据初始化
    4.2) 界面绘制
    4.3) 左右移动功能设计
    4.4) 下落功能设计
    

1 明确业务需求
  用自然语言，将业务功能描述清楚
 
Tetris 专用词 俄罗斯方块
Tetromino 专用词 4格方块

俄罗斯方块的基本规则：
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 业务分析
  找到有哪些业务对象根据图片的分析
 
 窗口
  |-- tetris(俄罗斯方块) 矩形区域
        |-- score 累计分数
        |-- lines 销毁的行数
        |-- wall(墙 20行X10列)
        |    |-- 20row（行）
        |         |-- 10 col cell（列）
        |-- tetromino 正在下落的（4格方块，有7种形态）
        |      |-- 4 cell
        |-- nextOne 下一个准备下落的方块
               |-- 4 cell

3 数据模型, 一切业务对象转换为数字表示  
  场地按照行列划分为 20×10格子
   格子有属性row, col, color
   
4 类 设计
  Cell
   |-- int row
   |-- int col
   |-- image 贴图
 
  Tetromino
   |--Cell[] cells
               |-- Cell * 4
 
  Tetris 俄罗斯方块
   |-- Cell[][] wall = 20*10
   |-- Tetromino tetromino 正在下落的方块
   |-- Tetromino nextOne 下一个方块
   |-- int lines
   |-- int score
 
填写初始化代码(构造器)
  功能:
  toString()

绘制界面: 将对象的"数据"绘制到界面, 界面是数据的表现
  界面不是业务逻辑,
利用API实现界面的绘制工作!
 

5 算法设计，就是如何利用数据的计算实现软件的功能
 
 4格方块的初始形态：I S Z J L T O
  就在初始数据的数值状态设计
 
  四格方块的下落计算： 就是将每个格子的row+1
  就是将下落业务功能，转换为数字计算实现
 
 左右移动
 
 下落流程控制：方块下落与墙之间的控制关系
   1 合理的文字流程描述
   2 分析文字描述中的功能（动作）为方法
   3 用流程控制语句连接方法实现功能！
   4 严格测试结果！ TestCase
   
   1) 如果"能够下落", 就下落一步
   2) 否则就"着陆到墙里面"
   3) 着落以后, "销毁充满的行", 并且记分
   4) "检查游戏结束"了吗?
   5) 如果还能玩，就生成下一个方块
 
  下落流程：也是一个功能，要封装为一个方法
   A 返回值：是无返回值的方法，有输出，数据输出
     结果就是tetromino 和 wall
   B 方法名：softDropAction 软下落动作
   C 参数：无参数，实际的输入数据tetromino和wall
   D 过程：
   
 
 
   详细设计：
   A "能够下落" 设计为一个方法
         返回值(输出): boolean 返回true 表示能够下落
        方法名: canDrop  能够下落吗？
        参数(输入)：是墙和正在下落的方块
          可以不作为输入参数定义，因为是Tetris的实例变量
      如果将方法 canDrop 定义在 Tetris类中，就可以
      直接利用this获得实例变量，进而获得输入数据
        过程：
        如果4格方块的某个格子 的行坐标到达19就不能
        下落了
       如果4格方块的某个格子的下方墙上有方块，就不能
       下落了。
 
 左右移动流程控制
   是一个方法， 是一个功能
   方法名：moveRightAction 向右移动动作
  输入：tetromino 正在下落的方块
  输出：tetromino 正在下落的方块
  过程：如果正在下落的方块能够向右移动就移动一下
    否则就原地不动。如果没有超过边界或者没有压住
    另外一个方块，就可以移动。
    也就是：如果能够移动，输出的数据一定所有列+1
 
  算法：
   1) 先向右移动一次。
   2) 检查移动结果是否出界或重回(压住)
   3) 如果出界了或重回了就退回去（向左移动）
 
 

 分数计算

 界面的绘制
 
 键盘事件控制
 
 
 旋转流程控制
 
 加速下降流程控制
 
 记分
 
 开始流程控制（Timer）
  主刷新(Timer)频率: 1/100 秒
 0.5秒执行一次下落(是主刷新的50倍)
 
 利用定时器定时的调用 下落流程
 如果暂停时候, 就不执行下落流程来
 
 实现过程:
 1) 在Tetris类中添加属性 Timer, 用于启动主刷新频率
 2) 在Tetris类中添加属性 level 是下落的间隔次数
   如: 50 表示50次刷新以后,执行一次 下落, 如果减少,
   加快下落
 3)  在Tetris类中添加属性 stepIndex 是下落计数
  每当 stepIndex % level == 0 时候 执行一次 下落
 4) 在Tetris类中添加属性  pause 暂停执行状态控制
 5) 在action() 方法添加主刷新Timer的启动
   在主刷新中 添加代码 控制下落
   
 
 暂停流程控制
 设置暂停状态 true
 
 继续流程控制
 
 结束流程控制
 
 修改键盘事件
 
 修改paintScore方法
 
 
如何绘制背景图片
 1) 将图片素材文件复制到 com.tarena.tetris 包中
 2) 在Tetris类中声明静态变量 background
 3) 使用静态代码块 加载磁盘文件到内存对象
    将使用到 图片读取API: ImageIO
 4) 在paint 方法中绘制背景图片
 
 可能出现的错误:
 1) 文件名/包搞错了!
 
如何绘制 正在下落的方块
 1) 先在action方法中生产 正在下落的方块和下一个方块
 2) 在paint方法中调用 paintTetromino()方法
 3) 在Tetris类中 增加paintTetromino()方法
    将正在下落的4格方块的每个格子逐一绘制出来
 
如何使方块移动
 1) 处理键盘事件(API), 获得用户何时按下 ->  <-
 2) 当按下 -> 按键时候, 执行当前4格方块 向右移动 方法
 3) 向右移动 方法 会改变当前4格方块的每个格子的列坐标
 4) 调用继承于JPanel类的 repaint(), 这个方法会尽快的
  调用 paint()
 5) paint() 会根据当前数据(已经被右移动改变的数据)
  绘制全部面板效果

 6) 用户的感受就是, 方块动了.

Cell.java

package Tetris;

import java.awt.image.BufferedImage;
/**
 * 格子 
 */
public class Cell {
	private int row;
	private int col;
	private BufferedImage image;
	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;
	}
	public void drop(){
		row++;
	}
	public void moveLeft(){
		col--;
	}
	public void moveRight(){
		col++;
	}
}

Tetromino.java

Tetromino

package Tetris;
import java.util.Arrays;
import java.util.Random;

/**
 * 4格方块类 
 *
 */
public abstract class Tetromino {
	/** 4个格子，留给子类使用的属性 protected*/
	protected Cell[] cells = new Cell[4];
	/** 随机参数7种方块之一 */
	public static Tetromino randomOne(){
		Random random = new Random(); 
		int type = random.nextInt(7);
		switch (type) {
		case 0: return new T();
		case 1: return new S();
		case 2: return new Z();
		case 3: return new I();
		case 4: return new L();
		case 5: return new J();
		case 6: return new O();
		}
		return null;
	}
	public void softDrop(){
		for (int i = 0; i < cells.length; i++) {
			Cell cell = cells[i];
			cell.drop();
		}
	}
	public void moveLeft(){
		for (int i = 0; i < cells.length; i++) {
			Cell cell = cells[i];
			cell.moveLeft();
		}
	}
	public void moveRight(){
		for (int i = 0; i < cells.length; i++) {
			Cell cell = cells[i];
			cell.moveRight();
		}
	}
	@Override
	public String toString() {
		return Arrays.toString(cells);
	}
	/** 存储旋转状态的类，在Tetromino类中添加 */
	protected class State{
		int row0,col0,row1,col1,
		    row2,col2,row3,col3;
		public State(int row0, int col0, int row1, int col1, int row2,
				int col2, int row3, int col3) {
			this.row0=row0;this.col0=col0;
			this.row1 = row1;this.col1 = col1;
			this.row2 = row2;this.col2 = col2;
			this.row3 = row3;this.col3 = col3;
		}
	}
	//在Tetromino 类上添加向右转的方法
	private int index = 10000;
	//s0={row0,col0,row1,col1,row2,col2,row3,col3}
	protected State[] states;//在子类构造器中初始化 //{s0,s1,s2,s3};
	public void rotateRight() {
		//System.out.println(this);
		//输入1：cells 当前方块的数据
		//输入2：sN : s1 s2 s3 s0 s1 s2 s3 ...
		//输出 cells 旋转以后的方块数据
		//算法：cells[0]+sN -> cells
		//如何得到序列：1 2 3 0 1 2 3 0 1 2 3 0
		index ++;//10005
		//index%4 = ?;//1 2 3 0 1 2 3 0 
		//states[index%4]=?//s1 s2 s3 s0 s1 s2 s3...
		State s = states[index%states.length];
		//s = s1
		Cell o = cells[0];//找到轴 t0[0]
		int row = o.getRow();
		int col = o.getCol();
		cells[1].setRow(row + s.row1);//轴的row+s1[row1]=t1.row
		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);
		//System.out.println(this);
	}
	public void rotateLeft() {
		index --;//10005
		State s = states[index%states.length];
		Cell o = cells[0];//找到轴 t0[0]
		int row = o.getRow();
		int col = o.getCol();
		cells[1].setRow(row + s.row1);//轴的row+s1[row1]=t1.row
		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);
	}
}
/** T 型方块，包内类 */
class T extends Tetromino{
	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);
		//在子类中初始化旋转状态数据
		states = new State[]{
			new State(0,0, 0,-1, 0,1, 1,0), //s0
			new State(0,0, -1,0, 1,0, 0,-1),//s1
			new State(0,0, 0,1, 0,-1, -1,0),//s2
			new State(0,0, 1,0, -1,0, 0,1)//s3
		}; 
	}
}
class S extends Tetromino{
	public S() {
		cells[0] = new Cell(0,4,Tetris.S);
		cells[1] = new Cell(0,5,Tetris.S);
		cells[2] = new Cell(1,3,Tetris.S);
		cells[3] = new Cell(1,4,Tetris.S);
		//=====
		states = new State[] { 
				new State(0, 0, 0, 1, 1, -1, 1, 0),
				new State(0, 0, -1, 0, 1, 1, 0, 1)};
	}
}
class L extends Tetromino{
	public L() {
		cells[0] = new Cell(0,4,Tetris.L);
		cells[1] = new Cell(0,3,Tetris.L);
		cells[2] = new Cell(0,5,Tetris.L);
		cells[3] = new Cell(1,3,Tetris.L);
		//====
		states = new State[] { 
				new State(0, 0, 0, 1, 0, -1, -1, 1),
				new State(0, 0, 1, 0, -1, 0, 1, 1),
				new State(0, 0, 0, -1, 0, 1, 1, -1),
				new State(0, 0, -1, 0, 1, 0, -1, -1)};
	}
}
class J extends Tetromino{
	public J() {
		cells[0] = new Cell(0,4,Tetris.J);
		cells[1] = new Cell(0,3,Tetris.J);
		cells[2] = new Cell(0,5,Tetris.J);
		cells[3] = new Cell(1,5,Tetris.J);
		//===
		states = new State[] { 
				new State(0, 0, 0, 1, 0, -1, -1, -1),
				new State(0, 0, 1, 0, -1, 0, -1, 1),
				new State(0, 0, 0, -1, 0, 1, 1, 1),
				new State(0, 0, -1, 0, 1, 0, 1, -1)};
	}
}
class Z extends Tetromino{
	public Z() {
		cells[0] = new Cell(1,4,Tetris.Z);
		cells[1] = new Cell(1,5,Tetris.Z);
		cells[2] = new Cell(0,3,Tetris.Z);
		cells[3] = new Cell(0,4,Tetris.Z);
		//====
		states = new State[] { 
				new State(0, 0, -1, -1, -1, 0, 0, 1),
				new State(0, 0, -1, 1, 0, 1, 1, 0)};
	}
}
class O extends Tetromino{
	public O() {
		cells[0] = new Cell(0,4,Tetris.O);
		cells[1] = new Cell(0,5,Tetris.O);
		cells[2] = new Cell(1,4,Tetris.O);
		cells[3] = new Cell(1,5,Tetris.O);
		//===
		states = new State[] { new State(0, 0, 0, 1, 1, 0, 1, 1),
				new State(0, 0, 0, 1, 1, 0, 1, 1) };
	}
}
class I extends Tetromino{
	public I() {
		cells[0] = new Cell(0,4,Tetris.I);
		cells[1] = new Cell(0,3,Tetris.I);
		cells[2] = new Cell(0,5,Tetris.I);
		cells[3] = new Cell(0,6,Tetris.I);
		//===
		states = new State[] { 
				new State(0, 0, 0, -1, 0, 1, 0, 2),
				new State(0, 0, -1, 0, 1, 0, 2, 0)};
	}
}

package Tetris;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.Arrays;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * 俄罗斯方块
 *
 */
public class Tetris extends JPanel {
	/** 游戏的状态 */
	private int state;
	/** 游戏正在玩状态 */
	public static final int PLAYING = 0;
	/** 游戏暂停状态 */
	public static final int PAUSE = 1;
	/** 游戏结束状态 */
	public static final int GAME_OVER = 2;
	/** 游戏状态提示信息 */
	private static final String[] STATE=
	  {"[P]Pause", "[C]Continue", "[S]Restart"};
	/** 下落速度控制 */
	int index = 0;  
	/** speed 的值越小下落速度越快 */
	int speed = 8; 
	
	/** 分数 */
	private int score;
	/** 行数， 销毁的总行数 */
	private int lines;
	public static final int ROWS = 20;
	public static final int COLS = 10;
	/** 方块墙 */
	private Cell[][] wall=new Cell[ROWS][COLS];
	/** 正在下落的方块 */
	private Tetromino tetromino;
	/** 下一个方块 */
	private Tetromino nextOne;
	
	/** 在Tetris 中添加背景图属性 */
	private static BufferedImage background;
	public static BufferedImage gameOverImage;
	public static BufferedImage T;
	public static BufferedImage S;
	public static BufferedImage Z;
	public static BufferedImage J;
	public static BufferedImage L;
	public static BufferedImage I;
	public static BufferedImage O;
	
	/** 读取图片文件到内存对象 */
	//将图片复制到 com.tarena.tetris包中
	static {
		try{
			background=ImageIO.read(
				Tetris.class.getResource(
						"tetris.png"));
			gameOverImage=ImageIO.read(
					Tetris.class.getResource(
							"game-over.png"));
			T=ImageIO.read(Tetris.class
					.getResource("T.png"));
			S=ImageIO.read(Tetris.class
					.getResource("S.png"));
			Z=ImageIO.read(Tetris.class
					.getResource("Z.png"));
			J=ImageIO.read(Tetris.class
					.getResource("J.png"));
			L=ImageIO.read(Tetris.class
					.getResource("L.png"));
			O=ImageIO.read(Tetris.class
					.getResource("O.png"));
			I=ImageIO.read(Tetris.class
					.getResource("I.png"));
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	/** 利用重写方法修改父类JPanel */
	//paint:涂绘， Graphics：图，画笔
	public void paint(Graphics g){
		//draw: 绘
		g.drawImage(background, 0, 0, null);
		//g.drawString("Hello", 50, 50);
		g.translate(15, 15);
		paintWall(g);
		paintTetromino(g);
		paintNextOne(g);
		paintScore(g);//绘制分数
		g.translate(-15, -15);
		paintState(g);//绘制游戏状态
	}
	//绘制状态
	private void paintState(Graphics g) {
		//如果state是 0 显示 Pause 
		//如果state是 1 显示 Continue
		//如果state是 2 显示 Restart
		g.drawString(STATE[state], 309, 287);
		if(state == GAME_OVER){
			g.drawImage(gameOverImage,0,0,null);
		}
	}
	//绘制分数
	private void paintScore(Graphics g){
		int x = 293; 
		int y = 162;
		Font font = new Font(
				Font.SANS_SERIF, Font.BOLD, 30);
		g.setFont(font);
		g.setColor(new Color(0x667799)); 
		g.drawString("SCORE:"+score, x, y);
		y+=56;
		g.drawString("LINES:"+lines, x, y);
	}
	
	public void paintNextOne(Graphics g){
		Cell[] cells = nextOne.cells;
		for(int i=0;i=1; i--){
			System.arraycopy(wall[i-1], 0, 
					wall[i], 0, COLS);
		}
		Arrays.fill(wall[0], null);
	}
	/** 将方块着陆到墙上 */
	private void landIntoWall() {
		Cell[] cells = tetromino.cells;
		for(int i=0; i=ROWS) ||
					(col<0||col>=COLS)){
				return true;
			}
		}
		return false;
	}
	//检查当前下落的方块，是否与墙砖重合，true重合
	private boolean concide(){
		Cell[] cells = tetromino.cells;
		//for (int i = 0; i < cells.length; i++) {
		//	Cell cell = cells[i];
		for(Cell cell: cells){
			int row = cell.getRow();
			int col = cell.getCol();
			if(wall[row][col]!=null){
				return true;
			}
		}
		return false;
	}
	/** 在tetris 类中增加旋转流程控制方法 */
	public void rotateRightAction(){
		//rotate:原地转
		tetromino.rotateRight();
		if(outOfBounds() || concide()){
			tetromino.rotateLeft();
		}
	}
	public void rotateLeftAction(){
		//rotate:原地转
		tetromino.rotateLeft();
		if(outOfBounds() || concide()){
			tetromino.rotateRight();
		}
	}
	
	public static void main(String[] args) {
		//Frame 框，相框，代表窗口框 
		JFrame frame = new JFrame();
		//panel 代表面板
		Tetris panel = new Tetris();
		//Background 背景
		panel.setBackground(Color.YELLOW);
		//窗口中添加面板
		frame.add(panel);
		frame.setUndecorated(true);//去掉窗口边框
		frame.setSize(535, 580);
		//居中
		frame.setLocationRelativeTo(null);
		//点击X时候同时关闭程序
		frame.setDefaultCloseOperation(
				JFrame.EXIT_ON_CLOSE);
		//显示窗口框
		frame.setVisible(true);
		//尽快的调用 paint()方法绘制显示界面
		//显示窗口以后，执行 启动方法action
		panel.action();
	}
}