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

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

俄罗斯方块

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

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

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

图：Tetrominoes

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

创建计算机游戏是增强编程技能的好方法。

开发

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

游戏背后的一些想法：

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

该代码包括四个类别：Tetris，Board，Tetrominoe和Shape。 Tetris类设置游戏。 Board是编写游戏逻辑的地方。 Tetrominoe类包含所有俄罗斯方块的名称，Shape类包含俄罗斯方块的代码。

  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  4. """
  5. ZetCode PyQt4 tutorial 
  7. This is a Tetris game clone.
  9. author: Jan Bodnar
  10. website: zetcode.com 
  11. last edited: October 2013
  12. """
  14. import sys, random
  15. from PyQt4 import QtCore, QtGui
  17. class Tetris(QtGui.QMainWindow):
  19.     def __init__(self):
  20.         super(Tetris, self).__init__()
  22.         self.initUI()
  24.     def initUI(self):    
  26.         self.tboard = Board(self)
  27.         self.setCentralWidget(self.tboard)
  29.         self.statusbar = self.statusBar()        
  30.         self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)
  32.         self.tboard.start()
  34.         self.resize(180, 380)
  35.         self.center()
  36.         self.setWindowTitle('Tetris')        
  37.         self.show()
  39.     def center(self):
  41.         screen = QtGui.QDesktopWidget().screenGeometry()
  42.         size = self.geometry()
  43.         self.move((screen.width()-size.width())/2, 
  44.             (screen.height()-size.height())/2)
  46. class Board(QtGui.QFrame):
  48.     msg2Statusbar = QtCore.pyqtSignal(str)
  50.     BoardWidth = 10
  51.     BoardHeight = 22
  52.     Speed = 300
  54.     def __init__(self, parent):
  55.         super(Board, self).__init__(parent)
  57.         self.initBoard()
  59.     def initBoard(self):     
  61.         self.timer = QtCore.QBasicTimer()
  62.         self.isWaitingAfterLine = False
  64.         self.curX = 0
  65.         self.curY = 0
  66.         self.numLinesRemoved = 0
  67.         self.board = []
  69.         self.setFocusPolicy(QtCore.Qt.StrongFocus)
  70.         self.isStarted = False
  71.         self.isPaused = False
  72.         self.clearBoard()
  74.     def shapeAt(self, x, y):
  75.         return self.board[(y * Board.BoardWidth) + x]
  77.     def setShapeAt(self, x, y, shape):
  78.         self.board[(y * Board.BoardWidth) + x] = shape
  80.     def squareWidth(self):
  81.         return self.contentsRect().width() / Board.BoardWidth
  83.     def squareHeight(self):
  84.         return self.contentsRect().height() / Board.BoardHeight
  86.     def start(self):
  88.         if self.isPaused:
  89.             return
  91.         self.isStarted = True
  92.         self.isWaitingAfterLine = False
  93.         self.numLinesRemoved = 0
  94.         self.clearBoard()
  96.         self.msg2Statusbar.emit(str(self.numLinesRemoved))
  98.         self.newPiece()
  99.         self.timer.start(Board.Speed, self)
  101.     def pause(self):
  103.         if not self.isStarted:
  104.             return
  106.         self.isPaused = not self.isPaused
  108.         if self.isPaused:
  109.             self.timer.stop()
  110.             self.msg2Statusbar.emit("paused")
  112.         else:
  113.             self.timer.start(Board.Speed, self)
  114.             self.msg2Statusbar.emit(str(self.numLinesRemoved))
  116.         self.update()
  118.     def paintEvent(self, event):
  120.         painter = QtGui.QPainter(self)
  121.         rect = self.contentsRect()
  123.         boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()
  125.         for i in range(Board.BoardHeight):
  126.             for j in range(Board.BoardWidth):
  127.                 shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  129.                 if shape != Tetrominoe.NoShape:
  130.                     self.drawSquare(painter,
  131.                         rect.left() + j * self.squareWidth(),
  132.                         boardTop + i * self.squareHeight(), shape)
  134.         if self.curPiece.shape() != Tetrominoe.NoShape:
  136.             for i in range(4):
  138.                 x = self.curX + self.curPiece.x(i)
  139.                 y = self.curY - self.curPiece.y(i)
  140.                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),
  141.                     boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
  142.                     self.curPiece.shape())
  144.     def keyPressEvent(self, event):
  146.         if not self.isStarted or self.curPiece.shape() == Tetrominoe.NoShape:
  147.             super(Board, self).keyPressEvent(event)
  148.             return
  150.         key = event.key()
  152.         if key == QtCore.Qt.Key_P:
  153.             self.pause()
  154.             return
  156.         if self.isPaused:
  157.             return
  159.         elif key == QtCore.Qt.Key_Left:
  160.             self.tryMove(self.curPiece, self.curX - 1, self.curY)
  162.         elif key == QtCore.Qt.Key_Right:
  163.             self.tryMove(self.curPiece, self.curX + 1, self.curY)
  165.         elif key == QtCore.Qt.Key_Down:
  166.             self.tryMove(self.curPiece.rotateRight(), self.curX, self.curY)
  168.         elif key == QtCore.Qt.Key_Up:
  169.             self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)
  171.         elif key == QtCore.Qt.Key_Space:
  172.             self.dropDown()
  174.         elif key == QtCore.Qt.Key_D:
  175.             self.oneLineDown()
  177.         else:
  178.             super(Board, self).keyPressEvent(event)
  180.     def timerEvent(self, event):
  182.         if event.timerId() == self.timer.timerId():
  184.             if self.isWaitingAfterLine:
  185.                 self.isWaitingAfterLine = False
  186.                 self.newPiece()
  187.             else:
  188.                 self.oneLineDown()
  190.         else:
  191.             super(Board, self).timerEvent(event)
  193.     def clearBoard(self):
  195.         for i in range(Board.BoardHeight * Board.BoardWidth):
  196.             self.board.append(Tetrominoe.NoShape)
  198.     def dropDown(self):
  200.         newY = self.curY
  202.         while newY > 0:
  204.             if not self.tryMove(self.curPiece, self.curX, newY - 1):
  205.                 break
  207.             newY -= 1
  209.         self.pieceDropped()
  211.     def oneLineDown(self):
  213.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
  214.             self.pieceDropped()
  216.     def pieceDropped(self):
  218.         for i in range(4):
  220.             x = self.curX + self.curPiece.x(i)
  221.             y = self.curY - self.curPiece.y(i)
  222.             self.setShapeAt(x, y, self.curPiece.shape())
  224.         self.removeFullLines()
  226.         if not self.isWaitingAfterLine:
  227.             self.newPiece()
  229.     def removeFullLines(self):
  231.         numFullLines = 0
  232.         rowsToRemove = []
  234.         for i in range(Board.BoardHeight):
  236.             n = 0
  237.             for j in range(Board.BoardWidth):
  238.                 if not self.shapeAt(j, i) == Tetrominoe.NoShape:
  239.                     n = n + 1
  241.             if n == 10:
  242.                 rowsToRemove.append(i)
  244.         rowsToRemove.reverse()
  246.         for m in rowsToRemove:
  248.             for k in range(m, Board.BoardHeight):
  249.                 for l in range(Board.BoardWidth):
  250.                         self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  252.         numFullLines = numFullLines + len(rowsToRemove)
  254.         if numFullLines > 0:
  256.             self.numLinesRemoved = self.numLinesRemoved + numFullLines
  257.             self.msg2Statusbar.emit(str(self.numLinesRemoved))
  259.             self.isWaitingAfterLine = True
  260.             self.curPiece.setShape(Tetrominoe.NoShape)
  261.             self.update()
  263.     def newPiece(self):
  265.         self.curPiece = Shape()
  266.         self.curPiece.setRandomShape()
  267.         self.curX = Board.BoardWidth / 2 + 1
  268.         self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
  270.         #print self.curY
  272.         if not self.tryMove(self.curPiece, self.curX, self.curY):
  274.             self.curPiece.setShape(Tetrominoe.NoShape)
  275.             self.timer.stop()
  276.             self.isStarted = False
  277.             self.msg2Statusbar.emit("Game over")
  279.     def tryMove(self, newPiece, newX, newY):
  281.         for i in range(4):
  283.             x = newX + newPiece.x(i)
  284.             y = newY - newPiece.y(i)
  286.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  287.                 return False
  289.             if self.shapeAt(x, y) != Tetrominoe.NoShape:
  290.                 return False
  292.         self.curPiece = newPiece
  293.         self.curX = newX
  294.         self.curY = newY
  295.         self.update()
  297.         return True
  299.     def drawSquare(self, painter, x, y, shape):
  301.         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
  302.                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
  304.         color = QtGui.QColor(colorTable[shape])
  305.         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2, 
  306.             self.squareHeight() - 2, color)
  308.         painter.setPen(color.light())
  309.         painter.drawLine(x, y + self.squareHeight() - 1, x, y)
  310.         painter.drawLine(x, y, x + self.squareWidth() - 1, y)
  312.         painter.setPen(color.dark())
  313.         painter.drawLine(x + 1, y + self.squareHeight() - 1,
  314.             x + self.squareWidth() - 1, y + self.squareHeight() - 1)
  315.         painter.drawLine(x + self.squareWidth() - 1, 
  316.             y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
  318. class Tetrominoe(object):
  320.     NoShape = 0
  321.     ZShape = 1
  322.     SShape = 2
  323.     LineShape = 3
  324.     TShape = 4
  325.     SquareShape = 5
  326.     LShape = 6
  327.     MirroredLShape = 7
  329. class Shape(object):
  331.     coordsTable = (
  332.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
  333.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
  334.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
  335.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
  336.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
  337.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
  338.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
  339.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
  340.     )
  342.     def __init__(self):
  344.         self.coords = [[0,0] for i in range(4)]
  345.         self.pieceShape = Tetrominoe.NoShape
  347.         self.setShape(Tetrominoe.NoShape)
  349.     def shape(self):
  350.         return self.pieceShape
  352.     def setShape(self, shape):
  354.         table = Shape.coordsTable[shape]
  356.         for i in range(4):
  357.             for j in range(2):
  358.                 self.coords[i][j] = table[i][j]
  360.         self.pieceShape = shape
  362.     def setRandomShape(self):
  363.         self.setShape(random.randint(1, 7))
  365.     def x(self, index):
  366.         return self.coords[index][0]
  368.     def y(self, index):
  369.         return self.coords[index][1]
  371.     def setX(self, index, x):
  372.         self.coords[index][0] = x
  374.     def setY(self, index, y):
  375.         self.coords[index][1] = y
  377.     def minX(self):
  379.         m = self.coords[0][0]
  380.         for i in range(4):
  381.             m = min(m, self.coords[i][0])
  383.         return m
  385.     def maxX(self):
  387.         m = self.coords[0][0]
  388.         for i in range(4):
  389.             m = max(m, self.coords[i][0])
  391.         return m
  393.     def minY(self):
  395.         m = self.coords[0][1]
  396.         for i in range(4):
  397.             m = min(m, self.coords[i][1])
  399.         return m
  401.     def maxY(self):
  403.         m = self.coords[0][1]
  404.         for i in range(4):
  405.             m = max(m, self.coords[i][1])
  407.         return m
  409.     def rotateLeft(self):
  411.         if self.pieceShape == Tetrominoe.SquareShape:
  412.             return self
  414.         result = Shape()
  415.         result.pieceShape = self.pieceShape
  417.         for i in range(4):
  419.             result.setX(i, self.y(i))
  420.             result.setY(i, -self.x(i))
  422.         return result
  424.     def rotateRight(self):
  426.         if self.pieceShape == Tetrominoe.SquareShape:
  427.             return self
  429.         result = Shape()
  430.         result.pieceShape = self.pieceShape
  432.         for i in range(4):
  434.             result.setX(i, -self.y(i))
  435.             result.setY(i, self.x(i))
  437.         return result
  439. def main():
  441.     app = QtGui.QApplication([])
  442.     tetris = Tetris()    
  443.     sys.exit(app.exec_())
  445. if __name__ == '__main__':
  446.     main()

游戏进行了简化，以便于理解。 游戏启动后立即开始。 我们可以通过按 p 键暂停游戏。 Space 键将使俄罗斯方块立即下降到底部。 游戏以恒定速度进行，没有实现加速。 分数是我们已删除的行数。

  1. self.tboard = Board(self)
  2. self.setCentralWidget(self.tboard)

创建Board类的实例，并将其设置为应用的中央窗口小部件。

  1. self.statusbar = self.statusBar()        
  2. self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)

