{% raw %}

俄罗斯方块

http://zetcode.com/tutorials/javaswingtutorial/thetetrisgame/

在本章中，我们将在 Java Swing 中创建一个俄罗斯方块游戏克隆。

俄罗斯方块

俄罗斯方块游戏是有史以来最受欢迎的计算机游戏之一。 原始游戏是由俄罗斯程序员 Alexey Pajitnov 于 1985 年设计和编程的。此后，几乎所有版本的几乎所有计算机平台上都可以使用俄罗斯方块。

俄罗斯方块被称为下降块益智游戏。 在这个游戏中，我们有七个不同的形状，称为 tetrominoes：S 形，Z 形，T 形，L 形，线形，MirroredL 形和方形。 这些形状中的每一个都形成有四个正方形。 形状从板上掉下来。 俄罗斯方块游戏的目的是移动和旋转形状，以使其尽可能地适合。 如果我们设法形成一行，则该行将被破坏并得分。 我们玩俄罗斯方块游戏，直到达到顶峰。

73.md - 图1

图：Tetrominoes

开发

我们的俄罗斯方块游戏没有图像，我们使用 Swing 绘图 API 绘制四面体。 每个计算机游戏的背后都有一个数学模型。 俄罗斯方块也是如此。

游戏背后的一些想法。

  • 我们使用Timer类创建游戏周期
  • 绘制四方块
  • 形状以正方形为单位移动（不是逐个像素移动）
  • 从数学上讲，棋盘是简单的数字列表

游戏经过简化，因此更易于理解。 游戏启动后立即开始。 我们可以通过按 p 键暂停游戏。 空格键将俄罗斯方块放到底部。 d 键将棋子下降一行。 （它可以用来加快下降速度。）游戏以恒定速度运行，没有实现加速。 分数是我们已删除的行数。

com/zetcode/Tetris.java

  1. package com.zetcode;
  3. import java.awt.BorderLayout;
  4. import java.awt.EventQueue;
  5. import javax.swing.JFrame;
  6. import javax.swing.JLabel;
  8. /*
  9. Java Tetris game clone
  11. Author: Jan Bodnar
  12. Website: http://zetcode.com
  13.  */
  14. public class Tetris extends JFrame {
  16.     private JLabel statusbar;
  18.     public Tetris() {
  20.         initUI();
  21.     }
  23.     private void initUI() {
  25.         statusbar = new JLabel(" 0");
  26.         add(statusbar, BorderLayout.SOUTH);
  28.         var board = new Board(this);
  29.         add(board);
  30.         board.start();
  32.         setTitle("Tetris");
  33.         setSize(200, 400);
  34.         setDefaultCloseOperation(EXIT_ON_CLOSE);
  35.         setLocationRelativeTo(null);
  36.     }
  38.     JLabel getStatusBar() {
  40.         return statusbar;
  41.     }
  43.     public static void main(String[] args) {
  45.         EventQueue.invokeLater(() -> {
  47.             var game = new Tetris();
  48.             game.setVisible(true);
  49.         });
  50.     }
  51. }

在Tetris中，我们设置了游戏。 我们创建一个玩游戏的棋盘。 我们创建一个状态栏。

  1. board.start();

start()方法启动俄罗斯方块游戏。

