贪吃蛇和俄罗斯方块

贪吃蛇

一、创建新项目

创建一个新的项目，并命名。

创建一个名为images的文件夹用来存放游戏相关图片。

然后再在项目的src文件下创建一个com.xxx.view的包用来存放所有的图形界面类，

创建一个com.xxx.controller的包用来存放启动的入口类(控制类)

二、游戏界面 

1. package com.snake.view;

3. import java.awt.Color;

4. import java.awt.EventQueue;

5. import java.awt.Font;

6. import java.awt.Frame;

7. import java.awt.Graphics;

8. import java.awt.Image;

9. import java.util.ArrayList;

10. import java.util.List;

11. import java.util.Random;

13. import javax.swing.ImageIcon;

14. import javax.swing.JFrame;

15. import javax.swing.JOptionPane;

16. import javax.swing.JPanel;

17. import javax.swing.Timer;

18. import javax.swing.border.EmptyBorder;

21. import java.awt.event.ActionEvent;

22. import java.awt.event.ActionListener;

23. import java.awt.event.KeyAdapter;

24. import java.awt.event.KeyEvent;

26. public class SnakeJPanel extends JPanel implements ActionListener{

28. private boolean start;//当前游戏状态

30. private int speed;//速度

32. private boolean exist;//当前是否存在食物

34. private int foodType;//食物种类

36. private int x;//豆子的横坐标

37. private int y;//豆子的纵坐标

39. private ArrayList<int[]> localList;//蛇

42. public String direction;//方向

44. private String direction2;//引导方向

46. public boolean flag;

48. Random rand = new Random();

50. private ImageIcon up;

52. private ImageIcon down;

54. private ImageIcon right;

56. private ImageIcon left;

58. private ImageIcon body;

60. private ImageIcon food;

62. private ImageIcon title;

64. Timer time;

66. private int score;//当前得分情况

68. private int num;//吃到的食物个数

70. // private Image offScreenImage; //图形缓存

73. //图片绘制

74. @Override

75. public void paint(Graphics g) {

77. direction = direction2;

79. g.setColor(Color.WHITE);

80. g.fillRect(0, 0, 900, 700);

82. //绘制游戏框

83. //标题框

84. // g.drawRect(25, 30, 800, 75);

85. title.paintIcon(this, g, 25, 10);

87. //内容框

88. g.setColor(Color.black);

89. g.fillRect(25, 75, 850, 600);

91. //绘制食物的坐标位置

92. if(!exist) {//如果当前不存在豆子,随机绘制一个豆子

93. if(num % 5 == 0) {

94. foodType = 1;

95. }else {

96. foodType = 0;

97. }

98. boolean isProduce = true;

99. while(isProduce) {

100. isProduce = false;

101. x = rand.nextInt(33) * 25 + 25;

102. y = rand.nextInt(23) * 25 + 75;

103. for (int[] arr:localList) {

104. if(x == arr[0] && y == arr[1]) {

105. isProduce = true;

106. break;

107. }

108. }

110. }

111. System.out.println(x + "---" + y);

112. }

114. if(eat()) {

115. exist = false;

116. }else {

117. exist = true;

118. }

121. if(foodType == 0) {

122. //绘制食物

123. g.setColor(Color.blue);

124. // g.fillRect(x, y, 25, 25);

125. g.drawImage(food.getImage(),x, y, 25, 25,null);

126. }else {

127. //绘制食物

128. g.setColor(Color.WHITE);

129. g.fillRect(x, y, 25, 25);

130. // g.drawImage(food.getImage(),x, y, 25, 25,null);

131. }

134. //绘制头

135. g.setColor(Color.red);

136. // g.fillRect(localList.get(0)[0], localList.get(0)[1], 25, 25);

137. ImageIcon head = null;

138. //判断当前方向

139. if(direction.equals("R")) {

140. head = right;

141. }else if(direction.equals("L")) {

142. head = left;

143. }else if(direction.equals("U")) {

144. head = up;

145. }else if(direction.equals("D")) {

146. head = down;

147. }

148. // g.drawImage(head.getImage(), localList.get(0)[0], localList.get(0)[1], 25, 25,null);

149. head.paintIcon(this, g,localList.get(0)[0], localList.get(0)[1]);

151. //绘制身体

152. g.setColor(Color.white);

153. for (int i = 1; i < localList.size(); i++) {

154. // g.fillRect(localList.get(i)[0], localList.get(i)[1], 25, 25);

155. // g.drawImage(body.getImage(), localList.get(i)[0], localList.get(i)[1], 25, 25,null);

156. body.paintIcon(this, g, localList.get(i)[0], localList.get(i)[1]);

157. }

158. // g.fillRect(localList.get(1)[0], localList.get(1)[1], 25, 25);

159. // g.fillRect(localList.get(2)[0], localList.get(2)[1], 25, 25);

162. //绘制分数和长度

163. //长度

164. g.setColor(Color.GREEN);

165. g.setFont(new Font("宋体", Font.BOLD, 18));

166. g.drawString("长度:" + (localList.size() - 1), 25, 30);

168. //分数

169. g.drawString("分数:" + score, 25, 48);

171. if(!start) {//如果游戏未启动，结束移动和重绘

172. g.setColor(Color.white);

173. g.setFont(new Font("宋体", Font.BOLD, 30));

174. g.drawString("暂停/开始(请按任意键开始，空格键暂停)", 150, 300);

175. time.stop();

177. }else {

178. time.start();

179. }

181. // speed();

182. //移动后进行下一次绘制

183. // move();//移动

184. // repaint();//重新绘制

185. }

187. // //解决闪烁问题

188. // //如果为JFrame 为重量级 程序不会调用update()方法

189. // //如果为Frame 为轻量级 重写update()方法 做双缓冲

190. // //如果为JPanel 不会闪烁

191. // @Override

192. // public void update(Graphics g)

193. // {

194. // System.out.println("update");

195. // if(offScreenImage == null)

196. // offScreenImage = this.createImage(900, 700); //新建一个图像缓存空间,这里图像大小为800*600

197. // Graphics gImage = offScreenImage.getGraphics(); //把它的画笔拿过来,给gImage保存着

198. // paint(gImage); //将要画的东西画到图像缓存空间去

199. // g.drawImage(offScreenImage, 0, 0, null); //然后一次性显示出来

200. // }

203. @Override

204. public void actionPerformed(ActionEvent e) {

205. //移动后进行下一次绘制

206. move();//移动

207. repaint();//重新绘制

209. }

211. /**

212. * 绘制速度

213. */

214. // private void speed() {

215. // try {//按一定速度进行移动

216. // Thread.sleep(speed);//控制移动速度

217. // } catch (InterruptedException e) {

218. // // TODO 自动生成的 catch 块

219. // e.printStackTrace();

220. // }

221. // }

223. /**

224. * 初始化图片

225. */

226. private void drawImage() {

227. up = new ImageIcon("images/up.png");

228. down = new ImageIcon("images/down.png");

229. right = new ImageIcon("images/right.png");

230. left = new ImageIcon("images/left.png");

231. body = new ImageIcon("images/body.png");

232. food = new ImageIcon("images/food.png");

233. title = new ImageIcon("images/title.jpg");

234. }

236. private boolean eat() {

237. if(localList.get(0)[0] == x && localList.get(0)[1] == y) {//如果当前蛇头吃到了豆子

238. System.out.println("eat");

239. num++;

240. if(foodType == 0) {

241. score += 10;

242. }else {

243. score += (rand.nextInt(5) * 10 + 10);

244. }

245. int last = localList.size() - 1;//蛇尾

246. //在蛇尾后面添加一节身体

247. localList.add(new int[] {localList.get(last)[0],localList.get(last)[1]});

248. return true;

249. }

250. return false;

251. }

253. //移动方法

254. public void move() {

255. //判断是否游戏结束

256. if(isbody()) {

257. System.out.println("game over");

258. start = false;//结束游戏移动

259. JOptionPane.showMessageDialog(null,"游戏已结束！");

260. time.stop();

261. init();

262. }

264. if(flag && localList != null) {//如果长度不为空且游戏未结束

265. int last = localList.size() - 1;//记录蛇尾

267. for (int i = last; i > 0; i--) {//从蛇尾开始，每节身体移动到前一节身体的位置上

268. localList.set(i,new int[] {localList.get(i - 1)[0],localList.get(i - 1)[1]});

269. }

271. //记录头位置

272. int[] local = localList.get(0);

273. //判断当前方向,并进行模拟移动，判断是否与边界重合

274. if(direction.equals("R")) {

275. if(local[0] >= 850) {

276. local[0] = 25;

277. }else {

278. local[0] += 25;

279. }

281. }else if(direction.equals("L")) {

282. if(local[0] <= 25) {

283. local[0] = 850;

284. }else {

285. local[0] -= 25;

286. }

288. }else if(direction.equals("U")) {

290. if(local[1] <= 75) {

291. local[1] = 650;

292. }else {

293. local[1] -= 25;

294. }

296. }else if(direction.equals("D")) {

297. if(local[1] >= 650) {

298. local[1] = 75;

299. }else {

300. local[1] += 25;

301. }

303. }

305. //更改头的位置

306. localList.set(0, local);

307. }

308. }

310. //判断下一步是否为蛇身

311. private boolean isbody() {

312. // TODO 自动生成的方法存根

313. //记录头位置

314. int x = localList.get(0)[0];

315. int y = localList.get(0)[1];

317. //判断当前方向,并进行模拟移动，判断是否与边界重合

318. if(direction.equals("R")) {

319. x += 25;

320. }else if(direction.equals("L")) {

321. x -= 25;

322. }else if(direction.equals("U")) {

323. y -= 25;

324. }else if(direction.equals("D")) {

325. y += 25;

326. }

328. for (int i = 1; i < localList.size(); i++) {

329. if(localList.get(i)[0] == x && localList.get(i)[1] == y) {

330. return true;

331. }

332. }

333. return false;

335. }

337. // //判断下一步是否为边界

338. // private boolean isborder() {

339. // // TODO 自动生成的方法存根

340. // //记录头位置

341. // // TODO 自动生成的方法存根

342. // //记录头位置

343. // int x = localList.get(0)[0];

344. // int y = localList.get(0)[1];

345. //

346. // //判断当前方向,并进行模拟移动，判断是否与边界重合

347. // if(direction.equals("R")) {

348. // x += 25;

349. // }else if(direction.equals("L")) {

350. // x -= 25;

351. // }else if(direction.equals("U")) {

352. // y -= 25;

353. // }else if(direction.equals("D")) {

354. // y += 25;

355. // }

356. //

357. // if(x < 25 || x > (33 * 25 + 25)) {

358. // return true;//当x坐标超出边界，则返回true

359. // }

360. // if(y < 105 || y > (23 * 25 + 105)) {

361. // return true;//当y坐标超出边界，则返回true

362. // }

363. // return false;//蛇头移动后未超出边界，返回false

364. //

365. // }

367. /**

368. * Create the frame.

369. */

370. public SnakeJPanel(int speed) {

372. this.speed = speed; //初始化速度

374. //初始化游戏面板的基本信息

375. this.setSize(900, 700);

376. this.setLocation(0, 30);

377. this.setFocusable(true);

379. init();//初始化界面

380. drawImage();//绘制图片

381. moveByKey();//给界面添加一个键盘监听

383. }

385. /*

386. * 键盘监听

387. * 通过键盘输入上下左右来控制当前蛇头移动的方向

388. * 先判断当前蛇头方向，再来改变引导方向

389. * 当进行绘制时再修改蛇的方向

390. * 保证不会因为在短时间内快速变换方向导致蛇头逆向转向

391. */

392. private void moveByKey() {

393. addKeyListener(new KeyAdapter() {

394. @Override

395. public void keyPressed(KeyEvent e) {

396. int key = e.getKeyCode();

397. //边界值判断

398. switch(key) {

399. case 65:

400. case 37:{//向左走

401. if(!direction.equals("R")) {

402. direction2 = "L";

404. }

405. break;

406. }

407. case 87:

408. case 38:{//向上走

409. if(!direction.equals("D")) {

410. direction2 = "U";

411. }

412. break;

413. }

414. case 68:

415. case 39:{//向右走

416. if(!direction.equals("L")) {

417. direction2 = "R";

418. }

419. break;

420. }

421. case 83:

422. case 40:{//向下走

423. if(!direction.equals("U")) {

424. direction2 = "D";

425. }

426. break;

427. }

428. case KeyEvent.VK_SPACE:{//如果当前键盘输入为空格

429. start = !start;//调整游戏状态

430. System.out.println("暂停/开始");

431. repaint();//重绘

432. }

433. }

435. //任意键开始

436. if(!start && key != KeyEvent.VK_SPACE) {//如果当前状态为暂停状态，且键盘输入不是空格

437. start = true;

438. repaint();//重绘

440. }

441. }

442. });

443. }

445. /**

446. * 初始化游戏基本信息

447. */

448. private void init() {

449. start = false;

451. exist = true;

453. direction2 = "U";

455. flag = true;

457. localList = new ArrayList<int[]>();

459. localList.add(0,new int[] {75,125});//蛇头

460. localList.add(1,new int[] {75,150});//蛇身1

461. localList.add(2,new int[] {75,175});//蛇身2

463. //创建第一个食物的位置

464. //通过循环保证当前生成的食物不在身体所在的坐标上

465. boolean isProduce = true;

466. while(isProduce) {//循环生成食物坐标

467. isProduce = false;//结束本次循环

468. x = rand.nextInt(33) * 25 + 25;

469. y = rand.nextInt(23) * 25 + 75;

470. for (int[] arr:localList) {//循环遍历蛇头及蛇身的坐标

471. if(x == arr[0] && y == arr[1]) {//如果食物坐标和蛇的某一节坐标重合

472. isProduce = true;//跳转循环状态，继续下一次食物生成

473. break;

474. }

475. }

476. //蛇身遍历完成，没有重合坐标，结束食物坐标生成

478. }

480. time = new Timer(speed, this);

481. setLayout(null);

483. score = 0;

485. num = 0;

487. foodType = 0;

489. // repaint();

491. }

494. }