我们创建一个状态栏，在其中显示消息。 我们将显示三种可能的消息：已删除的行数，暂停的消息或游戏结束消息。 msg2Statusbar是在Board类中实现的自定义信号。 showMessage()是一种内置方法，可在状态栏上显示一条消息。

  1. self.tboard.start()

这条线启动了游戏。

  1. class Board(QtGui.QFrame):
  3.     msg2Statusbar = QtCore.pyqtSignal(str)
  4. ...

创建自定义信号。 msg2Statusbar是当我们要向状态栏写消息或乐谱时发出的信号。

  1. BoardWidth = 10
  2. BoardHeight = 22
  3. Speed = 300

这些是Board's类变量。 BoardWidth和BoardHeight以块为单位定义电路板的大小。 Speed定义游戏的速度。 每 300 毫秒将开始一个新的游戏周期。

  1. ...
  2. self.curX = 0
  3. self.curY = 0
  4. self.numLinesRemoved = 0
  5. self.board = []
  6. ...

在initBoard()方法中，我们初始化了一些重要的变量。 变量self.board是从 0 到 7 的数字的列表。它表示各种形状的位置以及板上形状的其余部分。

  1. def shapeAt(self, x, y):
  2.     return self.board[(y * Board.BoardWidth) + x]

shapeAt()方法确定给定块上的形状类型。

  1. def squareWidth(self):
  2.     return self.contentsRect().width() / Board.BoardWidth

