JAVA版俄罗斯方块学习

字母的形状来命名。

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

1. 
   
2. package Tetris;
4. import java.awt.image.BufferedImage;
5. /**
6. * 格子
7. */
8. public class Cell {
9. private int row;
10. private int col;
11. private BufferedImage image;
12. public Cell(int row, int col, BufferedImage image) {
13. super();
14. this.row = row;
15. this.col = col;
16. this.image = image;
17. }
18. public int getRow() {
19. return row;
20. }
21. public void setRow(int row) {
22. this.row = row;
23. }
24. public int getCol() {
25. return col;
26. }
27. public void setCol(int col) {
28. this.col = col;
29. }
30. public BufferedImage getImage() {
31. return image;
32. }
33. public void setImage(BufferedImage image) {
34. this.image = image;
35. }
36. public void drop(){
37. row ;
38. }
39. public void moveLeft(){
40. col--;
41. }
42. public void moveRight(){
43. col ;
44. }
45. }

Tetromino.java

</pre><pre name="code" class="java">Tetromino

1. 
   
2. package Tetris;
3. import java.util.Arrays;
4. import java.util.Random;
6. /**
7. * 4格方块类
8. *
9. */
10. public abstract class Tetromino {
11. /** 4个格子，留给子类使用的属性 protected*/
12. protected Cell[] cells = new Cell[4];
13. /** 随机参数7种方块之一 */
14. public static Tetromino randomOne(){
15. Random random = new Random();
16. int type = random.nextInt(7);
17. switch (type) {
18. case 0: return new T();
19. case 1: return new S();
20. case 2: return new Z();
21. case 3: return new I();
22. case 4: return new L();
23. case 5: return new J();
24. case 6: return new O();
25. }
26. return null;
27. }
28. public void softDrop(){
29. for (int i = 0; i < cells.length; i ) {
30. Cell cell = cells[i];
31. cell.drop();
32. }
33. }
34. public void moveLeft(){
35. for (int i = 0; i < cells.length; i ) {
36. Cell cell = cells[i];
37. cell.moveLeft();
38. }
39. }
40. public void moveRight(){
41. for (int i = 0; i < cells.length; i ) {
42. Cell cell = cells[i];
43. cell.moveRight();
44. }
45. }
46. @Override
47. public String toString() {
48. return Arrays.toString(cells);
49. }
50. /** 存储旋转状态的类，在Tetromino类中添加 */
51. protected class State{
52. int row0,col0,row1,col1,
53. row2,col2,row3,col3;
54. public State(int row0, int col0, int row1, int col1, int row2,
55. int col2, int row3, int col3) {
56. this.row0=row0;this.col0=col0;
57. this.row1 = row1;this.col1 = col1;
58. this.row2 = row2;this.col2 = col2;
59. this.row3 = row3;this.col3 = col3;
60. }
61. }
62. //在Tetromino 类上添加向右转的方法
63. private int index = 10000;
64. //s0={row0,col0,row1,col1,row2,col2,row3,col3}
65. protected State[] states;//在子类构造器中初始化 //{s0,s1,s2,s3};
66. public void rotateRight() {
67. //System.out.println(this);
68. //输入1：cells 当前方块的数据
69. //输入2：sN : s1 s2 s3 s0 s1 s2 s3 ...
70. //输出 cells 旋转以后的方块数据
71. //算法：cells[0] sN -> cells
72. //如何得到序列：1 2 3 0 1 2 3 0 1 2 3 0
73. index ;//10005
74. //index%4 = ?;//1 2 3 0 1 2 3 0
75. //states[index%4]=?//s1 s2 s3 s0 s1 s2 s3...
76. State s = states[index%states.length];
77. //s = s1
78. Cell o = cells[0];//找到轴 t0[0]
79. int row = o.getRow();
80. int col = o.getCol();
81. cells[1].setRow(row s.row1);//轴的row s1[row1]=t1.row
82. cells[1].setCol(col s.col1);
83. cells[2].setRow(row s.row2);
84. cells[2].setCol(col s.col2);
85. cells[3].setRow(row s.row3);
86. cells[3].setCol(col s.col3);
87. //System.out.println(this);
88. }
89. public void rotateLeft() {
90. index --;//10005
91. State s = states[index%states.length];
92. Cell o = cells[0];//找到轴 t0[0]
93. int row = o.getRow();
94. int col = o.getCol();
95. cells[1].setRow(row s.row1);//轴的row s1[row1]=t1.row
96. cells[1].setCol(col s.col1);
97. cells[2].setRow(row s.row2);
98. cells[2].setCol(col s.col2);
99. cells[3].setRow(row s.row3);
100. cells[3].setCol(col s.col3);
101. }
102. }
103. /** T 型方块，包内类 */
104. class T extends Tetromino{
105. public T() {
106. cells[0] = new Cell(0,4,Tetris.T);
107. cells[1] = new Cell(0,3,Tetris.T);
108. cells[2] = new Cell(0,5,Tetris.T);
109. cells[3] = new Cell(1,4,Tetris.T);
110. //在子类中初始化旋转状态数据
111. states = new State[]{
112. new State(0,0, 0,-1, 0,1, 1,0), //s0
113. new State(0,0, -1,0, 1,0, 0,-1),//s1
114. new State(0,0, 0,1, 0,-1, -1,0),//s2
115. new State(0,0, 1,0, -1,0, 0,1)//s3
116. };
117. }
118. }
119. class S extends Tetromino{
120. public S() {
121. cells[0] = new Cell(0,4,Tetris.S);
122. cells[1] = new Cell(0,5,Tetris.S);
123. cells[2] = new Cell(1,3,Tetris.S);
124. cells[3] = new Cell(1,4,Tetris.S);
125. //=====
126. states = new State[] {
127. new State(0, 0, 0, 1, 1, -1, 1, 0),
128. new State(0, 0, -1, 0, 1, 1, 0, 1)};
129. }
130. }
131. class L extends Tetromino{
132. public L() {
133. cells[0] = new Cell(0,4,Tetris.L);
134. cells[1] = new Cell(0,3,Tetris.L);
135. cells[2] = new Cell(0,5,Tetris.L);
136. cells[3] = new Cell(1,3,Tetris.L);
137. //====
138. states = new State[] {
139. new State(0, 0, 0, 1, 0, -1, -1, 1),
140. new State(0, 0, 1, 0, -1, 0, 1, 1),
141. new State(0, 0, 0, -1, 0, 1, 1, -1),
142. new State(0, 0, -1, 0, 1, 0, -1, -1)};
143. }
144. }
145. class J extends Tetromino{
146. public J() {
147. cells[0] = new Cell(0,4,Tetris.J);
148. cells[1] = new Cell(0,3,Tetris.J);
149. cells[2] = new Cell(0,5,Tetris.J);
150. cells[3] = new Cell(1,5,Tetris.J);
151. //===
152. states = new State[] {
153. new State(0, 0, 0, 1, 0, -1, -1, -1),
154. new State(0, 0, 1, 0, -1, 0, -1, 1),
155. new State(0, 0, 0, -1, 0, 1, 1, 1),
156. new State(0, 0, -1, 0, 1, 0, 1, -1)};
157. }
158. }
159. class Z extends Tetromino{
160. public Z() {
161. cells[0] = new Cell(1,4,Tetris.Z);
162. cells[1] = new Cell(1,5,Tetris.Z);
163. cells[2] = new Cell(0,3,Tetris.Z);
164. cells[3] = new Cell(0,4,Tetris.Z);
165. //====
166. states = new State[] {
167. new State(0, 0, -1, -1, -1, 0, 0, 1),
168. new State(0, 0, -1, 1, 0, 1, 1, 0)};
169. }
170. }
171. class O extends Tetromino{
172. public O() {
173. cells[0] = new Cell(0,4,Tetris.O);
174. cells[1] = new Cell(0,5,Tetris.O);
175. cells[2] = new Cell(1,4,Tetris.O);
176. cells[3] = new Cell(1,5,Tetris.O);
177. //===
178. states = new State[] { new State(0, 0, 0, 1, 1, 0, 1, 1),
179. new State(0, 0, 0, 1, 1, 0, 1, 1) };
180. }
181. }
182. class I extends Tetromino{
183. public I() {
184. cells[0] = new Cell(0,4,Tetris.I);
185. cells[1] = new Cell(0,3,Tetris.I);
186. cells[2] = new Cell(0,5,Tetris.I);
187. cells[3] = new Cell(0,6,Tetris.I);
188. //===
189. states = new State[] {
190. new State(0, 0, 0, -1, 0, 1, 0, 2),
191. new State(0, 0, -1, 0, 1, 0, 2, 0)};
192. }
193. }
198. package Tetris;
200. import java.awt.Color;
201. import java.awt.Font;
202. import java.awt.Graphics;
203. import java.awt.event.KeyAdapter;
204. import java.awt.event.KeyEvent;
205. import java.awt.event.KeyListener;
206. import java.awt.image.BufferedImage;
207. import java.util.Arrays;
209. import javax.imageio.ImageIO;
210. import javax.swing.JFrame;
211. import javax.swing.JPanel;
213. /**
214. * 俄罗斯方块
215. *
216. */
217. public class Tetris extends JPanel {
218. /** 游戏的状态 */
219. private int state;
220. /** 游戏正在玩状态 */
221. public static final int PLAYING = 0;
222. /** 游戏暂停状态 */
223. public static final int PAUSE = 1;
224. /** 游戏结束状态 */
225. public static final int GAME_OVER = 2;
226. /** 游戏状态提示信息 */
227. private static final String[] STATE=
228. {"[P]Pause", "[C]Continue", "[S]Restart"};
229. /** 下落速度控制 */
230. int index = 0;
231. /** speed 的值越小下落速度越快 */
232. int speed = 8;
234. /** 分数 */
235. private int score;
236. /** 行数， 销毁的总行数 */
237. private int lines;
238. public static final int ROWS = 20;
239. public static final int COLS = 10;
240. /** 方块墙 */
241. private Cell[][] wall=new Cell[ROWS][COLS];
242. /** 正在下落的方块 */
243. private Tetromino tetromino;
244. /** 下一个方块 */
245. private Tetromino nextOne;
247. /** 在Tetris 中添加背景图属性 */
248. private static BufferedImage background;
249. public static BufferedImage gameOverImage;
250. public static BufferedImage T;
251. public static BufferedImage S;
252. public static BufferedImage Z;
253. public static BufferedImage J;
254. public static BufferedImage L;
255. public static BufferedImage I;
256. public static BufferedImage O;
258. /** 读取图片文件到内存对象 */
259. //将图片复制到 com.tarena.tetris包中
260. static {
261. try{
262. background=ImageIO.read(
263. Tetris.class.getResource(
264. "tetris.png"));
265. gameOverImage=ImageIO.read(
266. Tetris.class.getResource(
267. "game-over.png"));
268. T=ImageIO.read(Tetris.class
269. .getResource("T.png"));
270. S=ImageIO.read(Tetris.class
271. .getResource("S.png"));
272. Z=ImageIO.read(Tetris.class
273. .getResource("Z.png"));
274. J=ImageIO.read(Tetris.class
275. .getResource("J.png"));
276. L=ImageIO.read(Tetris.class
277. .getResource("L.png"));
278. O=ImageIO.read(Tetris.class
279. .getResource("O.png"));
280. I=ImageIO.read(Tetris.class
281. .getResource("I.png"));
282. }catch(Exception e){
283. e.printStackTrace();
284. }
285. }
286. /** 利用重写方法修改父类JPanel */
287. //paint:涂绘， Graphics：图，画笔
288. public void paint(Graphics g){
289. //draw: 绘
290. g.drawImage(background, 0, 0, null);
291. //g.drawString("Hello", 50, 50);
292. g.translate(15, 15);
293. paintWall(g);
294. paintTetromino(g);
295. paintNextOne(g);
296. paintScore(g);//绘制分数
297. g.translate(-15, -15);
298. paintState(g);//绘制游戏状态
299. }
300. //绘制状态
301. private void paintState(Graphics g) {
302. //如果state是 0 显示 Pause
303. //如果state是 1 显示 Continue
304. //如果state是 2 显示 Restart
305. g.drawString(STATE[state], 309, 287);
306. if(state == GAME_OVER){
307. g.drawImage(gameOverImage,0,0,null);
308. }
309. }
310. //绘制分数
311. private void paintScore(Graphics g){
312. int x = 293;
313. int y = 162;
314. Font font = new Font(
315. Font.SANS_SERIF, Font.BOLD, 30);
316. g.setFont(font);
317. g.setColor(new Color(0x667799));
318. g.drawString("SCORE:" score, x, y);
319. y =56;
320. g.drawString("LINES:" lines, x, y);
321. }
323. public void paintNextOne(Graphics g){
324. Cell[] cells = nextOne.cells;
325. for(int i=0;i<cells.length; i ){
326. Cell cell = cells[i];
327. int x = CELL_SIZE*(cell.getCol() 10);
328. int y = CELL_SIZE*(cell.getRow() 1);
329. g.drawImage(cell.getImage(), x, y,
330. null);
331. }
332. }
333. /** 在Tetris类中填方法,绘制正在下落的方块 */
334. public void paintTetromino(Graphics g){
335. Cell[] cells = tetromino.cells;
336. for(int i=0;i<cells.length; i ){
337. Cell cell = cells[i];
338. int x = CELL_SIZE*cell.getCol();
339. int y = CELL_SIZE*cell.getRow();
340. g.drawImage(cell.getImage(), x, y,
341. null);
342. }
343. }
344. public static final int CELL_SIZE=26;
345. /** 在Tetris 添加画墙的方法 */
346. private void paintWall(Graphics g){
347. for(int row=0; row<ROWS; row ){
348. for(int col=0; col<COLS; col ){
349. Cell cell = wall[row][col];
350. int x=CELL_SIZE * col;
351. int y=CELL_SIZE * row;
352. if(cell==null){
353. //g.drawRect(x, y,
354. // CELL_SIZE, CELL_SIZE);
355. }else{
356. g.drawImage(cell.getImage(),
357. x,y,null);
358. }
359. }
360. }
361. }
363. /** 在Tetris 类中添加方法 */
364. public void action(){
365. state = PLAYING;
366. //wall[19][2]=new Cell(19,2,T);
367. //尽快的调用paint()重新绘制面板
368. tetromino = Tetromino.randomOne();
369. nextOne = Tetromino.randomOne();
370. repaint();
371. //创建键盘事件监听器对象
372. KeyListener l=new KeyAdapter(){
373. @Override
374. public void keyPressed(KeyEvent e) {
375. int key = e.getKeyCode();
376. //当state是值是PAUSE时候，只处理c按键
377. //其它的按键的代码被忽略不再执行
378. if(key==KeyEvent.VK_Q){
379. System.exit(0);//结束Java进程
380. }
381. switch(state){
382. case GAME_OVER:
383. if(key==KeyEvent.VK_S){
384. restartAction();
385. }
386. return;
387. case PAUSE:
388. if(key==KeyEvent.VK_C){
389. state=PLAYING;
390. }
391. //retuer以后的代码不再执行了
392. return;
393. }
394. switch(key){
395. case KeyEvent.VK_DOWN:
396. softDropAction();break;
397. case KeyEvent.VK_RIGHT:
398. moveRightAction();break;
399. case KeyEvent.VK_LEFT:
400. moveLeftAction(); break;
401. case KeyEvent.VK_UP:
402. rotateRightAction(); break;
403. case KeyEvent.VK_Z:
404. rotateLeftAction(); break;
405. case KeyEvent.VK_SPACE:
406. hardDropAction(); break;
407. case KeyEvent.VK_P:
408. state = PAUSE; break;
409. }
410. repaint();
411. }
412. };
413. //添加监听器到当前面板（挂载）
414. this.addKeyListener(l);
415. //为当前面板申请输入焦点，有焦点才能接收键盘事件
416. this.requestFocus();
418. //在action方法中添加，主控制循环
419. for(;;){
420. if(state==PLAYING){
421. index ;
422. if(index % speed==0){
423. softDropAction();
424. }
425. }
426. repaint();
427. try{
428. Thread.sleep(1000/10);
429. }catch(Exception e){
430. }
431. }
432. }
433. /** 重新开始游戏 */
434. protected void restartAction() {
435. score = 0;
436. lines = 0;
437. //将墙清空
438. wall = new Cell[ROWS][COLS];
439. tetromino = Tetromino.randomOne();
440. nextOne = Tetromino.randomOne();
441. speed = 8;
442. index = 0;
443. state = PLAYING;
444. }
445. /** 在Tetris类中添加加速下来功能
446. * 就是下落到不能下落为止
447. **/
448. private void hardDropAction(){
449. //当能够下落就下落一步，到不能下落为止
450. while(canDrop()){
451. tetromino.softDrop();
452. }
453. landIntoWall();
454. destroyLines();
455. if(!isGameOver()){
456. tetromino = nextOne;
457. nextOne = Tetromino.randomOne();
458. }else{ //游戏结束状态
459. state = GAME_OVER;
460. }
461. }
463. /** 在Tetris 类中填写方法 softDropAction */
464. private void softDropAction(){
465. boolean drop = canDrop();
466. //System.out.println("t:" tetromino);
467. //System.out.println("canDrop:" drop);
468. if(drop){
469. tetromino.softDrop();
470. }else{
471. // 入墙,land着陆 into进去 Wall 墙
472. landIntoWall();//封装 方块入墙 的算法
473. // 销毁行 destroyLines，计分
474. destroyLines();//封装销毁行的算法
475. // 检查是否结束
476. // 如果游戏没有结束，产生下一个方块
477. if(!isGameOver()){
478. tetromino=nextOne;
479. nextOne=Tetromino.randomOne();
480. }else{
481. state = GAME_OVER;
482. }
483. }
484. //System.out.println(tetromino);
485. }
486. /** 检查游戏是否结束
487. * 如果下一个将要出场的方块的墙上位置被占用
488. * 了就结束了！
489. * */
490. private boolean isGameOver() {
491. Cell[] cells = nextOne.cells;
492. for(int i=0; i<cells.length; i ){
493. Cell cell = cells[i];
494. int row=cell.getRow();
495. int col=cell.getCol();
496. if(wall[row][col]!=null){
497. return true;
498. }
499. }
500. return false;
501. }
503. /** 销毁墙上已经满的行, 并且计分 */
504. private int[] scoreTable = {0,1,5,20,100};
505. // lines 0 1 2 3 4
506. private void destroyLines() {
507. int lines = 0;//当前销毁的行数
508. for(int row=0; row<ROWS; row ){
509. if(fullCells(row)){
510. deleteRow(row);
511. lines ;
512. }
513. }
514. this.score = scoreTable[lines];
515. //速度控制，每增加1000分时候，速度
516. //的值会变小，速度加快
517. //速度的最小值是 1，不能比1更小了
518. speed = Math.max(8-score/1000, 1);
519. this.lines = lines;
520. }
521. /** 检查墙上row行是否是"满格子"，true：满了 */
522. private boolean fullCells(int row) {
523. Cell[] line = wall[row];
524. for(int i=0; i<line.length; i ){
525. Cell cell = line[i];
526. if(cell==null){
527. return false;
528. }
529. }
530. return true;
531. }
532. /** 删除墙上 row对应的行 */
533. private void deleteRow(int row) {
534. for(int i=row; i>=1; i--){
535. System.arraycopy(wall[i-1], 0,
536. wall[i], 0, COLS);
537. }
538. Arrays.fill(wall[0], null);
539. }
540. /** 将方块着陆到墙上 */
541. private void landIntoWall() {
542. Cell[] cells = tetromino.cells;
543. for(int i=0; i<cells.length; i ){
544. Cell cell = cells[i];
545. int row = cell.getRow();
546. int col = cell.getCol();
547. wall[row][col]=cell;
548. }
549. }
550. /** 在Tetris类中添加方法 canDrop() */
551. private boolean canDrop(){
552. //输入是 wall tetromino
553. //先检查tetromino是否到达底部
554. Cell[] cells = tetromino.cells;
555. for(int i=0; i<cells.length; i ){
556. //i = 0 1 2 3
557. //cell“引用”了4格方块的每个格式
558. Cell cell = cells[i];
559. //如果某个格子的行是19，就不能下落了
560. if(cell.getRow() == ROWS-1){
561. //System.out.println("到达底部");
562. return false;
563. }
564. }
566. //检查tetromino的下方墙上是否有方块
567. for(int i=0; i<cells.length; i ){
568. Cell cell = cells[i];
569. int row = cell.getRow();
570. int col = cell.getCol();
571. if(wall[row 1][col]!=null){
572. //System.out.println(cell "的下方有方块");
573. return false;
574. }
575. }
576. return true;
577. }
579. /** Tetris 类中添加向右移动流程控制方法 */
580. private void moveRightAction(){
581. tetromino.moveRight();
582. //outOfBounds出界 concide：重合
583. if(outOfBounds() || concide()){
584. tetromino.moveLeft();
585. }
586. }
587. private void moveLeftAction(){
588. tetromino.moveLeft();
589. //outOfBounds出界 concide：重合
590. if(outOfBounds() || concide()){
591. tetromino.moveRight();
592. }
593. }
594. //检查当前下落的方块，是否出界，true：出界了
595. private boolean outOfBounds(){
596. Cell[] cells = tetromino.cells;
597. for(int i=0; i<cells.length; i ){
598. Cell cell = cells[i];
599. int row = cell.getRow();
600. int col = cell.getCol();
601. if((row<0||row>=ROWS) ||
602. (col<0||col>=COLS)){
603. return true;
604. }
605. }
606. return false;
607. }
608. //检查当前下落的方块，是否与墙砖重合，true重合
609. private boolean concide(){
610. Cell[] cells = tetromino.cells;
611. //for (int i = 0; i < cells.length; i ) {
612. // Cell cell = cells[i];
613. for(Cell cell: cells){
614. int row = cell.getRow();
615. int col = cell.getCol();
616. if(wall[row][col]!=null){
617. return true;
618. }
619. }
620. return false;
621. }
622. /** 在tetris 类中增加旋转流程控制方法 */
623. public void rotateRightAction(){
624. //rotate:原地转
625. tetromino.rotateRight();
626. if(outOfBounds() || concide()){
627. tetromino.rotateLeft();
628. }
629. }
630. public void rotateLeftAction(){
631. //rotate:原地转
632. tetromino.rotateLeft();
633. if(outOfBounds() || concide()){
634. tetromino.rotateRight();
635. }
636. }
638. public static void main(String[] args) {
639. //Frame 框，相框，代表窗口框
640. JFrame frame = new JFrame();
641. //panel 代表面板
642. Tetris panel = new Tetris();
643. //Background 背景
644. panel.setBackground(Color.YELLOW);
645. //窗口中添加面板
646. frame.add(panel);
647. frame.setUndecorated(true);//去掉窗口边框
648. frame.setSize(535, 580);
649. //居中
650. frame.setLocationRelativeTo(null);
651. //点击X时候同时关闭程序
652. frame.setDefaultCloseOperation(
653. JFrame.EXIT_ON_CLOSE);
654. //显示窗口框
655. frame.setVisible(true);
656. //尽快的调用 paint()方法绘制显示界面
657. //显示窗口以后，执行 启动方法action
658. panel.action();
659. }
660. }