Java | Tetris

基于 Java-Swing 实现俄罗斯方块

Preview

普通模式：

加速模式：

设计思路

方块的属性

• 方块表示：
  • 由四维数组 SHAPE[][][][] 表示7种方块及每种方块的4种翻转状态。
  • 由SHAPE[type][state]可以唯一标识一个方块。
• 方块属性：
  • type：方块类型
  • state：方块翻转状态
  • (x, y)：方块坐标
  • nextType：下一方块类型
  • nextState：下一方块翻转状态
• 背景块：由map[ROW][COl]表示已固定的背景块。

方块的行为

方块翻转：通过改变方块的state属性实现翻转

public void turn() {
  	int temp = state;
  	state = (state + 1) % 4;
  	// 如果旋转后不合法，还原上一状态
  	if (!check(type, state, x, y)) {
  		state = temp;
  	}
}

方块下落：通过改变方块纵坐标实现下落

public void down() {
    // 如果下一个下落状态合法，则下落；不合法，则固定，清行，新建块。
  	if (check(type, state, x, y + 1)) {
  		y++;
  	} else {
  		fix(type, state, x, y);
  		clearLines();
  		createShape();
  	}
  	this.repaint();
}

方块左移：通过改变方块横坐标实现左移

public void left() {
  	if (check(type, state, x - 1, y)) {
  		x--;
  	}
}

方块右移：通过改变方块横坐标实现右移

public void right() {
	if (check(type, state, x + 1, y)) {
  		x++;
  	}
}

核心方法实现

方块碰撞检测：

private boolean check(int type, int state, int x, int y) {
	for (int i = 0; i < SHAPE[type][state].length; i++) {
		for (int j = 0; j < SHAPE[type][state][0].length; j++) {
			if (SHAPE[type][state][i][j] == 1) {
				// 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
				if ((x + j >= COL) || (x + j < 0) || (y + i >= ROW) || (map[y + i][x + j] == 1)) {
					return false;
				}
			}
		}
	}
	return true;
}

固定当前方块到背景中：

private void fix(int type, int state, int x, int y) {
	for (int i = 0; i < SHAPE[type][state].length; i++) {
		for (int j = 0; j < SHAPE[type][state][0].length; j++) {
			// 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
			if ((y + i < ROW) && (x + j >= 0) && (x + j < COL) && (map[y + i][x + j] == 0)) {
				map[y + i][x + j] = SHAPE[type][state][i][j];
				mapColor[y + i][x + j] = color[type];
			}
		}
	}
}

清行加分：

private void clearLines() {
	int lines = 0;
	boolean isFull = true;
	for (int i = 0; i < map.length; i++) {
		isFull = true;
		for (int j = 0; j < map[0].length; j++) {
			if (map[i][j] == 0) {
				isFull = false;
				break;
			}
		}
		if (isFull) {
			lines++;
			for (int m = i; m > 0; m--) {
				for (int n = 0; n < map[0].length; n++) {
					map[m][n] = map[m - 1][n];
				}
			}
		}
	}
	score += lines * lines * 10;
	if (isAccelMode) {
		up();
	}
}

GUI

绘制图形：重写paint()方法，使用Graphics类随意绘制。

Graphics类绘制方法如下：

setColor(Color color);  // 设置画笔颜色
drawRect(int x,int y,int width,int height);  // 绘制矩形边框
fillRect(int x,int y,int width,int height);  // 填充矩形
fill3DRect(int x,int y,int width,int height, boolean raised); // 填充3D矩形。
drawLine(x1,y1,x2,y2);  // 绘制线条
setFont(Font font); // 设置字体
drawString(String text, int x, int y);  // 绘制字符串

文件目录

com.lizich.tetris下：

.
|——TetrisMain  # 游戏窗口，由此运行
|——TetrisCtrl  # 绘制游戏面板&游戏逻辑

com.lizi.tetris.singleclass下：

.
|——Tetris # 合并了TetrisMain与TetrisCtrl

源码

TetrisMain

package com.liziczh.tetris;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;

public class TetrisMain extends JFrame {

	/**
	 * 版本号
	 */
	private static final long serialVersionUID = 1L;
	// 游戏面板
	private TetrisCtrl tCtrl = new TetrisCtrl();