com/zetcode/Shape.java

  1. package com.zetcode;
  3. import java.util.Random;
  5. public class Shape {
  7.     protected enum Tetrominoe {
  8.         NoShape, ZShape, SShape, LineShape,
  9.         TShape, SquareShape, LShape, MirroredLShape
  10.     }
  12.     private Tetrominoe pieceShape;
  13.     private int coords[][];
  14.     private int[][][] coordsTable;
  16.     public Shape() {
  18.         coords = new int[4][2];
  19.         setShape(Tetrominoe.NoShape);
  20.     }
  22.     void setShape(Tetrominoe shape) {
  24.         coordsTable = new int[][][]{
  25.                 {{0, 0}, {0, 0}, {0, 0}, {0, 0}},
  26.                 {{0, -1}, {0, 0}, {-1, 0}, {-1, 1}},
  27.                 {{0, -1}, {0, 0}, {1, 0}, {1, 1}},
  28.                 {{0, -1}, {0, 0}, {0, 1}, {0, 2}},
  29.                 {{-1, 0}, {0, 0}, {1, 0}, {0, 1}},
  30.                 {{0, 0}, {1, 0}, {0, 1}, {1, 1}},
  31.                 {{-1, -1}, {0, -1}, {0, 0}, {0, 1}},
  32.                 {{1, -1}, {0, -1}, {0, 0}, {0, 1}}
  33.         };
  35.         for (int i = 0; i < 4; i++) {
  37.             System.arraycopy(coordsTable[shape.ordinal()], 0, coords, 0, 4);
  38.         }
  40.         pieceShape = shape;
  41.     }
  43.     private void setX(int index, int x) {
  44.         coords[index][0] = x;
  45.     }
  47.     private void setY(int index, int y) {
  48.         coords[index][1] = y;
  49.     }
  51.     int x(int index) {
  52.         return coords[index][0];
  53.     }
  55.     int y(int index) {
  56.         return coords[index][1];
  57.     }
  59.     Tetrominoe getShape() {
  60.         return pieceShape;
  61.     }
  63.     void setRandomShape() {
  65.         var r = new Random();
  66.         int x = Math.abs(r.nextInt()) % 7 + 1;
  68.         Tetrominoe[] values = Tetrominoe.values();
  69.         setShape(values[x]);
  70.     }
  72.     public int minX() {
  74.         int m = coords[0][0];
  76.         for (int i = 0; i < 4; i++) {
  78.             m = Math.min(m, coords[i][0]);
  79.         }
  81.         return m;
  82.     }
  84.     int minY() {
  86.         int m = coords[0][1];
  88.         for (int i = 0; i < 4; i++) {
  90.             m = Math.min(m, coords[i][1]);
  91.         }
  93.         return m;
  94.     }
  96.     Shape rotateLeft() {
  98.         if (pieceShape == Tetrominoe.SquareShape) {
  99.             return this;
  100.         }
  102.         var result = new Shape();
  103.         result.pieceShape = pieceShape;
  105.         for (int i = 0; i < 4; ++i) {
  107.             result.setX(i, y(i));
  108.             result.setY(i, -x(i));
  109.         }
  111.         return result;
  112.     }
  114.     Shape rotateRight() {
  116.         if (pieceShape == Tetrominoe.SquareShape) {
  117.             return this;
  118.         }
  120.         var result = new Shape();
  121.         result.pieceShape = pieceShape;
  123.         for (int i = 0; i < 4; ++i) {
  125.             result.setX(i, -y(i));
  126.             result.setY(i, x(i));
  127.         }
  129.         return result;
  130.     }
  131. }

Shape提供有关俄罗斯方块的信息。

  1. protected enum Tetrominoe {
  2.     NoShape, ZShape, SShape, LineShape,
  3.     TShape, SquareShape, LShape, MirroredLShape
  4. }

Tetrominoe拥有七个俄罗斯方块形状名称，而空的形状称为NoShape。

  1. public Shape() {
  3.     coords = new int[4][2];
  4.     setShape(Tetrominoe.NoShape);
  5. }

这是Shape类的构造器。 coords数组保存俄罗斯方块的实际坐标。

  1. coordsTable = new int[][][] {
  2.    { { 0, 0 },   { 0, 0 },   { 0, 0 },   { 0, 0 } },
  3.    { { 0, -1 },  { 0, 0 },   { -1, 0 },  { -1, 1 } },
  4.    { { 0, -1 },  { 0, 0 },   { 1, 0 },   { 1, 1 } },
  5.    { { 0, -1 },  { 0, 0 },   { 0, 1 },   { 0, 2 } },
  6.    { { -1, 0 },  { 0, 0 },   { 1, 0 },   { 0, 1 } },
  7.    { { 0, 0 },   { 1, 0 },   { 0, 1 },   { 1, 1 } },
  8.    { { -1, -1 }, { 0, -1 },  { 0, 0 },   { 0, 1 } },
  9.    { { 1, -1 },  { 0, -1 },  { 0, 0 },   { 0, 1 } }
  10. };