三、构造启动类

1. package com.snake.controller;

3. import javax.swing.JFrame;

4. import javax.swing.JOptionPane;

6. import com.snake.view.SnakeJPanel;

8. public class SnakeStart {

9. public static void main(String[] args) {

11. int speed = 0;

12. String showInputDialog = null;//初始化时间

13. //得到速度

14. while(true) {

15. showInputDialog = JOptionPane.showInputDialog("蛇移动速度(1 - 5)","3");

17. if(showInputDialog == null) {

18. showInputDialog = "3";//默认速度

19. break;

20. }

21. if(showInputDialog.length() > 1) {

22. continue;

23. }

24. char[] a = showInputDialog.toCharArray();

25. if(a[0] >= '1' && a[0] <= '5') {

26. break;

27. }

28. }

30. speed = Integer.parseInt(showInputDialog) * 50;

33. SnakeJPanel snakeJPanel = new SnakeJPanel(speed);

35. //创建一个JFrame窗口，将游戏面板添加进行窗口中

36. JFrame jFrame = new JFrame();

37. //设置窗口的某些属性

38. jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

39. jFrame.setSize(920, 750);

40. jFrame.add(snakeJPanel);

41. jFrame.setLocationRelativeTo(null);

42. jFrame.setVisible(true);

43. }

45. }

