原文： http://zetcode.com/gui/wxwidgets/thetetrisgame/

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

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

wxWidgets 中的俄罗斯方块游戏 - 图1

图：Tetrominoes

wxWidgets 是一个用于创建应用的工具包。 还有其他一些旨在创建计算机游戏的库。 不过，可以使用 wxWidgets 和其他应用工具包来创建简单的游戏。

开发

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

游戏背后的一些想法。

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

Shape.h

  1. #ifndef SHAPE_H
  2. #define SHAPE_H
  4. enum Tetrominoes { NoShape, ZShape, SShape, LineShape, 
  5.                   TShape, SquareShape, LShape, MirroredLShape };
  7. class Shape
  8. {
  9. public:
  10.     Shape() { SetShape(NoShape); }
  11.     void SetShape(Tetrominoes shape);
  12.     void SetRandomShape();
  14.     Tetrominoes GetShape() const { return pieceShape; }
  15.     int x(int index) const { return coords[index][0]; }
  16.     int y(int index) const { return coords[index][1]; }
  18.     int MinX() const;
  19.     int MaxX() const;
  20.     int MinY() const;
  21.     int MaxY() const;
  23.     Shape RotateLeft() const;
  24.     Shape RotateRight() const;
  26. private:
  27.     void SetX(int index, int x) { coords[index][0] = x; }
  28.     void SetY(int index, int y) { coords[index][1] = y; }
  29.     Tetrominoes pieceShape;
  30.     int coords[4][2];
  31. };
  33. #endif

Shape.cpp

  1. #include <stdlib.h>
  2. #include <algorithm>
  3. #include "Shape.h"
  5. using namespace std;
  7. void Shape::SetShape(Tetrominoes shape)
  8. {
  9.     static const int coordsTable[8][4][2] = {
  10.         { { 0, 0 },   { 0, 0 },   { 0, 0 },   { 0, 0 } },
  11.         { { 0, -1 },  { 0, 0 },   { -1, 0 },  { -1, 1 } },
  12.         { { 0, -1 },  { 0, 0 },   { 1, 0 },   { 1, 1 } },
  13.         { { 0, -1 },  { 0, 0 },   { 0, 1 },   { 0, 2 } },
  14.         { { -1, 0 },  { 0, 0 },   { 1, 0 },   { 0, 1 } },
  15.         { { 0, 0 },   { 1, 0 },   { 0, 1 },   { 1, 1 } },
  16.         { { -1, -1 }, { 0, -1 },  { 0, 0 },   { 0, 1 } },
  17.         { { 1, -1 },  { 0, -1 },  { 0, 0 },   { 0, 1 } }
  18.     };
  20.     for (int i = 0; i < 4 ; i++) {
  21.         for (int j = 0; j < 2; ++j)
  22.             coords[i][j] = coordsTable[shape][i][j];
  23.     }
  24.     pieceShape = shape;
  25. }
  27. void Shape::SetRandomShape()
  28. {
  29.   int x = rand() % 7 + 1;
  30.   SetShape(Tetrominoes(x));
  31. }
  33. int Shape::MinX() const
  34. {
  35.   int m = coords[0][0];
  36.   for (int i=0; i<4; i++) {
  37.       m = min(m, coords[i][0]);
  38.   }
  39.   return m;
  40. }
  42. int Shape::MaxX() const
  43. {
  44.   int m = coords[0][0];
  45.   for (int i=0; i<4; i++) {
  46.       m = max(m, coords[i][0]);
  47.   }
  48.   return m;
  49. }
  51. int Shape::MinY() const
  52. {
  53.   int m = coords[0][1];
  54.   for (int i=0; i<4; i++) {
  55.       m = min(m, coords[i][1]);
  56.   }
  57.   return m;
  58. }
  60. int Shape::MaxY() const
  61. {
  62.   int m = coords[0][1];
  63.   for (int i=0; i<4; i++) {
  64.       m = max(m, coords[i][1]);
  65.   }
  66.   return m;
  67. }
  69. Shape Shape::RotateLeft() const
  70. {
  71.     if (pieceShape == SquareShape)
  72.         return *this;
  74.     Shape result;
  75.     result.pieceShape = pieceShape;
  76.     for (int i = 0; i < 4; ++i) {
  77.         result.SetX(i, y(i));
  78.         result.SetY(i, -x(i));
  79.     }
  80.     return result;
  81. }
  83. Shape Shape::RotateRight() const
  84. {
  85.     if (pieceShape == SquareShape)
  86.         return *this;
  88.     Shape result;
  89.     result.pieceShape = pieceShape;
  90.     for (int i = 0; i < 4; ++i) {
  91.         result.SetX(i, -y(i));
  92.         result.SetY(i, x(i));
  93.     }
  94.     return result;
  95. }