coordsTable数组保存我们的俄罗斯方块的所有可能的坐标值。 这是一个模板，所有零件均从该模板获取其坐标值。

  1. for (int i = 0; i < 4; i++) {
  3.     System.arraycopy(coordsTable[shape.ordinal()], 0, coords, 0, 4);
  4. }

在这里，我们将一行坐标值从coordsTable复制到俄罗斯方块的coords数组。 请注意ordinal()方法的使用。 在 C++ 中，枚举类型本质上是一个整数。 与 C++ 不同，Java 枚举是完整类，ordinal()方法返回枚举类型在枚举对象中的当前位置。

73.md - 图2

图：坐标

该图像有助于进一步了解坐标值。 coords数组保存俄罗斯方块的坐标。 下图说明了旋转的 S 形。 它具有以下坐标：（-1，1），（-1，0），（0，0）和（0，-1）。

  1. Shape rotateRight() {
  3.     if (pieceShape == Tetrominoe.SquareShape) {
  4.         return this;
  5.     }
  7.     var result = new Shape();
  8.     result.pieceShape = pieceShape;
  10.     for (int i = 0; i < 4; ++i) {
  12.         result.setX(i, -y(i));
  13.         result.setY(i, x(i));
  14.     }
  16.     return result;
  17. }

此代码将棋子向右旋转。 正方形不必旋转。 这就是为什么在Tetrominoe.SquareShape的情况下我们仅将引用返回给当前对象的原因。 查看上一张图片将有助于进一步了解旋转情况。