四、游戏启动

设置游戏速度

游戏界面

 俄罗斯方块

游戏规则：

由小方块组成的不同形状的板块陆续从屏幕上方落下来，玩家通过调整板块的位置和方向，使它们在屏幕底部拼出完整的一条或几条。这些完整的横条会随即消失，给新落下来的板块腾出空间，与此同时，玩家得到分数奖励。没有被消除掉的方块不断堆积起来，一旦堆到屏幕顶端，玩家便告输，游戏结束。

整体代码分为三个模块：方格模块，七种图形模块，俄罗斯方块主模块。

小方块类：Cell

1. package com.zhao.demo.block;

3. import java.awt.image.BufferedImage;

4. import java.util.Objects;

6. /**

7. * @author xiaoZhao

8. * @date 2022/5/7

9. * @describe

10. * 小方块类

11. * 方法： 左移、右移、下落

12. */

13. public class Cell {

14. // 行

15. private int row;

16. // 列

17. private int col;

18. private BufferedImage image;

20. public Cell() {

21. }

23. public Cell(int row, int col, BufferedImage image) {

24. this.row = row;

25. this.col = col;

26. this.image = image;

27. }

29. public int getRow() {

30. return row;

31. }

33. public void setRow(int row) {

34. this.row = row;

35. }

37. public int getCol() {

38. return col;

39. }

41. public void setCol(int col) {

42. this.col = col;

43. }

45. public BufferedImage getImage() {

46. return image;

47. }

49. public void setImage(BufferedImage image) {

50. this.image = image;

51. }

53. @Override

54. public String toString() {

55. return "Cell{" +

56. "row=" + row +

57. ", col=" + col +

58. ", image=" + image +

59. '}';

60. }

62. @Override

63. public boolean equals(Object o) {

64. if (this == o) {

65. return true;

66. }

68. if (!(o instanceof Cell)) {

69. return false;

70. }

71. Cell cell = (Cell) o;

72. return getRow() == cell.getRow() &&

73. getCol() == cell.getCol() &&

74. Objects.equals(getImage(), cell.getImage());

75. }

77. @Override

78. public int hashCode() {

79. return Objects.hash(getRow(), getCol(), getImage());

80. }

82. //左移动一格

83. public void left(){

84. col--;

85. }

87. //右移动一格

88. public void right(){

89. col++;

90. }

92. //下移动一格

93. public void down(){

94. row++;

95. }

96. }

 四方格图形的父类：Tetromino

