原文： http://zetcode.com/gui/pyqt5/tetris/

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

俄罗斯方块

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

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

PyQt5 中的俄罗斯方块 - 图1

图：Tetrominoes

PyQt5 是旨在创建应用的工具包。 还有其他一些旨在创建计算机游戏的库。 尽管如此，PyQt5 和其他应用工具包仍可用于创建简单的游戏。

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

开发

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

游戏背后的一些想法：

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

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

tetris.py

  1. #!/usr/bin/python3
  2. # -*- coding: utf-8 -*-
  4. """
  5. ZetCode PyQt5 tutorial 
  7. This is a Tetris game clone.
  9. Author: Jan Bodnar
  10. Website: zetcode.com 
  11. Last edited: August 2017
  12. """
  14. from PyQt5.QtWidgets import QMainWindow, QFrame, QDesktopWidget, QApplication
  15. from PyQt5.QtCore import Qt, QBasicTimer, pyqtSignal
  16. from PyQt5.QtGui import QPainter, QColor 
  17. import sys, random
  19. class Tetris(QMainWindow):
  21.     def __init__(self):
  22.         super().__init__()
  24.         self.initUI()
  26.     def initUI(self):    
  27.         '''initiates application UI'''
  29.         self.tboard = Board(self)
  30.         self.setCentralWidget(self.tboard)
  32.         self.statusbar = self.statusBar()        
  33.         self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)
  35.         self.tboard.start()
  37.         self.resize(180, 380)
  38.         self.center()
  39.         self.setWindowTitle('Tetris')        
  40.         self.show()
  42.     def center(self):
  43.         '''centers the window on the screen'''
  45.         screen = QDesktopWidget().screenGeometry()
  46.         size = self.geometry()
  47.         self.move((screen.width()-size.width())/2, 
  48.             (screen.height()-size.height())/2)
  50. class Board(QFrame):
  52.     msg2Statusbar = pyqtSignal(str)
  54.     BoardWidth = 10
  55.     BoardHeight = 22
  56.     Speed = 300
  58.     def __init__(self, parent):
  59.         super().__init__(parent)
  61.         self.initBoard()
  63.     def initBoard(self):     
  64.         '''initiates board'''
  66.         self.timer = QBasicTimer()
  67.         self.isWaitingAfterLine = False
  69.         self.curX = 0
  70.         self.curY = 0
  71.         self.numLinesRemoved = 0
  72.         self.board = []
  74.         self.setFocusPolicy(Qt.StrongFocus)
  75.         self.isStarted = False
  76.         self.isPaused = False
  77.         self.clearBoard()
  79.     def shapeAt(self, x, y):
  80.         '''determines shape at the board position'''
  82.         return self.board[(y * Board.BoardWidth) + x]
  84.     def setShapeAt(self, x, y, shape):
  85.         '''sets a shape at the board'''
  87.         self.board[(y * Board.BoardWidth) + x] = shape
  89.     def squareWidth(self):
  90.         '''returns the width of one square'''
  92.         return self.contentsRect().width() // Board.BoardWidth
  94.     def squareHeight(self):
  95.         '''returns the height of one square'''
  97.         return self.contentsRect().height() // Board.BoardHeight
  99.     def start(self):
  100.         '''starts game'''
  102.         if self.isPaused:
  103.             return
  105.         self.isStarted = True
  106.         self.isWaitingAfterLine = False
  107.         self.numLinesRemoved = 0
  108.         self.clearBoard()
  110.         self.msg2Statusbar.emit(str(self.numLinesRemoved))
  112.         self.newPiece()
  113.         self.timer.start(Board.Speed, self)
  115.     def pause(self):
  116.         '''pauses game'''
  118.         if not self.isStarted:
  119.             return
  121.         self.isPaused = not self.isPaused
  123.         if self.isPaused:
  124.             self.timer.stop()
  125.             self.msg2Statusbar.emit("paused")
  127.         else:
  128.             self.timer.start(Board.Speed, self)
  129.             self.msg2Statusbar.emit(str(self.numLinesRemoved))
  131.         self.update()
  133.     def paintEvent(self, event):
  134.         '''paints all shapes of the game'''
  136.         painter = QPainter(self)
  137.         rect = self.contentsRect()
  139.         boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()
  141.         for i in range(Board.BoardHeight):
  142.             for j in range(Board.BoardWidth):
  143.                 shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  145.                 if shape != Tetrominoe.NoShape:
  146.                     self.drawSquare(painter,
  147.                         rect.left() + j * self.squareWidth(),
  148.                         boardTop + i * self.squareHeight(), shape)
  150.         if self.curPiece.shape() != Tetrominoe.NoShape:
  152.             for i in range(4):
  154.                 x = self.curX + self.curPiece.x(i)
  155.                 y = self.curY - self.curPiece.y(i)
  156.                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),
  157.                     boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
  158.                     self.curPiece.shape())
  160.     def keyPressEvent(self, event):
  161.         '''processes key press events'''
  163.         if not self.isStarted or self.curPiece.shape() == Tetrominoe.NoShape:
  164.             super(Board, self).keyPressEvent(event)
  165.             return
  167.         key = event.key()
  169.         if key == Qt.Key_P:
  170.             self.pause()
  171.             return
  173.         if self.isPaused:
  174.             return
  176.         elif key == Qt.Key_Left:
  177.             self.tryMove(self.curPiece, self.curX - 1, self.curY)
  179.         elif key == Qt.Key_Right:
  180.             self.tryMove(self.curPiece, self.curX + 1, self.curY)
  182.         elif key == Qt.Key_Down:
  183.             self.tryMove(self.curPiece.rotateRight(), self.curX, self.curY)
  185.         elif key == Qt.Key_Up:
  186.             self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)
  188.         elif key == Qt.Key_Space:
  189.             self.dropDown()
  191.         elif key == Qt.Key_D:
  192.             self.oneLineDown()
  194.         else:
  195.             super(Board, self).keyPressEvent(event)
  197.     def timerEvent(self, event):
  198.         '''handles timer event'''
  200.         if event.timerId() == self.timer.timerId():
  202.             if self.isWaitingAfterLine:
  203.                 self.isWaitingAfterLine = False
  204.                 self.newPiece()
  205.             else:
  206.                 self.oneLineDown()
  208.         else:
  209.             super(Board, self).timerEvent(event)
  211.     def clearBoard(self):
  212.         '''clears shapes from the board'''
  214.         for i in range(Board.BoardHeight * Board.BoardWidth):
  215.             self.board.append(Tetrominoe.NoShape)
  217.     def dropDown(self):
  218.         '''drops down a shape'''
  220.         newY = self.curY
  222.         while newY > 0:
  224.             if not self.tryMove(self.curPiece, self.curX, newY - 1):
  225.                 break
  227.             newY -= 1
  229.         self.pieceDropped()
  231.     def oneLineDown(self):
  232.         '''goes one line down with a shape'''
  234.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
  235.             self.pieceDropped()
  237.     def pieceDropped(self):
  238.         '''after dropping shape, remove full lines and create new shape'''
  240.         for i in range(4):
  242.             x = self.curX + self.curPiece.x(i)
  243.             y = self.curY - self.curPiece.y(i)
  244.             self.setShapeAt(x, y, self.curPiece.shape())
  246.         self.removeFullLines()
  248.         if not self.isWaitingAfterLine:
  249.             self.newPiece()
  251.     def removeFullLines(self):
  252.         '''removes all full lines from the board'''
  254.         numFullLines = 0
  255.         rowsToRemove = []
  257.         for i in range(Board.BoardHeight):
  259.             n = 0
  260.             for j in range(Board.BoardWidth):
  261.                 if not self.shapeAt(j, i) == Tetrominoe.NoShape:
  262.                     n = n + 1
  264.             if n == 10:
  265.                 rowsToRemove.append(i)
  267.         rowsToRemove.reverse()
  269.         for m in rowsToRemove:
  271.             for k in range(m, Board.BoardHeight):
  272.                 for l in range(Board.BoardWidth):
  273.                         self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  275.         numFullLines = numFullLines + len(rowsToRemove)
  277.         if numFullLines > 0:
  279.             self.numLinesRemoved = self.numLinesRemoved + numFullLines
  280.             self.msg2Statusbar.emit(str(self.numLinesRemoved))
  282.             self.isWaitingAfterLine = True
  283.             self.curPiece.setShape(Tetrominoe.NoShape)
  284.             self.update()
  286.     def newPiece(self):
  287.         '''creates a new shape'''
  289.         self.curPiece = Shape()
  290.         self.curPiece.setRandomShape()
  291.         self.curX = Board.BoardWidth // 2 + 1
  292.         self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
  294.         if not self.tryMove(self.curPiece, self.curX, self.curY):
  296.             self.curPiece.setShape(Tetrominoe.NoShape)
  297.             self.timer.stop()
  298.             self.isStarted = False
  299.             self.msg2Statusbar.emit("Game over")
  301.     def tryMove(self, newPiece, newX, newY):
  302.         '''tries to move a shape'''
  304.         for i in range(4):
  306.             x = newX + newPiece.x(i)
  307.             y = newY - newPiece.y(i)
  309.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  310.                 return False
  312.             if self.shapeAt(x, y) != Tetrominoe.NoShape:
  313.                 return False
  315.         self.curPiece = newPiece
  316.         self.curX = newX
  317.         self.curY = newY
  318.         self.update()
  320.         return True
  322.     def drawSquare(self, painter, x, y, shape):
  323.         '''draws a square of a shape'''        
  325.         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
  326.                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
  328.         color = QColor(colorTable[shape])
  329.         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2, 
  330.             self.squareHeight() - 2, color)
  332.         painter.setPen(color.lighter())
  333.         painter.drawLine(x, y + self.squareHeight() - 1, x, y)
  334.         painter.drawLine(x, y, x + self.squareWidth() - 1, y)
  336.         painter.setPen(color.darker())
  337.         painter.drawLine(x + 1, y + self.squareHeight() - 1,
  338.             x + self.squareWidth() - 1, y + self.squareHeight() - 1)
  339.         painter.drawLine(x + self.squareWidth() - 1, 
  340.             y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
  342. class Tetrominoe(object):
  344.     NoShape = 0
  345.     ZShape = 1
  346.     SShape = 2
  347.     LineShape = 3
  348.     TShape = 4
  349.     SquareShape = 5
  350.     LShape = 6
  351.     MirroredLShape = 7
  353. class Shape(object):
  355.     coordsTable = (
  356.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
  357.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
  358.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
  359.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
  360.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
  361.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
  362.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
  363.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
  364.     )
  366.     def __init__(self):
  368.         self.coords = [[0,0] for i in range(4)]
  369.         self.pieceShape = Tetrominoe.NoShape
  371.         self.setShape(Tetrominoe.NoShape)
  373.     def shape(self):
  374.         '''returns shape'''
  376.         return self.pieceShape
  378.     def setShape(self, shape):
  379.         '''sets a shape'''
  381.         table = Shape.coordsTable[shape]
  383.         for i in range(4):
  384.             for j in range(2):
  385.                 self.coords[i][j] = table[i][j]
  387.         self.pieceShape = shape
  389.     def setRandomShape(self):
  390.         '''chooses a random shape'''
  392.         self.setShape(random.randint(1, 7))
  394.     def x(self, index):
  395.         '''returns x coordinate'''
  397.         return self.coords[index][0]
  399.     def y(self, index):
  400.         '''returns y coordinate'''
  402.         return self.coords[index][1]
  404.     def setX(self, index, x):
  405.         '''sets x coordinate'''
  407.         self.coords[index][0] = x
  409.     def setY(self, index, y):
  410.         '''sets y coordinate'''
  412.         self.coords[index][1] = y
  414.     def minX(self):
  415.         '''returns min x value'''
  417.         m = self.coords[0][0]
  418.         for i in range(4):
  419.             m = min(m, self.coords[i][0])
  421.         return m
  423.     def maxX(self):
  424.         '''returns max x value'''
  426.         m = self.coords[0][0]
  427.         for i in range(4):
  428.             m = max(m, self.coords[i][0])
  430.         return m
  432.     def minY(self):
  433.         '''returns min y value'''
  435.         m = self.coords[0][1]
  436.         for i in range(4):
  437.             m = min(m, self.coords[i][1])
  439.         return m
  441.     def maxY(self):
  442.         '''returns max y value'''
  444.         m = self.coords[0][1]
  445.         for i in range(4):
  446.             m = max(m, self.coords[i][1])
  448.         return m
  450.     def rotateLeft(self):
  451.         '''rotates shape to the left'''
  453.         if self.pieceShape == Tetrominoe.SquareShape:
  454.             return self
  456.         result = Shape()
  457.         result.pieceShape = self.pieceShape
  459.         for i in range(4):
  461.             result.setX(i, self.y(i))
  462.             result.setY(i, -self.x(i))
  464.         return result
  466.     def rotateRight(self):
  467.         '''rotates shape to the right'''
  469.         if self.pieceShape == Tetrominoe.SquareShape:
  470.             return self
  472.         result = Shape()
  473.         result.pieceShape = self.pieceShape
  475.         for i in range(4):
  477.             result.setX(i, -self.y(i))
  478.             result.setY(i, self.x(i))
  480.         return result
  482. if __name__ == '__main__':
  484.     app = QApplication([])
  485.     tetris = Tetris()    
  486.     sys.exit(app.exec_())

游戏进行了简化，以便于理解。 游戏启动后立即开始。 我们可以通过按 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(QFrame):
  3.     msg2Statusbar = pyqtSignal(str)
  4. ...

使用pyqtSignal创建自定义信号。 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.     '''determines shape at the board position'''
  4.     return self.board[(y * Board.BoardWidth) + x]

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

  1. def squareWidth(self):
  2.     '''returns the width of one square'''
  4.     return self.contentsRect().width() // Board.BoardWidth

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

  1. def pause(self):
  2.     '''pauses game'''
  4.     if not self.isStarted:
  5.         return
  7.     self.isPaused = not self.isPaused
  9.     if self.isPaused:
  10.         self.timer.stop()
  11.         self.msg2Statusbar.emit("paused")
  13.     else:
  14.         self.timer.start(Board.Speed, self)
  15.         self.msg2Statusbar.emit(str(self.numLinesRemoved))
  17.     self.update()

pause()方法暂停游戏。 它停止计时器并在状态栏上显示一条消息。

  1. def paintEvent(self, event):
  2.     '''paints all shapes of the game'''
  4.     painter = QPainter(self)
  5.     rect = self.contentsRect()
  6. ...

绘图以paintEvent()方法进行。 QPainter负责 PyQt5 中的所有低级绘图。

  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 == Qt.Key_Right:
  2.     self.tryMove(self.curPiece, self.curX + 1, self.curY)

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

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

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

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

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

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

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

  1. def timerEvent(self, event):
  2.     '''handles timer event'''
  4.     if event.timerId() == self.timer.timerId():
  6.         if self.isWaitingAfterLine:
  7.             self.isWaitingAfterLine = False
  8.             self.newPiece()
  9.         else:
  10.             self.oneLineDown()
  12.     else:
  13.         super(Board, self).timerEvent(event)

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

  1. def clearBoard(self):
  2.     '''clears shapes from the board'''
  4.     for i in range(Board.BoardHeight * Board.BoardWidth):
  5.         self.board.append(Tetrominoe.NoShape)

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

  1. def removeFullLines(self):
  2.     '''removes all full lines from the board'''
  4.     numFullLines = 0
  5.     rowsToRemove = []
  7.     for i in range(Board.BoardHeight):
  9.         n = 0
  10.         for j in range(Board.BoardWidth):
  11.             if not self.shapeAt(j, i) == Tetrominoe.NoShape:
  12.                 n = n + 1
  14.         if n == 10:
  15.             rowsToRemove.append(i)
  17.     rowsToRemove.reverse()
  19.     for m in rowsToRemove:
  21.         for k in range(m, Board.BoardHeight):
  22.             for l in range(Board.BoardWidth):
  23.                     self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  25.     numFullLines = numFullLines + len(rowsToRemove)
  26.  ...

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

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

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

  1. def tryMove(self, newPiece, newX, newY):
  2.     '''tries to move a shape'''
  4.     for i in range(4):
  6.         x = newX + newPiece.x(i)
  7.         y = newY - newPiece.y(i)
  9.         if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  10.             return False
  12.         if self.shapeAt(x, y) != Tetrominoe.NoShape:
  13.             return False
  15.     self.curPiece = newPiece
  16.     self.curX = newX
  17.     self.curY = newY
  18.     self.update()
  20.     return True

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

  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)]

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

PyQt5 中的俄罗斯方块 - 图2

图：坐标

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

  1. def rotateLeft(self):
  2.     '''rotates shape to the left'''
  4.     if self.pieceShape == Tetrominoe.SquareShape:
  5.         return self
  7.     result = Shape()
  8.     result.pieceShape = self.pieceShape
  10.     for i in range(4):
  12.         result.setX(i, self.y(i))
  13.         result.setY(i, -self.x(i))
  15.     return result

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

PyQt5 中的俄罗斯方块 - 图3

图：俄罗斯方块

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