	/**
	 * 游戏窗口初始化
	 */
	public TetrisMain() {
		// 设置标题
		this.setTitle("Lizi Tetris");
		// 设置大小
		this.setSize(tCtrl.getSize());
		// 调用方法居中
		this.setLocationRelativeTo(null);
		// 设置关闭操作：关闭窗口，程序结束运行；
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// 设置窗体大小不改变
		this.setResizable(false);
		// 添加键盘监听事件
		this.addKeyListener(keyListener);

		// 菜单栏
		JMenuBar menu = new JMenuBar();
		this.setJMenuBar(menu);
		JMenu gameMenu = new JMenu("游戏");
		JMenuItem newGameItem = gameMenu.add("新游戏");
		newGameItem.addActionListener(newGameAction);
		JMenuItem pauseItem = gameMenu.add("暂停");
		pauseItem.addActionListener(pauseAction);
		JMenuItem continueItem = gameMenu.add("继续");
		continueItem.addActionListener(continueAction);
		JMenuItem exitItem = gameMenu.add("退出");
		exitItem.addActionListener(exitAction);
		JMenu modeMenu = new JMenu("模式");
		JMenuItem normalModeItem = modeMenu.add("普通模式");
		normalModeItem.addActionListener(normalModeAction);
		JMenuItem accelModeItem = modeMenu.add("加速模式");
		accelModeItem.addActionListener(accelModeAction);
		JMenu helpMenu = new JMenu("帮助");
		JMenuItem aboutItem = helpMenu.add("关于");
		aboutItem.addActionListener(aboutAction);
		menu.add(gameMenu);
		menu.add(modeMenu);
		menu.add(helpMenu);
		// 设置窗口可见
		this.setVisible(true);
		// 添加TetrisPanel
		this.add(tCtrl);

	}

	// 键盘事件监听
	KeyListener keyListener = new KeyAdapter() {

		@Override
		public void keyPressed(KeyEvent e) {
			switch (e.getKeyCode()) {
			case KeyEvent.VK_UP:
				// ↑：旋转
				tCtrl.turn();
				tCtrl.repaint();
				break;
			case KeyEvent.VK_LEFT:
				// ←：左移
				tCtrl.left();
				tCtrl.repaint();
				break;
			case KeyEvent.VK_RIGHT:
				// →：右移
				tCtrl.right();
				tCtrl.repaint();
				break;
			case KeyEvent.VK_DOWN:
				// ↓：下移
				tCtrl.down();
				tCtrl.repaint();
				break;
			}
		}
	};

	// 新游戏
	ActionListener newGameAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent arg0) {
			tCtrl.init();
		}
	};
	// 暂停
	ActionListener pauseAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent arg0) {
			tCtrl.setPause();
		}
	};
	// 继续
	ActionListener continueAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent e) {
			tCtrl.setContinue();
		}
	};

	// 退出
	ActionListener exitAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent e) {
			System.exit(0);
		}
	};

	// 普通模式
	ActionListener normalModeAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent e) {
			tCtrl.setNormal();
		}
	};

	// 加速模式
	ActionListener accelModeAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent e) {
			tCtrl.setAccel();
		}
	};

	// 关于
	ActionListener aboutAction = new ActionListener() {

		@Override
		public void actionPerformed(ActionEvent e) {
			JOptionPane.showMessageDialog(tCtrl, "Tetris v1.0 from liziczh", "关于", getDefaultCloseOperation());
		}
	};

	public static void main(String[] args) {
		new TetrisMain();
	}

}

TetrisCtrl：

package com.liziczh.tetris;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

public class TetrisCtrl extends JPanel {

	/**
	 * 版本号
	 */
	private static final long serialVersionUID = 1L;

	// 方块边长，单位像素(px)
	public final int LEN = 24;

	// Panel区域：20行10列
	public final int ROW = 20;
	public final int COL = 10;

	/**
	 * SHAPE[type][state]：方块形状； type方块类型， state方块旋转状态；
	 */
	private final int[][][][] SHAPE = new int[][][][] {
			// 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 } } },
			// 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 } } },
			// 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 } } },
			// I:
			{ { { 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 } },
					{ { 0, 0, 0, 0 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } },
			// O:
			{ { { 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, 1, 1, 0 }, { 0, 1, 1, 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 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } },
					{ { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } },
					{ { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } } },

	};

	// 当前方块的四个参数：type方块类型，state方块旋转状态，坐标(x,y)。
	private int type, state, x, y;
	// 下一个块的参数：nextType方块类型，nextState方块旋转状态
	private int nextType, nextState;

	// 背景：已固定块
	private int[][] map = new int[ROW][COL];
	// 已固定块的颜色
	private Color[][] mapColor = new Color[ROW][COL];

	// 得分
	private int score = 0;
	// 等级
	private int level = 0;
	// 下落延时
	private int delay = 1000;

	// 是否在暂停状态
	private boolean isPause = false;

	// 是否为加速模式
	private boolean isAccelMode = false;

	// 方块颜色：color[type]
	private Color[] color = new Color[] { Color.green, Color.red, Color.orange, Color.blue, Color.cyan, Color.yellow,
			Color.magenta, Color.gray };

	public TetrisCtrl() {
		// 初始化Panel大小
		this.setSize(LEN * 20, LEN * 25);
		this.init();
	}

	/**
	 * 游戏初始化
	 */
	public void init() {
		// 初始化背景map
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[0].length; j++) {
				map[i][j] = 0;
			}
		}
		// 初始化分数
		score = 0;
		isPause = false;
		// 随机生成下一方块
		nextType = (int) (Math.random() * 7);
		nextState = (int) (Math.random() * 4);
		// 生成当前方块
		createShape();