1. package com.zhao.demo.block;

3. import com.zhao.demo.shape.*;

5. /**

6. * @author xiaoZhao

7. * @date 2022/5/11

8. * @describe 编写四方格父类

9. */

10. public class Tetromino {

12. public Cell[] cells = new Cell[4];

14. //旋转的状态

15. protected State[] states;

16. //声明旋转次数

17. protected int count = 10000;

20. //左移方法

21. public void moveLeft() {

22. for (Cell cell : cells) {

23. cell.left();

24. }

25. }

27. //右移方法

28. public void moveRight() {

29. for (Cell cell : cells) {

30. cell.right();

31. }

32. }

34. //单元格下落

35. public void moveDrop() {

36. for (Cell cell : cells) {

37. cell.down();

38. }

39. }

41. //编写随机生成四方格

42. public static Tetromino randomOne() {

43. int num = (int) (Math.random() * 7);

44. Tetromino tetromino = null;

45. switch (num) {

46. case 0:

47. tetromino = new I();

48. break;

49. case 1:

50. tetromino = new J();

51. break;

52. case 2:

53. tetromino = new L();

54. break;

55. case 3:

56. tetromino = new O();

57. break;

58. case 4:

59. tetromino = new S();

60. break;

61. case 5:

62. tetromino = new T();

63. break;

64. case 6:

65. tetromino = new Z();

66. break;

67. }

69. return tetromino;

70. }

72. //顺时针旋转的方法

73. public void rotateRight() {

74. if (states.length == 0) {

75. return;

76. }

78. //旋转次数+1

79. count++;

80. State s = states[count % states.length];

81. Cell cell = cells[0];

82. int row = cell.getRow();

83. int col = cell.getCol();

84. cells[1].setRow(row + s.row1);

85. cells[1].setCol(col + s.col1);

86. cells[2].setRow(row + s.row2);

87. cells[2].setCol(col + s.col2);

88. cells[3].setRow(row + s.row3);

89. cells[3].setCol(col + s.col3);

90. }

92. //逆时针旋转的方法

93. public void rotateLeft() {

94. if (states.length == 0) {

95. return;

96. }

98. //旋转次数+1

99. count--;

100. State s = states[count % states.length];

101. Cell cell = cells[0];

102. int row = cell.getRow();

103. int col = cell.getCol();

104. cells[1].setRow(row + s.row1);

105. cells[1].setCol(col + s.col1);

106. cells[2].setRow(row + s.row2);

107. cells[2].setCol(col + s.col2);

108. cells[3].setRow(row + s.row3);

109. cells[3].setCol(col + s.col3);

110. }

112. //四方格旋转状态的内部类

113. protected class State {

114. //存储四方格各元素的位置

115. int row0, col0, row1, col1, row2, col2, row3, col3;

117. public State() {

118. }

120. public State(int row0, int col0, int row1, int col1, int row2, int col2, int row3, int col3) {

121. this.row0 = row0;

122. this.col0 = col0;

123. this.row1 = row1;

124. this.col1 = col1;

125. this.row2 = row2;

126. this.col2 = col2;

127. this.row3 = row3;

128. this.col3 = col3;

129. }

131. public int getRow0() {

132. return row0;

133. }

135. public void setRow0(int row0) {

136. this.row0 = row0;

137. }

139. public int getCol0() {

140. return col0;

141. }

143. public void setCol0(int col0) {

144. this.col0 = col0;

145. }

147. public int getRow1() {

148. return row1;

149. }

151. public void setRow1(int row1) {

152. this.row1 = row1;

153. }

155. public int getCol1() {

156. return col1;

157. }

159. public void setCol1(int col1) {

160. this.col1 = col1;

161. }

163. public int getRow2() {

164. return row2;

165. }

167. public void setRow2(int row2) {

168. this.row2 = row2;

169. }

171. public int getCol2() {

172. return col2;

173. }

175. public void setCol2(int col2) {

176. this.col2 = col2;

177. }

179. public int getRow3() {

180. return row3;

181. }

183. public void setRow3(int row3) {

184. this.row3 = row3;

185. }

187. public int getCol3() {

188. return col3;

189. }

191. public void setCol3(int col3) {

192. this.col3 = col3;

193. }

195. @Override

196. public String toString() {

197. return "State{" +

198. "row0=" + row0 +

199. ", col0=" + col0 +

200. ", row1=" + row1 +

201. ", col1=" + col1 +

202. ", row2=" + row2 +

203. ", col2=" + col2 +

204. ", row3=" + row3 +

205. ", col3=" + col3 +

206. '}';

207. }

208. }

209. }