com/zetcode/Board.java

  1. package com.zetcode;
  3. import com.zetcode.Shape.Tetrominoe;
  5. import javax.swing.JLabel;
  6. import javax.swing.JPanel;
  7. import javax.swing.Timer;
  8. import java.awt.Color;
  9. import java.awt.Graphics;
  10. import java.awt.event.ActionEvent;
  11. import java.awt.event.ActionListener;
  12. import java.awt.event.KeyAdapter;
  13. import java.awt.event.KeyEvent;
  15. public class Board extends JPanel implements ActionListener {
  17.     private final int BOARD_WIDTH = 10;
  18.     private final int BOARD_HEIGHT = 22;
  20.     private Timer timer;
  21.     private boolean isFallingFinished = false;
  22.     private boolean isStarted = false;
  23.     private boolean isPaused = false;
  24.     private int numLinesRemoved = 0;
  25.     private int curX = 0;
  26.     private int curY = 0;
  27.     private JLabel statusbar;
  28.     private Shape curPiece;
  29.     private Tetrominoe[] board;
  31.     public Board(Tetris parent) {
  33.         initBoard(parent);
  34.     }
  36.     private void initBoard(Tetris parent) {
  38.         setFocusable(true);
  39.         curPiece = new Shape();
  40.         int DELAY = 400;
  41.         timer = new Timer(DELAY, this);
  42.         timer.start();
  44.         statusbar =  parent.getStatusBar();
  45.         board = new Tetrominoe[BOARD_WIDTH * BOARD_HEIGHT];
  46.         addKeyListener(new TAdapter());
  47.         clearBoard();
  48.     }
  50.     @Override
  51.     public void actionPerformed(ActionEvent e) {
  53.         if (isFallingFinished) {
  55.             isFallingFinished = false;
  56.             newPiece();
  57.         } else {
  59.             oneLineDown();
  60.         }
  61.     }
  63.     private int squareWidth() { return (int) getSize().getWidth() / BOARD_WIDTH; }
  64.     private int squareHeight() { return (int) getSize().getHeight() / BOARD_HEIGHT; }
  65.     private Tetrominoe shapeAt(int x, int y) { return board[(y * BOARD_WIDTH) + x]; }
  67.     void start()  {
  69.         if (isPaused) {
  70.             return;
  71.         }
  73.         isStarted = true;
  74.         isFallingFinished = false;
  75.         numLinesRemoved = 0;
  76.         clearBoard();
  78.         newPiece();
  79.         timer.start();
  80.     }
  82.     private void pause()  {
  84.         if (!isStarted) {
  85.             return;
  86.         }
  88.         isPaused = !isPaused;
  90.         if (isPaused) {
  92.             timer.stop();
  93.             statusbar.setText("paused");
  94.         } else {
  96.             timer.start();
  97.             statusbar.setText(String.valueOf(numLinesRemoved));
  98.         }
  100.         repaint();
  101.     }
  103.     private void doDrawing(Graphics g) {
  105.         var size = getSize();
  106.         int boardTop = (int) size.getHeight() - BOARD_HEIGHT * squareHeight();
  108.         for (int i = 0; i < BOARD_HEIGHT; ++i) {
  110.             for (int j = 0; j < BOARD_WIDTH; ++j) {
  112.                 Tetrominoe shape = shapeAt(j, BOARD_HEIGHT - i - 1);
  114.                 if (shape != Tetrominoe.NoShape)
  115.                     drawSquare(g, j * squareWidth(),
  116.                             boardTop + i * squareHeight(), shape);
  117.             }
  118.         }
  120.         if (curPiece.getShape() != Tetrominoe.NoShape) {
  122.             for (int i = 0; i < 4; ++i) {
  124.                 int x = curX + curPiece.x(i);
  125.                 int y = curY - curPiece.y(i);
  127.                 drawSquare(g, x * squareWidth(),
  128.                         boardTop + (BOARD_HEIGHT - y - 1) * squareHeight(),
  129.                         curPiece.getShape());
  130.             }
  131.         }
  132.     }
  134.     @Override
  135.     public void paintComponent(Graphics g) {
  137.         super.paintComponent(g);
  138.         doDrawing(g);
  139.     }
  141.     private void dropDown() {
  143.         int newY = curY;
  145.         while (newY > 0) {
  147.             if (!tryMove(curPiece, curX, newY - 1)) {
  148.                 break;
  149.             }
  151.             --newY;
  152.         }
  154.         pieceDropped();
  155.     }
  157.     private void oneLineDown()  {
  159.         if (!tryMove(curPiece, curX, curY - 1)) {
  160.             pieceDropped();
  161.         }
  162.     }
  164.     private void clearBoard() {
  166.         for (int i = 0; i < BOARD_HEIGHT * BOARD_WIDTH; ++i) {
  167.             board[i] = Tetrominoe.NoShape;
  168.         }
  169.     }
  171.     private void pieceDropped() {
  173.         for (int i = 0; i < 4; ++i) {
  175.             int x = curX + curPiece.x(i);
  176.             int y = curY - curPiece.y(i);
  177.             board[(y * BOARD_WIDTH) + x] = curPiece.getShape();
  178.         }
  180.         removeFullLines();
  182.         if (!isFallingFinished) {
  183.             newPiece();
  184.         }
  185.     }
  187.     private void newPiece()  {
  189.         curPiece.setRandomShape();
  190.         curX = BOARD_WIDTH / 2 + 1;
  191.         curY = BOARD_HEIGHT - 1 + curPiece.minY();
  193.         if (!tryMove(curPiece, curX, curY)) {
  195.             curPiece.setShape(Tetrominoe.NoShape);
  196.             timer.stop();
  197.             isStarted = false;
  198.             statusbar.setText("game over");
  199.         }
  200.     }
  202.     private boolean tryMove(Shape newPiece, int newX, int newY) {
  204.         for (int i = 0; i < 4; ++i) {
  206.             int x = newX + newPiece.x(i);
  207.             int y = newY - newPiece.y(i);
  209.             if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
  210.                 return false;
  212.             if (shapeAt(x, y) != Tetrominoe.NoShape)
  213.                 return false;
  214.         }
  216.         curPiece = newPiece;
  217.         curX = newX;
  218.         curY = newY;
  220.         repaint();
  222.         return true;
  223.     }
  225.     private void removeFullLines() {
  227.         int numFullLines = 0;
  229.         for (int i = BOARD_HEIGHT - 1; i >= 0; --i) {
  231.             boolean lineIsFull = true;
  233.             for (int j = 0; j < BOARD_WIDTH; ++j) {
  235.                 if (shapeAt(j, i) == Tetrominoe.NoShape) {
  236.                     lineIsFull = false;
  237.                     break;
  238.                 }
  239.             }
  241.             if (lineIsFull) {
  243.                 ++numFullLines;
  245.                 for (int k = i; k < BOARD_HEIGHT - 1; ++k) {
  246.                     for (int j = 0; j < BOARD_WIDTH; ++j)
  247.                         board[(k * BOARD_WIDTH) + j] = shapeAt(j, k + 1);
  248.                 }
  249.             }
  250.         }
  252.         if (numFullLines > 0) {
  254.             numLinesRemoved += numFullLines;
  255.             statusbar.setText(String.valueOf(numLinesRemoved));
  256.             isFallingFinished = true;
  257.             curPiece.setShape(Tetrominoe.NoShape);
  258.             repaint();
  259.         }
  260.     }
  262.     private void drawSquare(Graphics g, int x, int y, Tetrominoe shape)  {
  264.         Color colors[] = { new Color(0, 0, 0), new Color(204, 102, 102),
  265.                 new Color(102, 204, 102), new Color(102, 102, 204),
  266.                 new Color(204, 204, 102), new Color(204, 102, 204),
  267.                 new Color(102, 204, 204), new Color(218, 170, 0)
  268.         };
  270.         var color = colors[shape.ordinal()];
  272.         g.setColor(color);
  273.         g.fillRect(x + 1, y + 1, squareWidth() - 2, squareHeight() - 2);
  275.         g.setColor(color.brighter());
  276.         g.drawLine(x, y + squareHeight() - 1, x, y);
  277.         g.drawLine(x, y, x + squareWidth() - 1, y);
  279.         g.setColor(color.darker());
  280.         g.drawLine(x + 1, y + squareHeight() - 1,
  281.                 x + squareWidth() - 1, y + squareHeight() - 1);
  282.         g.drawLine(x + squareWidth() - 1, y + squareHeight() - 1,
  283.                 x + squareWidth() - 1, y + 1);
  285.     }
  287.     class TAdapter extends KeyAdapter {
  289.         @Override
  290.         public void keyPressed(KeyEvent e) {
  292.             if (!isStarted || curPiece.getShape() == Tetrominoe.NoShape) {
  293.                 return;
  294.             }
  296.             int keycode = e.getKeyCode();
  298.             if (keycode == 'P') {
  299.                 pause();
  300.                 return;
  301.             }
  303.             if (isPaused) {
  304.                 return;
  305.             }
  307.             switch (keycode) {
  309.                 case KeyEvent.VK_LEFT:
  310.                     tryMove(curPiece, curX - 1, curY);
  311.                     break;
  313.                 case KeyEvent.VK_RIGHT:
  314.                     tryMove(curPiece, curX + 1, curY);
  315.                     break;
  317.                 case KeyEvent.VK_DOWN:
  318.                     tryMove(curPiece.rotateRight(), curX, curY);
  319.                     break;
  321.                 case KeyEvent.VK_UP:
  322.                     tryMove(curPiece.rotateLeft(), curX, curY);
  323.                     break;
  325.                 case KeyEvent.VK_SPACE:
  326.                     dropDown();
  327.                     break;
  329.                 case KeyEvent.VK_D:
  330.                     oneLineDown();
  331.                     break;
  332.             }
  333.         }
  334.     }
  335. }