Board.h

  1. #ifndef BOARD_H
  2. #define BOARD_H
  4. #include "Shape.h"
  5. #include <wx/wx.h>
  7. class Board : public wxPanel
  8. {
  10. public:
  11.     Board(wxFrame *parent);
  12.     void Start();
  13.     void Pause();
  14.     void linesRemovedChanged(int numLines);
  16. protected:
  17.     void OnPaint(wxPaintEvent& event);
  18.     void OnKeyDown(wxKeyEvent& event);
  19.     void OnTimer(wxCommandEvent& event);
  21. private:
  22.     enum { BoardWidth = 10, BoardHeight = 22 };
  24.     Tetrominoes & ShapeAt(int x, int y) { return board[(y * BoardWidth) + x]; }
  26.     int SquareWidth() { return GetClientSize().GetWidth() / BoardWidth; }
  27.     int SquareHeight() { return GetClientSize().GetHeight() / BoardHeight; }
  28.     void ClearBoard();
  29.     void DropDown();
  30.     void OneLineDown();
  31.     void PieceDropped();
  32.     void RemoveFullLines();
  33.     void NewPiece();
  34.     bool TryMove(const Shape& newPiece, int newX, int newY);
  35.     void DrawSquare(wxPaintDC &dc, int x, int y, Tetrominoes shape);
  37.     wxTimer *timer;
  38.     bool isStarted;
  39.     bool isPaused;
  40.     bool isFallingFinished;
  41.     Shape curPiece;
  42.     int curX;
  43.     int curY;
  44.     int numLinesRemoved;
  45.     Tetrominoes board[BoardWidth * BoardHeight];
  46.     wxStatusBar *m_stsbar;
  47. };
  49. #endif