电路板可以动态调整大小。 结果，块的大小可能改变。 squareWidth()计算单个正方形的宽度（以像素为单位）并将其返回。 Board.BoardWidth是板的大小，以块为单位。

  1. for i in range(Board.BoardHeight):
  2.     for j in range(Board.BoardWidth):
  3.         shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  5.         if shape != Tetrominoe.NoShape:
  6.             self.drawSquare(painter,
  7.                 rect.left() + j * self.squareWidth(),
  8.                 boardTop + i * self.squareHeight(), shape)

游戏的绘图分为两个步骤。 在第一步中，我们绘制所有形状或已放置到板底部的形状的其余部分。 所有正方形都记在self.board列表变量中。 使用shapeAt()方法访问该变量。

  1. if self.curPiece.shape() != Tetrominoe.NoShape:
  3.     for i in range(4):
  5.         x = self.curX + self.curPiece.x(i)
  6.         y = self.curY - self.curPiece.y(i)
  7.         self.drawSquare(painter, rect.left() + x * self.squareWidth(),
  8.             boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
  9.             self.curPiece.shape())

下一步是下落的实际零件的图纸。

  1. elif key == QtCore.Qt.Key_Right:
  2.     self.tryMove(self.curPiece, self.curX + 1, self.curY)

在keyPressEvent()方法中，我们检查按键是否按下。 如果按向右箭头键，我们将尝试将棋子向右移动。 我们说尝试，因为该部分可能无法移动。

  1. elif key == QtCore.Qt.Key_Up:
  2.     self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)