		// 启动timer
		timer.start();
		// 绘图
		this.repaint();
	}

	/**
	 * 创建一个新方块
	 */
	public void createShape() {
		// 当前块
		type = nextType;
		state = nextState;
		x = 3;
		y = 0;
		// 下一块
		nextType = (int) (Math.random() * 7);
		nextState = (int) (Math.random() * 4);
		// 如果新块不合法，则表示游戏已结束，则重新开始
		if (!check(type, state, x, y)) {
			JOptionPane.showMessageDialog(this, "GAME OVER!");
			init();
		}
	}

	/**
	 * 判断方块是否合法：true合法，false不合法
	 */
	private boolean check(int type, int state, int x, int y) {
		for (int i = 0; i < SHAPE[type][state].length; i++) {
			for (int j = 0; j < SHAPE[type][state][0].length; j++) {
				if (SHAPE[type][state][i][j] == 1) {
					// 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
					if ((x + j >= COL) || (x + j < 0) || (y + i >= ROW) || (map[y + i][x + j] == 1)) {
						return false;
					}
				}
			}
		}
		return true;
	}

	/**
	 * 固定shape到map
	 */
	private void fix(int type, int state, int x, int y) {
		for (int i = 0; i < SHAPE[type][state].length; i++) {
			for (int j = 0; j < SHAPE[type][state][0].length; j++) {
				// 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
				if ((y + i < ROW) && (x + j >= 0) && (x + j < COL) && (map[y + i][x + j] == 0)) {
					map[y + i][x + j] = SHAPE[type][state][i][j];
					mapColor[y + i][x + j] = color[type];
				}
			}
		}
	}

	/**
	 * 消行加分
	 */
	private void clearLines() {
		int lines = 0;
		boolean isFull = true;
		for (int i = 0; i < map.length; i++) {
			isFull = true;
			for (int j = 0; j < map[0].length; j++) {
				if (map[i][j] == 0) {
					isFull = false;
					break;
				}
			}
			if (isFull) {
				lines++;
				for (int m = i; m > 0; m--) {
					for (int n = 0; n < map[0].length; n++) {
						map[m][n] = map[m - 1][n];
					}
				}
			}
		}
		score += lines * lines * 10;
		if (isAccelMode) {
			up();
		}

	}

	/**
	 * 升级加速：UP
	 */
	public void up() {
		int limit = 50;
		if (score > limit * level) {
			level++;
			delay /= 1.5;
			timer.setDelay(delay);
			limit = limit * level;
		}
	}

	public void turn() {
		int temp = state;
		state = (state + 1) % 4;
		// 如果旋转后不合法，还原上一状态
		if (!check(type, state, x, y)) {
			state = temp;
		}
	}

	public void down() {
		// 如果下一个下落状态合法，则下落；不合法，则固定。
		if (check(type, state, x, y + 1)) {
			y++;
		} else {
			fix(type, state, x, y);
			clearLines();
			createShape();
		}
		this.repaint();
	}

	public void right() {
		if (check(type, state, x + 1, y)) {
			x++;
		}
	}

	public void left() {
		if (check(type, state, x - 1, y)) {
			x--;
		}
	}

	/**
	 * 绘图：重写paint()方法
	 * 
	 * @see javax.swing.JComponent#paint(java.awt.Graphics)
	 */
	@Override
	public void paint(Graphics g) {
		// 游戏区域的左、上边距
		int MARGIN_LEFT = LEN;
		int MARGIN_TOP = LEN + 10;

		// 边栏的起始坐标
		int SIDEBAR_X = LEN * 13;// 文本的横坐标
		int SIDEBAR_Y = LEN * 9; // 文本的纵坐标
		/**
		 * 填充背景色
		 */
		g.setColor(Color.white);
		g.fillRect(0, 0, (int) (this.getSize().getWidth()), (int) (this.getSize().getHeight()));

		/**
		 * 画边框
		 */
		g.setColor(Color.gray);
		for (int offset = 1; offset < 2; offset++) {
			// 绘制矩形边框：drawRect(int x,int y,int width,int height);
			g.drawRect(MARGIN_LEFT - offset, MARGIN_TOP - offset, COL * LEN + offset * 2, ROW * LEN + offset * 2);
		}
		/**
		 * 画网状线
		 */
		g.setColor(Color.gray);
		// 11条竖线
		for (int i = 0; i < 11; i++) {
			// 绘制线条：drawLine(x1,y1,x2,y2);
			g.drawLine(MARGIN_LEFT + LEN * i, MARGIN_TOP, MARGIN_LEFT + LEN * i, MARGIN_TOP + ROW * LEN);
		}
		// 21条横线
		for (int i = 0; i < 21; i++) {
			g.drawLine(MARGIN_LEFT, MARGIN_TOP + LEN * i, MARGIN_LEFT + COL * LEN, MARGIN_TOP + LEN * i);
		}
		/**
		 * 画侧栏
		 */
		// 画文本：下一个
		g.setColor(Color.gray);
		g.setFont(new Font("Times", Font.BOLD, 20));
		g.drawString("下一个：", SIDEBAR_X, LEN * 2 + 10);
		// 画提示方块（下一个方块）
		g.setColor(color[nextType]);
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (SHAPE[nextType][nextState][i][j] == 1) {
					// 填充3D矩形：fill3DRect(int x,int y,int width,int height,boolean raised)
					g.fill3DRect(SIDEBAR_X + 20 + j * LEN, LEN * 3 + i * LEN, LEN, LEN, true);
				}
			}
		}
		// 画文本：得分
		g.setColor(Color.gray);
		g.setFont(new Font("Times", Font.BOLD, 24));
		g.drawString("等级：" + level, SIDEBAR_X, SIDEBAR_Y);
		g.drawString("得分：" + score, SIDEBAR_X, SIDEBAR_Y + 40);
		// 画文本：游戏说明
		g.setColor(Color.gray);
		g.setFont(new Font("Times", Font.BOLD, 15));
		g.drawString("玩法：", SIDEBAR_X, SIDEBAR_Y + LEN * 4);
		g.drawString("上箭头：旋转", SIDEBAR_X, SIDEBAR_Y + LEN * 5);
		g.drawString("左箭头：左移", SIDEBAR_X, SIDEBAR_Y + LEN * 6);
		g.drawString("右箭头：右移", SIDEBAR_X, SIDEBAR_Y + LEN * 7);
		g.drawString("下箭头：下落", SIDEBAR_X, SIDEBAR_Y + LEN * 8);
		g.drawString("@栗子", SIDEBAR_X, SIDEBAR_Y + LEN * 10);

		// 画当前下落块
		g.setColor(color[type]);
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (SHAPE[type][state][i][j] == 1) {
					g.fill3DRect(MARGIN_LEFT + (x + j) * LEN, MARGIN_TOP + (y + i) * LEN, LEN, LEN, true);
				}
			}
		}

		// 画背景map
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[0].length; j++) {
				if (map[i][j] == 1) {
					g.setColor(mapColor[i][j]);
					g.fill3DRect(MARGIN_LEFT + j * LEN, MARGIN_TOP + i * LEN, LEN, LEN, true);
				}
			}
		}

		// 画暂停
		if (isPause) {
			g.setColor(Color.black);
			g.drawString("PAUSE", MARGIN_LEFT + LEN * 8, LEN);
		}

		// 画普通模式
		if (!isAccelMode) {
			g.setColor(Color.black);
			g.drawString("Normal Mode", LEN, LEN);
		}
		// 画加速模式
		if (isAccelMode) {
			g.setColor(Color.black);
			g.drawString("Accel Mode", LEN, LEN);
		}

	}

	/**
	 * 定时器
	 */
	Timer timer = new Timer(delay, new ActionListener() {
		// 定时器任务
		@Override
		public void actionPerformed(ActionEvent e) {
			down();
		}
	});

	// 暂停
	public void setPause() {
		timer.stop();
		isPause = true;
		this.repaint();
	}

	// 继续
	public void setContinue() {
		timer.restart();
		isPause = false;
		this.repaint();
	}

	// 简单模式
	public void setNormal() {
		isAccelMode = false;
		level = 0;
		timer.setDelay(1000);
		init();
	}

	// 加速模式
	public void setAccel() {
		isAccelMode = true;
		level = 1;
		timer.setDelay(500);
		init();
	}

}

---