Board.cpp

  1. #include "Board.h"
  3. Board::Board(wxFrame *parent)
  4.        : wxPanel(parent, wxID_ANY, wxDefaultPosition,
  5.              wxDefaultSize, wxBORDER_NONE)
  6. {
  7.     timer = new wxTimer(this, 1);
  9.     m_stsbar = parent->GetStatusBar();
  10.     isFallingFinished = false;
  11.     isStarted = false;
  12.     isPaused = false;
  13.     numLinesRemoved = 0;
  14.     curX = 0;
  15.     curY = 0;
  17.     ClearBoard();  
  19.     Connect(wxEVT_PAINT, wxPaintEventHandler(Board::OnPaint));
  20.     Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(Board::OnKeyDown));
  21.     Connect(wxEVT_TIMER, wxCommandEventHandler(Board::OnTimer));
  22. }
  24. void Board::Start()
  25. {
  26.     if (isPaused)
  27.         return;
  29.     isStarted = true;
  30.     isFallingFinished = false;
  31.     numLinesRemoved = 0;
  32.     ClearBoard();
  34.     NewPiece();
  35.     timer->Start(300);
  36. }
  38. void Board::Pause()
  39. {
  40.     if (!isStarted)
  41.         return;
  43.     isPaused = !isPaused;
  44.     if (isPaused) {
  45.         timer->Stop();
  46.         m_stsbar->SetStatusText(wxT("paused"));
  47.     } else {
  48.         timer->Start(300);
  49.         wxString str;
  50.         str.Printf(wxT("%d"), numLinesRemoved);
  51.         m_stsbar->SetStatusText(str);
  52.     }
  53.     Refresh();
  54. }
  56. void Board::OnPaint(wxPaintEvent& event)
  57. {
  58.     wxPaintDC dc(this);
  60.     wxSize size = GetClientSize();
  61.     int boardTop = size.GetHeight() - BoardHeight * SquareHeight();
  63.     for (int i = 0; i < BoardHeight; ++i) {
  64.         for (int j = 0; j < BoardWidth; ++j) {
  65.             Tetrominoes shape = ShapeAt(j, BoardHeight - i - 1);
  66.             if (shape != NoShape)
  67.                 DrawSquare(dc, 0 + j * SquareWidth(),
  68.                            boardTop + i * SquareHeight(), shape);
  69.         }
  70.     }
  72.     if (curPiece.GetShape() != NoShape) {
  73.         for (int i = 0; i < 4; ++i) {
  74.             int x = curX + curPiece.x(i);
  75.             int y = curY - curPiece.y(i);
  76.             DrawSquare(dc, 0 + x * SquareWidth(),
  77.                        boardTop + (BoardHeight - y - 1) * SquareHeight(),
  78.                        curPiece.GetShape());
  79.         }
  80.     }
  81. }
  83. void Board::OnKeyDown(wxKeyEvent& event)
  84. {
  85.     if (!isStarted || curPiece.GetShape() == NoShape) {  
  86.         event.Skip();
  87.         return;
  88.     }
  90.     int keycode = event.GetKeyCode();
  92.     if (keycode == 'p' || keycode == 'P') {
  93.     Pause();
  94.         return;
  95.     }
  97.     if (isPaused)
  98.         return;
  100.     switch (keycode) {
  101.     case WXK_LEFT:
  102.         TryMove(curPiece, curX - 1, curY);
  103.         break;
  104.     case WXK_RIGHT:
  105.         TryMove(curPiece, curX + 1, curY);
  106.         break;
  107.     case WXK_DOWN:
  108.         TryMove(curPiece.RotateRight(), curX, curY);
  109.         break;
  110.     case WXK_UP:
  111.         TryMove(curPiece.RotateLeft(), curX, curY);
  112.         break;
  113.     case WXK_SPACE:
  114.         DropDown();
  115.         break;
  116.     case 'd':
  117.         OneLineDown();
  118.         break;
  119.     case 'D':
  120.         OneLineDown();
  121.         break;
  122.     default:
  123.         event.Skip();
  124.     }
  126. }
  128. void Board::OnTimer(wxCommandEvent& event)
  129. {
  130.     if (isFallingFinished) {
  131.         isFallingFinished = false;
  132.         NewPiece();
  133.     } else {
  134.         OneLineDown();
  135.     }
  136. }
  138. void Board::ClearBoard()
  139. {
  140.     for (int i = 0; i < BoardHeight * BoardWidth; ++i)
  141.         board[i] = NoShape;
  142. }
  144. void Board::DropDown()
  145. {
  146.     int newY = curY;
  147.     while (newY > 0) {
  148.         if (!TryMove(curPiece, curX, newY - 1))
  149.             break;
  150.         --newY;
  151.     }
  152.     PieceDropped();
  153. }
  155. void Board::OneLineDown()
  156. {
  157.     if (!TryMove(curPiece, curX, curY - 1))
  158.         PieceDropped();
  159. }
  161. void Board::PieceDropped()
  162. {
  163.     for (int i = 0; i < 4; ++i) {
  164.         int x = curX + curPiece.x(i);
  165.         int y = curY - curPiece.y(i);
  166.         ShapeAt(x, y) = curPiece.GetShape();
  167.     }
  169.     RemoveFullLines();
  171.     if (!isFallingFinished)
  172.         NewPiece();
  173. }
  175. void Board::RemoveFullLines()
  176. {
  177.      int numFullLines = 0;
  179.      for (int i = BoardHeight - 1; i >= 0; --i) {
  180.          bool lineIsFull = true;
  182.          for (int j = 0; j < BoardWidth; ++j) {
  183.              if (ShapeAt(j, i) == NoShape) {
  184.                  lineIsFull = false;
  185.                  break;
  186.              }
  187.          }
  189.          if (lineIsFull) {
  190.              ++numFullLines;
  191.              for (int k = i; k < BoardHeight - 1; ++k) {
  192.                  for (int j = 0; j < BoardWidth; ++j)
  193.                      ShapeAt(j, k) = ShapeAt(j, k + 1);
  194.              }
  195.          }
  196.      }
  198.      if (numFullLines > 0) {
  199.          numLinesRemoved += numFullLines;
  200.          wxString str;
  201.      str.Printf(wxT("%d"), numLinesRemoved);
  202.          m_stsbar->SetStatusText(str);
  204.          isFallingFinished = true;
  205.          curPiece.SetShape(NoShape);
  206.          Refresh();
  207.      }
  208.  }
  210. void Board::NewPiece()
  211. {
  212.     curPiece.SetRandomShape();
  213.     curX = BoardWidth / 2 + 1;
  214.     curY = BoardHeight - 1 + curPiece.MinY();
  216.     if (!TryMove(curPiece, curX, curY)) {
  217.         curPiece.SetShape(NoShape);
  218.         timer->Stop();
  219.         isStarted = false;
  220.         m_stsbar->SetStatusText(wxT("game over"));
  221.     }
  222. }
  224. bool Board::TryMove(const Shape& newPiece, int newX, int newY)
  225. {
  226.     for (int i = 0; i < 4; ++i) {
  227.         int x = newX + newPiece.x(i);
  228.         int y = newY - newPiece.y(i);
  229.         if (x < 0 || x >= BoardWidth || y < 0 || y >= BoardHeight)
  230.             return false;
  231.         if (ShapeAt(x, y) != NoShape)
  232.             return false;
  233.     }
  235.     curPiece = newPiece;
  236.     curX = newX;
  237.     curY = newY;
  238.     Refresh();
  239.     return true;
  240. }
  242. void Board::DrawSquare(wxPaintDC& dc, int x, int y, Tetrominoes shape)
  243. {
  244.     static wxColour colors[] = { wxColour(0, 0, 0), wxColour(204, 102, 102), 
  245.              wxColour(102, 204, 102), wxColour(102, 102, 204), 
  246.              wxColour(204, 204, 102), wxColour(204, 102, 204), 
  247.              wxColour(102, 204, 204), wxColour(218, 170, 0) };
  249.     static wxColour light[] = { wxColour(0, 0, 0), wxColour(248, 159, 171),
  250.              wxColour(121, 252, 121), wxColour(121, 121, 252), 
  251.              wxColour(252, 252, 121), wxColour(252, 121, 252), 
  252.              wxColour(121, 252, 252), wxColour(252, 198, 0) };
  254.     static wxColour dark[] = { wxColour(0, 0, 0), wxColour(128, 59, 59), 
  255.              wxColour(59, 128, 59), wxColour(59, 59, 128), 
  256.              wxColour(128, 128, 59), wxColour(128, 59, 128), 
  257.              wxColour(59, 128, 128), wxColour(128, 98, 0) };
  259.     wxPen pen(light[int(shape)]);
  260.     pen.SetCap(wxCAP_PROJECTING);
  261.     dc.SetPen(pen);
  263.     dc.DrawLine(x, y + SquareHeight() - 1, x, y);
  264.     dc.DrawLine(x, y, x + SquareWidth() - 1, y);
  266.     wxPen darkpen(dark[int(shape)]);
  267.     darkpen.SetCap(wxCAP_PROJECTING);
  268.     dc.SetPen(darkpen);
  270.     dc.DrawLine(x + 1, y + SquareHeight() - 1,
  271.         x + SquareWidth() - 1, y + SquareHeight() - 1);
  272.     dc.DrawLine(x + SquareWidth() - 1, 
  273.         y + SquareHeight() - 1, x + SquareWidth() - 1, y + 1);
  275.     dc.SetPen(*wxTRANSPARENT_PEN);
  276.     dc.SetBrush(wxBrush(colors[int(shape)])); 
  277.     dc.DrawRectangle(x + 1, y + 1, SquareWidth() - 2, 
  278.         SquareHeight() - 2);
  279. }