向上方向键将使下降片向左旋转。

  1. elif key == QtCore.Qt.Key_Space:
  2.     self.dropDown()

空格键将立即将下降的片段降到底部。

  1. elif key == QtCore.Qt.Key_D:
  2.     self.oneLineDown()

按下 d 键，乐曲将向下移动一个格。 它可以用来加速一块的下落。

  1. def tryMove(self, newPiece, newX, newY):
  3.     for i in range(4):
  5.         x = newX + newPiece.x(i)
  6.         y = newY - newPiece.y(i)
  8.         if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  9.             return False
  11.         if self.shapeAt(x, y) != Tetrominoe.NoShape:
  12.             return False
  14.     self.curPiece = newPiece
  15.     self.curX = newX
  16.     self.curY = newY
  17.     self.update()
  18.     return True

在tryMove()方法中，我们尝试移动形状。 如果形状在板的边缘或与其他零件相邻，则返回False。 否则，我们将当前的下降片放到新位置。

  1. def timerEvent(self, event):
  3.     if event.timerId() == self.timer.timerId():
  5.         if self.isWaitingAfterLine:
  6.             self.isWaitingAfterLine = False
  7.             self.newPiece()
  8.         else:
  9.             self.oneLineDown()
  11.     else:
  12.         super(Board, self).timerEvent(event)