游戏逻辑位于Board中。

  1. private final int BOARD_WIDTH = 10;
  2. private final int BOARD_HEIGHT = 22;

BOARD_WIDTH和BOARD_HEIGHT常数定义电路板的大小。

  1. ...
  2. private boolean isFallingFinished = false;
  3. private boolean isStarted = false;
  4. private boolean isPaused = false;
  5. private int numLinesRemoved = 0;
  6. private int curX = 0;
  7. private int curY = 0;
  8. ...

我们初始化一些重要的变量。 isFallingFinished变量确定俄罗斯方块形状是否已完成下降，然后我们需要创建一个新形状。 numLinesRemoved计算行数，到目前为止我们已经删除了行数。 curX和curY变量确定下降的俄罗斯方块形状的实际位置。

  1. setFocusable(true);

我们必须显式调用setFocusable()方法。 从现在开始，开发板具有键盘输入。

  1. int DELAY = 400;

DELAY常数定义游戏的速度。

  1. timer = new Timer(DELAY, this);
  2. timer.start();

在指定的延迟后，Timer对象将触发一个或多个操作事件。 在我们的情况下，计时器每DELAY ms 调用一次actionPerformed()方法。

  1. @Override
  2. public void actionPerformed(ActionEvent e) {
  4.     if (isFallingFinished) {
  6.         isFallingFinished = false;
  7.         newPiece();
  8.     } else {
  10.         oneLineDown();
  11.     }
  12. }