七种图形类：I、J、L、O、S、T、Z

 I

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class I extends Tetromino {

14. public I() {

15. cells[0] = new Cell(0,4, Tetris.I);

16. cells[1] = new Cell(0,3, Tetris.I);

17. cells[2] = new Cell(0,5, Tetris.I);

18. cells[3] = new Cell(0,6, Tetris.I);

20. //共有两种旋转状态

21. states =new State[2];

22. //初始化两种状态的相对坐标

23. states[0]=new State(0,0,0,-1,0,1,0,2);

24. states[1]=new State(0,0,-1,0,1,0,2,0);

25. }

27. }

J

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class J extends Tetromino {

13. public J() {

14. cells[0] = new Cell(0,4, Tetris.J);

15. cells[1] = new Cell(0,3, Tetris.J);

16. cells[2] = new Cell(0,5, Tetris.J);

17. cells[3] = new Cell(1,5, Tetris.J);

19. states=new State[4];

20. states[0]=new State(0,0,0,-1,0,1,1,1);

21. states[1]=new State(0,0,-1,0,1,0,1,-1);

22. states[2]=new State(0,0,0,1,0,-1,-1,-1);

23. states[3]=new State(0,0,1,0,-1,0,-1,1);

24. }

25. }

 L

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class L extends Tetromino {

13. public L() {

14. cells[0] = new Cell(0,4, Tetris.L);

15. cells[1] = new Cell(0,3, Tetris.L);

16. cells[2] = new Cell(0,5, Tetris.L);

17. cells[3] = new Cell(1,3, Tetris.L);

19. states=new State[4];

20. states[0]=new State(0,0,0,-1,0,1,1,-1);

21. states[1]=new State(0,0,-1,0,1,0,-1,-1);

22. states[2]=new State(0,0,0,1,0,-1,-1,1);

23. states[3]=new State(0,0,1,0,-1,0,1,1);

24. }

25. }