在计时器事件中，我们要么在上一个下降到底部之后创建一个新作品，要么将下降的一块向下移动一行。

  1. def clearBoard(self):
  3.     for i in range(Board.BoardHeight * Board.BoardWidth):
  4.         self.board.append(Tetrominoe.NoShape)

clearBoard()方法通过在板的每个块上设置Tetrominoe.NoShape来清除板。

  1. def removeFullLines(self):
  3.     numFullLines = 0
  4.     rowsToRemove = []
  6.     for i in range(Board.BoardHeight):
  8.         n = 0
  9.         for j in range(Board.BoardWidth):
  10.             if not self.shapeAt(j, i) == Tetrominoe.NoShape:
  11.                 n = n + 1
  13.         if n == 10:
  14.             rowsToRemove.append(i)
  16.     rowsToRemove.reverse()
  18.     for m in rowsToRemove:
  20.         for k in range(m, Board.BoardHeight):
  21.             for l in range(Board.BoardWidth):
  22.                     self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  24.     numFullLines = numFullLines + len(rowsToRemove)
  25.  ...

如果片段触底，我们将调用removeFullLines()方法。 我们找出所有实线并将其删除。 通过将所有行移动到当前全行上方来将其向下移动一行来实现。 请注意，我们颠倒了要删除的行的顺序。 否则，它将无法正常工作。 在我们的情况下，我们使用天真重力。 这意味着碎片可能会漂浮在空的间隙上方。

  1. def newPiece(self):
  3.     self.curPiece = Shape()
  4.     self.curPiece.setRandomShape()
  5.     self.curX = Board.BoardWidth / 2 + 1
  6.     self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
  8.     if not self.tryMove(self.curPiece, self.curX, self.curY):
  10.         self.curPiece.setShape(Tetrominoe.NoShape)
  11.         self.timer.stop()
  12.         self.isStarted = False
  13.         self.msg2Statusbar.emit("Game over")

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

  1. class Tetrominoe(object):
  3.     NoShape = 0
  4.     ZShape = 1
  5.     SShape = 2
  6.     LineShape = 3
  7.     TShape = 4
  8.     SquareShape = 5
  9.     LShape = 6
  10.     MirroredLShape = 7

Tetrominoe类包含所有可能形状的名称。 我们还有一个NoShape用于空白。

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

  1. class Shape(object):
  3.     coordsTable = (
  4.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
  5.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
  6.         ...
  7.     )
  8. ...

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

  1. self.coords = [[0,0] for i in range(4)]

创建后，我们将创建一个空坐标列表。 该列表将保存俄罗斯方块的坐标。

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

图：坐标

上面的图片将帮助您更多地了解坐标值。 例如，元组（0，-1），（0，0），（-1，0），（-1，-1）表示 Z 形。 该图说明了形状。

  1. def rotateLeft(self):
  3.     if self.pieceShape == Tetrominoe.SquareShape:
  4.         return self
  6.     result = Shape()
  7.     result.pieceShape = self.pieceShape
  9.     for i in range(4):
  11.         result.setX(i, self.y(i))
  12.         result.setY(i, -self.x(i))
  14.     return result

rotateLeft()方法将一块向左旋转。 正方形不必旋转。 这就是为什么我们只是将引用返回到当前对象。 将创建一个新零件，并将其坐标设置为旋转零件的坐标。

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

图：俄罗斯方块

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