actionPerformed()方法检查下降是否已完成。 如果是这样，将创建一个新作品。 如果不是，下降的俄罗斯方块下降了一行。

在doDrawing()方法内部，我们在板上绘制了所有对象。 这幅画有两个步骤。

  1. for (int i = 0; i < BOARD_HEIGHT; ++i) {
  3.     for (int j = 0; j < BOARD_WIDTH; ++j) {
  5.         Tetrominoe shape = shapeAt(j, BOARD_HEIGHT - i - 1);
  7.         if (shape != Tetrominoe.NoShape)
  8.             drawSquare(g, j * squareWidth(),
  9.                     boardTop + i * squareHeight(), shape);
  10.     }
  11. }

在第一步中，我们绘制掉落到板底部的所有形状或形状的其余部分。 所有正方形都记在板数组中。 我们使用shapeAt()方法访问它。

  1. if (curPiece.getShape() != Tetrominoe.NoShape) {
  3.     for (int i = 0; i < 4; ++i) {
  5.         int x = curX + curPiece.x(i);
  6.         int y = curY - curPiece.y(i);
  8.         drawSquare(g, 0 + x * squareWidth(),
  9.                    boardTop + (BOARD_HEIGHT - y - 1) * squareHeight(),
  10.                    curPiece.getShape());
  11.     }
  12. }

在第二步中，我们绘制实际的下降部分。

  1. private void dropDown() {
  3.     int newY = curY;
  5.     while (newY > 0) {
  7.         if (!tryMove(curPiece, curX, newY - 1)) {
  8.             break;
  9.         }
  11.         --newY;
  12.     }
  14.     pieceDropped();
  15. }

如果我们按 Space 键，则该片段将落到底部。 我们只是简单地尝试将一块下降到另一条俄罗斯方块下降的底部或顶部。 当俄罗斯方块结束下降时，将调用pieceDropped()。

  1. private void clearBoard() {
  3.     for (int i = 0; i < BOARD_HEIGHT * BOARD_WIDTH; ++i) {
  4.         board[i] = Tetrominoe.NoShape;
  5.     }
  6. }

clearBoard()方法用空的NoShapes填充电路板。

  1. private void pieceDropped() {
  3.     for (int i = 0; i < 4; ++i) {
  5.         int x = curX + curPiece.x(i);
  6.         int y = curY - curPiece.y(i);
  7.         board[(y * BOARD_WIDTH) + x] = curPiece.getShape();
  8.     }
  10.     removeFullLines();
  12.     if (!isFallingFinished) {
  13.         newPiece();
  14.     }
  15. }