O

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class O extends Tetromino {

13. public O() {

14. cells[0] = new Cell(0, 4, Tetris.O);

15. cells[1] = new Cell(0, 5, Tetris.O);

16. cells[2] = new Cell(1, 4, Tetris.O);

17. cells[3] = new Cell(1, 5, Tetris.O);

19. //无旋转状态

20. states = new State[0];

21. }

22. }

S 

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class S extends Tetromino {

13. public S() {

14. cells[0] = new Cell(0,4, Tetris.S);

15. cells[1] = new Cell(0,5, Tetris.S);

16. cells[2] = new Cell(1,3, Tetris.S);

17. cells[3] = new Cell(1,4, Tetris.S);

19. //共有两种旋转状态

20. states =new State[2];

21. //初始化两种状态的相对坐标

22. states[0]=new State(0,0,0,1,1,-1,1,0);

23. states[1]=new State(0,0,1,0,-1,-1,0,-1);

24. }

25. }

T 

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class T extends Tetromino {

13. public T() {

14. cells[0] = new Cell(0,4, Tetris.T);

15. cells[1] = new Cell(0,3, Tetris.T);

16. cells[2] = new Cell(0,5, Tetris.T);

17. cells[3] = new Cell(1,4, Tetris.T);

19. states=new State[4];

20. states[0]=new State(0,0,0,-1,0,1,1,0);

21. states[1]=new State(0,0,-1,0,1,0,0,-1);

22. states[2]=new State(0,0,0,1,0,-1,-1,0);

23. states[3]=new State(0,0,1,0,-1,0,0,1);

24. }

25. }

Z 

1. package com.zhao.demo.shape;

3. import com.zhao.demo.App.Tetris;

4. import com.zhao.demo.block.Cell;

5. import com.zhao.demo.block.Tetromino;

7. /**

8. * @author xiaoZhao

9. * @date 2022/5/11

10. * @describe

11. */

12. public class Z extends Tetromino {

13. public Z() {

14. cells[0] = new Cell(1,4, Tetris.Z);

15. cells[1] = new Cell(0,3, Tetris.Z);

16. cells[2] = new Cell(0,4, Tetris.Z);

17. cells[3] = new Cell(1,5, Tetris.Z);

19. //共有两种旋转状态

20. states =new State[2];

21. //初始化两种状态的相对坐标

22. states[0]=new State(0,0,-1,-1,-1,0,0,1);

23. states[1]=new State(0,0,-1,1,0,1,1,0);

24. }

25. }

俄罗斯方块游戏主类：Tetris

1. package com.zhao.demo.App;

3. import com.zhao.demo.block.Cell;

4. import com.zhao.demo.block.Tetromino;

6. import javax.imageio.ImageIO;

7. import javax.swing.*;

8. import java.awt.*;

9. import java.awt.event.KeyAdapter;

10. import java.awt.event.KeyEvent;

11. import java.awt.event.KeyListener;

12. import java.awt.image.BufferedImage;

13. import java.io.File;

14. import java.io.IOException;

15. import java.security.cert.Certificate;

17. /**

18. * @author xiaoZhao

19. * @date 2022/5/11

20. * @describe 俄罗斯方块游戏主类

21. */