Tetris.h

  1. #include <wx/wx.h>
  3. class Tetris : public wxFrame
  4. {
  5. public:
  6.     Tetris(const wxString& title);
  8. };

Tetris.cpp

  1. #include "Tetris.h"
  2. #include "Board.h"
  4. Tetris::Tetris(const wxString& title)
  5.        : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(180, 380))
  6. {
  7.   wxStatusBar *sb = CreateStatusBar();
  8.   sb->SetStatusText(wxT("0"));
  9.   Board *board = new Board(this);
  10.   board->SetFocus();
  11.   board->Start();
  12. }

main.h

  1. #include <wx/wx.h>
  3. class MyApp : public wxApp
  4. {
  5.   public:
  6.     virtual bool OnInit();
  8. };

main.cpp

  1. #include "main.h"
  2. #include "Tetris.h"
  4. IMPLEMENT_APP(MyApp)
  6. bool MyApp::OnInit()
  7. {
  8.     srand(time(NULL));
  9.     Tetris *tetris = new Tetris(wxT("Tetris"));
  10.     tetris->Centre();
  11.     tetris->Show(true);
  13.     return true;
  14. }

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

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

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

  1. for (int i = 0; i < BoardHeight; ++i) {
  2.     for (int j = 0; j < BoardWidth; ++j) {
  3.         Tetrominoes shape = ShapeAt(j, BoardHeight - i - 1);
  4.         if (shape != NoShape)
  5.             DrawSquare(dc, 0 + j * SquareWidth(),
  6.                     boardTop + i * SquareHeight(), shape);
  7.     }
  8. }