pieceDropped()方法将下降的片段放入board数组。 棋盘再次保持了所有碎片的正方形和已经落下的碎片的剩余部分。 当一块完成落下时，就该检查是否可以去除板上的一些线了。 这是removeFullLines()方法的工作。 然后，我们尝试创建一个新作品。

  1. private void newPiece()  {
  3.     curPiece.setRandomShape();
  4.     curX = BOARD_WIDTH / 2 + 1;
  5.     curY = BOARD_HEIGHT - 1 + curPiece.minY();
  7.     if (!tryMove(curPiece, curX, curY)) {
  9.         curPiece.setShape(Tetrominoe.NoShape);
  10.         timer.stop();
  11.         isStarted = false;
  12.         statusbar.setText("game over");
  13.     }
  14. }

newPiece()方法创建一个新的俄罗斯方块。 作品获得了新的随机形状。 然后，我们计算初始curX和curY值。 如果我们不能移动到初始位置，则游戏结束。 我们加油。 计时器停止。 我们将游戏放在状态栏上的字符串上方。

  1. private boolean tryMove(Shape newPiece, int newX, int newY) {
  3.     for (int i = 0; i < 4; ++i) {
  5.         int x = newX + newPiece.x(i);
  6.         int y = newY - newPiece.y(i);
  8.         if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT) {
  9.             return false;
  10.         }
  12.         if (shapeAt(x, y) != Tetrominoe.NoShape) {
  13.             return false;
  14.         }
  15.     }
  17.     curPiece = newPiece;
  18.     curX = newX;
  19.     curY = newY;
  21.     repaint();
  23.     return true;
  24. }

tryMove()方法尝试移动俄罗斯方块。 如果该方法已达到板边界或与已经跌落的俄罗斯方块相邻，则返回false。

  1. int numFullLines = 0;
  3. for (int i = BOARD_HEIGHT - 1; i >= 0; --i) {
  5.     boolean lineIsFull = true;
  7.     for (int j = 0; j < BOARD_WIDTH; ++j) {
  9.         if (shapeAt(j, i) == Tetrominoe.NoShape) {
  10.             lineIsFull = false;
  11.             break;
  12.         }
  13.     }
  15.     if (lineIsFull) {
  17.         ++numFullLines;
  19.         for (int k = i; k < BOARD_HEIGHT - 1; ++k) {
  20.             for (int j = 0; j < BOARD_WIDTH; ++j)
  21.                 board[(k * BOARD_WIDTH) + j] = shapeAt(j, k + 1);
  22.         }
  23.     }
  24. }

在removeFullLines()方法内部，我们检查board的所有行中是否有完整的行。 如果至少有一条实线，则将其删除。 找到整条线后，我们增加计数器。 我们将整行上方的所有行向下移动一行。 这样我们就破坏了整个生产线。 注意，在我们的俄罗斯方块游戏中，我们使用了所谓的朴素重力。 这意味着正方形可能会漂浮在空白间隙上方。

每个俄罗斯方块都有四个正方形。 每个正方形都使用drawSquare()方法绘制。 俄罗斯方块有不同的颜色。

  1. g.setColor(color.brighter());
  2. g.drawLine(x, y + squareHeight() - 1, x, y);
  3. g.drawLine(x, y, x + squareWidth() - 1, y);

正方形的左侧和顶部以较亮的颜色绘制。 类似地，底部和右侧用较深的颜色绘制。 这是为了模拟 3D 边缘。

我们使用键盘控制游戏。 控制机制通过KeyAdapter实现。 这是一个覆盖keyPressed()方法的内部类。

  1. case KeyEvent.VK_LEFT:
  2.     tryMove(curPiece, curX - 1, curY);
  3.     break;

如果按向左箭头键，则尝试将下降片向左移动一个正方形。

73.md - 图3

图：俄罗斯方块

这是俄罗斯方块游戏。

{% endraw %}