22. public class Tetris extends JPanel {

24. //正在下落的方块

25. private Tetromino currentOne = Tetromino.randomOne();

26. //将要下落的方块

27. private Tetromino nextOne = Tetromino.randomOne();

28. //游戏主区域

29. private Cell[][] wall = new Cell[18][9];

30. //声明单元格的值

31. private static final int CELL_SIZE = 48;

33. //游戏分数池

34. int[] scores_pool = {0, 1, 2, 5, 10};

35. //当前游戏的分数

36. private int totalScore = 0;

37. //当前消除的行数

38. private int totalLine = 0;

40. //游戏三种状态 游戏中、暂停、结束

41. public static final int PLING = 0;

42. public static final int STOP = 1;

43. public static final int OVER = 2;

44. //当前游戏状态值

45. private int game_state;

46. //显示游戏状态

47. String[] show_state = {"P[pause]", "C[continue]", "S[replay]"};

50. //载入方块图片

51. public static BufferedImage I;

52. public static BufferedImage J;

53. public static BufferedImage L;

54. public static BufferedImage O;

55. public static BufferedImage S;

56. public static BufferedImage T;

57. public static BufferedImage Z;

58. public static BufferedImage background;

60. static {

61. try {

62. I = ImageIO.read(new File("images/I.png"));

63. J = ImageIO.read(new File("images/J.png"));

64. L = ImageIO.read(new File("images/L.png"));

65. O = ImageIO.read(new File("images/O.png"));

66. S = ImageIO.read(new File("images/S.png"));

67. T = ImageIO.read(new File("images/T.png"));

68. Z = ImageIO.read(new File("images/Z.png"));

69. background = ImageIO.read(new File("images/background.png"));

70. } catch (IOException e) {

71. e.printStackTrace();

72. }

73. }

75. @Override

76. public void paint(Graphics g) {

77. g.drawImage(background, 0, 0, null);

78. //平移坐标轴

79. g.translate(22, 15);

80. //绘制游戏主区域

81. paintWall(g);

82. //绘制正在下落的四方格

83. paintCurrentOne(g);

84. //绘制下一个将要下落的四方格

85. paintNextOne(g);

86. //绘制游戏得分

87. paintSource(g);

88. //绘制当前游戏状态

89. paintState(g);

90. }

92. public void start() {

93. game_state = PLING;

94. KeyListener l = new KeyAdapter() {

95. @Override

96. public void keyPressed(KeyEvent e) {

97. int code = e.getKeyCode();

98. switch (code) {

99. case KeyEvent.VK_DOWN:

100. sortDropActive();

101. break;

102. case KeyEvent.VK_LEFT:

103. moveleftActive();

104. break;

105. case KeyEvent.VK_RIGHT:

106. moveRightActive();

107. break;

108. case KeyEvent.VK_UP:

109. rotateRightActive();

110. break;

111. case KeyEvent.VK_SPACE:

112. hadnDropActive();

113. break;

114. case KeyEvent.VK_P:

115. //判断当前游戏状态

116. if (game_state == PLING) {

117. game_state = STOP;

118. }

119. break;

120. case KeyEvent.VK_C:

121. if (game_state == STOP) {

122. game_state = PLING;

123. }

124. break;

125. case KeyEvent.VK_S:

126. //重新开始

127. game_state = PLING;

128. wall = new Cell[18][9];

129. currentOne = Tetromino.randomOne();

130. nextOne = Tetromino.randomOne();

131. totalScore = 0;

132. totalLine = 0;

133. break;

134. }

135. }

136. };

137. //将窗口设置为焦点

138. this.addKeyListener(l);

139. this.requestFocus();

141. while (true) {

142. if (game_state == PLING) {

143. try {

144. Thread.sleep(500);

145. } catch (InterruptedException e) {

146. e.printStackTrace();

147. }

148. if (camDrop()) {

149. currentOne.moveDrop();

150. } else {

151. landToWall();

152. destroyLine();

153. if (isGameOver()) {

154. game_state = OVER;

155. } else {

156. //游戏没有结束

157. currentOne = nextOne;

158. nextOne = Tetromino.randomOne();

159. }

160. }

161. }

162. repaint();

163. }

164. }

166. //创建顺时针旋转

167. public void rotateRightActive() {

168. currentOne.rotateRight();

169. if (outOFBounds() || coincide()) {

170. currentOne.rotateLeft();

171. }

172. }

174. //瞬间下落

175. public void hadnDropActive() {

176. while (true) {

177. //判断能否下落

178. if (camDrop()) {

179. currentOne.moveDrop();

180. } else {

181. break;

182. }

183. }

184. //嵌入到墙中

185. landToWall();

186. destroyLine();

187. if (isGameOver()) {

188. game_state = OVER;

189. } else {

190. //游戏没有结束

191. currentOne = nextOne;

192. nextOne = Tetromino.randomOne();

193. }

194. }

196. //按键一次，下落一格

197. public void sortDropActive() {

198. if (camDrop()) {

199. //当前四方格下落一格

200. currentOne.moveDrop();

201. } else {

202. landToWall();

203. destroyLine();

204. if (isGameOver()) {

205. game_state = OVER;

206. } else {

207. //游戏没有结束

208. currentOne = nextOne;

209. nextOne = Tetromino.randomOne();

210. }

211. }

212. }

214. //单元格嵌入墙中

215. private void landToWall() {

216. Cell[] cells = currentOne.cells;

217. for (Cell cell : cells) {

218. int row = cell.getRow();

219. int col = cell.getCol();

220. wall[row][col] = cell;

221. }

222. }

224. //判断四方格能否下落

225. public boolean camDrop() {

226. Cell[] cells = currentOne.cells;

227. for (Cell cell : cells) {

228. int row = cell.getRow();

229. int col = cell.getCol();

230. //判断是否到达底部

231. if (row == wall.length - 1) {

232. return false;

233. } else if (wall[row + 1][col] != null) {

234. return false;

235. }

236. }

237. return true;

238. }

240. //消除行

241. public void destroyLine() {

242. int line = 0;

243. Cell[] cells = currentOne.cells;

244. for (Cell cell : cells) {

245. int row = cell.getRow();

246. if (isFullLine(row)) {

247. line++;

248. for (int i = row; i > 0; i--) {

249. System.arraycopy(wall[i - 1], 0, wall[i], 0, wall[0].length);

250. }

251. wall[0] = new Cell[9];

252. }

253. }

254. //分数池获取分数，累加到总分

255. totalScore += scores_pool[line];

256. //总行数

257. totalLine += line;

258. }

260. //判断当前行是否已经满了

261. public boolean isFullLine(int row) {

262. Cell[] cells = wall[row];

263. for (Cell cell : cells) {

264. if (cell == null) {

265. return false;

266. }

267. }

268. return true;

269. }

271. //判断游戏是否结束

272. public boolean isGameOver() {

273. Cell[] cells = nextOne.cells;

274. for (Cell cell : cells) {

275. int row = cell.getRow();

276. int col = cell.getCol();

277. if (wall[row][col] != null) {

278. return true;

279. }

280. }

281. return false;

282. }

284. private void paintState(Graphics g) {

285. if (game_state == PLING) {

286. g.drawString(show_state[PLING], 500, 660);

287. } else if (game_state == STOP) {

288. g.drawString(show_state[STOP], 500, 660);

289. } else {

290. g.drawString(show_state[OVER], 500, 660);

291. g.setColor(Color.RED);

292. g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 60));

293. g.drawString("GAME OVER!", 30, 400);

294. }