游戏的绘图分为两个步骤。 在第一步中，我们绘制所有形状或已放置到板底部的形状的其余部分。 所有正方形都记在board数组中。 我们使用ShapeAt()方法访问它。

  1. if (curPiece.GetShape() != NoShape) {
  2.     for (int i = 0; i < 4; ++i) {
  3.         int x = curX + curPiece.x(i);
  4.         int y = curY - curPiece.y(i);
  5.         DrawSquare(dc, 0 + x * SquareWidth(),
  6.                    boardTop + (BoardHeight - y - 1) * SquareHeight(),
  7.                    curPiece.GetShape());
  8.     }
  9. }

下一步是绘制掉落的实际零件。

  1. ...
  2. switch (keycode) {
  3. case WXK_LEFT:
  4.     TryMove(curPiece, curX - 1, curY);
  5.     break;
  6. ...

在Board::OnKeyDown()方法中，我们检查按键是否按下。 如果按向左箭头键，我们将尝试将棋子向左移动。 我们说尝试，因为这片可能无法移动。

  1. void Board::OnTimer(wxCommandEvent& event)
  2. {
  3.     if (isFallingFinished) {
  4.         isFallingFinished = false;
  5.         NewPiece();
  6.     } else {
  7.         OneLineDown();
  8.     }
  9. }

在Board::OnTimer()方法中，我们可以创建一个新的片段，将前一个片段放到底部，或者将下降的片段向下移动一行。

  1. void Board::DropDown()
  2. {
  3.     int newY = curY;
  4.     while (newY > 0) {
  5.         if (!TryMove(curPiece, curX, newY - 1))
  6.             break;
  7.         --newY;
  8.     }
  9.     PieceDropped();
  10. }

Board::DropDown()方法将下落的形状立即下降到板的底部。 当我们按下空格键时会发生这种情况。

  1. void Board::PieceDropped()
  2. {
  3.     for (int i = 0; i < 4; ++i) {
  4.         int x = curX + curPiece.x(i);
  5.         int y = curY - curPiece.y(i);
  6.         ShapeAt(x, y) = curPiece.GetShape();
  7.     }
  9.     RemoveFullLines();
  11.     if (!isFallingFinished)
  12.         NewPiece();
  13. }

在Board::PieceDropped()方法中，我们将当前形状设置为其最终位置。 我们调用RemoveFullLines()方法来检查是否至少有一个完整的行。 如果尚未在Board::PieceDropped()方法中创建新的俄罗斯方块形状，则可以创建一个新的俄罗斯方块形状。

  1. if (lineIsFull) {
  2.     ++numFullLines;
  3.     for (int k = i; k < BoardHeight - 1; ++k) {
  4.         for (int j = 0; j < BoardWidth; ++j)
  5.             ShapeAt(j, k) = ShapeAt(j, k + 1);
  6.     }
  7. }

此代码将删除所有行。 找到整条线后，我们增加计数器。 我们将整行上方的所有行向下移动一行。 这样我们就破坏了整个生产线。 注意，在俄罗斯方块游戏中，我们使用了朴素引力。 这意味着正方形可能会漂浮在空白间隙上方。

  1. void Board::NewPiece()
  2. {
  3.     curPiece.SetRandomShape();
  4.     curX = BoardWidth / 2 + 1;
  5.     curY = BoardHeight - 1 + curPiece.MinY();
  7.     if (!TryMove(curPiece, curX, curY)) {
  8.         curPiece.SetShape(NoShape);
  9.         timer->Stop();
  10.         isStarted = false;
  11.         m_stsbar->SetStatusText(wxT("game over"));
  12.     }
  13. }

Board::NewPiece()方法随机创建一个新的俄罗斯方块。 如果棋子无法进入其初始位置，则游戏结束。

  1. bool Board::TryMove(const Shape& newPiece, int newX, int newY)
  2. {
  3.     for (int i = 0; i < 4; ++i) {
  4.         int x = newX + newPiece.x(i);
  5.         int y = newY - newPiece.y(i);
  6.         if (x < 0 || x >= BoardWidth || y < 0 || y >= BoardHeight)
  7.             return false;
  8.         if (ShapeAt(x, y) != NoShape)
  9.             return false;
  10.     }
  12.     curPiece = newPiece;
  13.     curX = newX;
  14.     curY = newY;
  15.     Refresh();
  16.     return true;
  17. }

在Board::TryMove()方法中，我们尝试移动形状。 如果形状在棋盘的边缘或与其他形状相邻，则返回false。 否则，我们将当前下降形状放置到新位置并返回true。

Shape类保存有关俄罗斯方块的信息。

  1. for (int i = 0; i < 4 ; i++) {
  2.     for (int j = 0; j < 2; ++j)
  3.         coords[i][j] = coordsTable[shape][i][j];
  4. }

coords数组保存俄罗斯方块的坐标。 例如，数字{0, -1}, {0, 0}, {1, 0}, {1, 1}表示旋转的 S 形。 下图说明了形状。

wxWidgets 中的俄罗斯方块游戏 - 图2

图：坐标

当绘制当前下降片时，将其绘制在curX和curY位置。 然后，我们查看坐标表并绘制所有四个正方形。

wxWidgets 中的俄罗斯方块游戏 - 图3

图：俄罗斯方块

这是 wxWidgets 中的俄罗斯方块游戏。