295. }

297. private void paintSource(Graphics g) {

298. g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 30));

299. g.drawString("分数: " + totalScore, 500, 250);

300. g.drawString("行数: " + totalLine, 500, 430);

301. }

303. private void paintNextOne(Graphics g) {

304. Cell[] cells = nextOne.cells;

305. for (Cell cell : cells) {

306. int x = cell.getCol() * CELL_SIZE + 370;

307. int y = cell.getRow() * CELL_SIZE + 25;

308. g.drawImage(cell.getImage(), x, y, null);

309. }

310. }

312. private void paintCurrentOne(Graphics g) {

313. Cell[] cells = currentOne.cells;

314. for (Cell cell : cells) {

315. int x = cell.getCol() * CELL_SIZE;

316. int y = cell.getRow() * CELL_SIZE;

317. g.drawImage(cell.getImage(), x, y, null);

318. }

319. }

321. private void paintWall(Graphics g) {

322. for (int i = 0; i < wall.length; i++) {

323. for (int j = 0; j < wall[i].length; j++) {

324. int x = j * CELL_SIZE;

325. int y = i * CELL_SIZE;

326. Cell cell = wall[i][j];

327. //判断是否有小方块

328. if (cell == null) {

329. g.drawRect(x, y, CELL_SIZE, CELL_SIZE);

330. } else {

331. g.drawImage(cell.getImage(), x, y, null);

332. }

333. }

334. }

335. }

337. //判断是否出界

338. public boolean outOFBounds() {

339. Cell[] cells = currentOne.cells;

340. for (Cell cell : cells) {

341. int col = cell.getCol();

342. int row = cell.getRow();

343. if (row < 0 || row > wall.length - 1 || col < 0 || col > wall[0].length-1) {

344. return true;

345. }

346. }

347. return false;

348. }

350. //按键一次，左移一次

351. public void moveleftActive() {

352. currentOne.moveLeft();

353. //判断是否越界或重合

354. if (outOFBounds() || coincide()) {

355. currentOne.moveRight();

356. }

357. }

359. //按键一次，右移一次

360. public void moveRightActive() {

361. currentOne.moveRight();

362. //判断是否越界或重合

363. if (outOFBounds() || coincide()) {

364. currentOne.moveLeft();

365. }

366. }

368. //判断是否重合

369. public boolean coincide() {

370. Cell[] cells = currentOne.cells;

371. for (Cell cell : cells) {

372. int row = cell.getRow();

373. int col = cell.getCol();

374. if (wall[row][col] != null) {

375. return true;

376. }

377. }

378. return false;

379. }

381. public static void main(String[] args) {

382. JFrame jFrame = new JFrame("俄罗斯方块");

383. //创建游戏界面

384. Tetris panel = new Tetris();

385. jFrame.add(panel);

386. //设置可见

387. jFrame.setVisible(true);

388. //设置窗口大小

389. jFrame.setSize(810, 940);

390. //设置剧中

391. jFrame.setLocationRelativeTo(null);

392. //设置窗口关闭时停止

393. jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

395. //游戏主要开始逻辑

396. panel.start();

397. }

398. }

三、效果展示

游戏开始，方快下落，右边区域展示即将下落的方块图、分数、消除的行数以及游戏切换的状态。

按下空格键，方块瞬间下落， 按下P键游戏暂停，消除一行分数为1（此处由分数池进行控制）

  按下C键游戏继续。