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

制作计算机游戏具有挑战性。 程序员迟早会希望有一天创建一个计算机游戏。 实际上，许多人对编程很感兴趣，因为他们玩游戏并想创建自己的游戏。 制作计算机游戏将有助于提高您的编程技能。

俄罗斯方块

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

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

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

图：Tetrominoes

PySide 是旨在创建应用的工具包。 还有其他一些旨在创建计算机游戏的库。 但是，可以使用 PySide 和其他应用工具包来创建游戏。

开发

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

游戏背后的一些想法：

  • 我们使用QtCore.QBasicTimer()创建游戏周期。
  • 绘制四方块。
  • 形状以正方形为单位移动（而不是逐个像素移动）。
  • 从数学上讲，棋盘是一个简单的数字列表。
  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  4. """
  5. ZetCode PySide tutorial
  7. This is a simple Tetris clone
  8. in PySide.
  10. author: Jan Bodnar
  11. website: zetcode.com
  12. last edited: August 2011
  13. """
  15. import sys, random
  16. from PySide import QtCore, QtGui
  18. class Communicate(QtCore.QObject):
  20.     msgToSB = QtCore.Signal(str)
  22. class Tetris(QtGui.QMainWindow):
  24.     def __init__(self):
  25.         super(Tetris, self).__init__()
  27.         self.setGeometry(300, 300, 180, 380)
  28.         self.setWindowTitle('Tetris')
  29.         self.Tetrisboard = Board(self)
  31.         self.setCentralWidget(self.Tetrisboard)
  33.         self.statusbar = self.statusBar()
  34.         self.Tetrisboard.c.msgToSB[str].connect(self.statusbar.showMessage)
  36.         self.Tetrisboard.start()
  37.         self.center()
  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.     BoardWidth = 10
  49.     BoardHeight = 22
  50.     Speed = 300
  52.     def __init__(self, parent):
  53.         super(Board, self).__init__()
  55.         self.timer = QtCore.QBasicTimer()
  56.         self.isWaitingAfterLine = False
  57.         self.curPiece = Shape()
  58.         self.nextPiece = Shape()
  59.         self.curX = 0
  60.         self.curY = 0
  61.         self.numLinesRemoved = 0
  62.         self.board = []
  64.         self.setFocusPolicy(QtCore.Qt.StrongFocus)
  65.         self.isStarted = False
  66.         self.isPaused = False
  67.         self.clearBoard()
  69.         self.c = Communicate()
  71.         self.nextPiece.setRandomShape()
  73.     def shapeAt(self, x, y):
  74.         return self.board[(y * Board.BoardWidth) + x]
  76.     def setShapeAt(self, x, y, shape):
  77.         self.board[(y * Board.BoardWidth) + x] = shape
  79.     def squareWidth(self):
  80.         return self.contentsRect().width() / Board.BoardWidth
  82.     def squareHeight(self):
  83.         return self.contentsRect().height() / Board.BoardHeight
  85.     def start(self):
  86.         if self.isPaused:
  87.             return
  89.         self.isStarted = True
  90.         self.isWaitingAfterLine = False
  91.         self.numLinesRemoved = 0
  92.         self.clearBoard()
  94.         self.c.msgToSB.emit(str(self.numLinesRemoved))
  96.         self.newPiece()
  97.         self.timer.start(Board.Speed, self)
  99.     def pause(self):
  101.         if not self.isStarted:
  102.             return
  104.         self.isPaused = not self.isPaused
  106.         if self.isPaused:
  107.             self.timer.stop()
  108.             self.c.msgToSB.emit("paused")
  109.         else:
  110.             self.timer.start(Board.Speed, self)
  111.             self.c.msgToSB.emit(str(self.numLinesRemoved))
  113.         self.update()
  115.     def paintEvent(self, event):
  117.         painter = QtGui.QPainter(self)
  118.         rect = self.contentsRect()
  120.         boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()
  122.         for i in range(Board.BoardHeight):
  123.             for j in range(Board.BoardWidth):
  124.                 shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  125.                 if shape != Tetrominoes.NoShape:
  126.                     self.drawSquare(painter,
  127.                         rect.left() + j * self.squareWidth(),
  128.                         boardTop + i * self.squareHeight(), shape)
  130.         if self.curPiece.shape() != Tetrominoes.NoShape:
  131.             for i in range(4):
  132.                 x = self.curX + self.curPiece.x(i)
  133.                 y = self.curY - self.curPiece.y(i)
  134.                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),
  135.                     boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
  136.                     self.curPiece.shape())
  138.     def keyPressEvent(self, event):
  140.         if not self.isStarted or self.curPiece.shape() == Tetrominoes.NoShape:
  141.             QtGui.QWidget.keyPressEvent(self, event)
  142.             return
  144.         key = event.key()
  146.         if key == QtCore.Qt.Key_P:
  147.             self.pause()
  148.             return
  149.         if self.isPaused:
  150.             return
  151.         elif key == QtCore.Qt.Key_Left:
  152.             self.tryMove(self.curPiece, self.curX - 1, self.curY)
  153.         elif key == QtCore.Qt.Key_Right:
  154.             self.tryMove(self.curPiece, self.curX + 1, self.curY)
  155.         elif key == QtCore.Qt.Key_Down:
  156.             self.tryMove(self.curPiece.rotatedRight(), self.curX, self.curY)
  157.         elif key == QtCore.Qt.Key_Up:
  158.             self.tryMove(self.curPiece.rotatedLeft(), self.curX, self.curY)
  159.         elif key == QtCore.Qt.Key_Space:
  160.             self.dropDown()
  161.         elif key == QtCore.Qt.Key_D:
  162.             self.oneLineDown()
  163.         else:
  164.             QtGui.QWidget.keyPressEvent(self, event)
  166.     def timerEvent(self, event):
  168.         if event.timerId() == self.timer.timerId():
  169.             if self.isWaitingAfterLine:
  170.                 self.isWaitingAfterLine = False
  171.                 self.newPiece()
  172.             else:
  173.                 self.oneLineDown()
  174.         else:
  175.             QtGui.QFrame.timerEvent(self, event)
  177.     def clearBoard(self):
  179.         for i in range(Board.BoardHeight * Board.BoardWidth):
  180.             self.board.append(Tetrominoes.NoShape)
  182.     def dropDown(self):
  184.         newY = self.curY
  185.         while newY > 0:
  186.             if not self.tryMove(self.curPiece, self.curX, newY - 1):
  187.                 break
  188.             newY -= 1
  190.         self.pieceDropped()
  192.     def oneLineDown(self):
  194.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
  195.             self.pieceDropped()
  197.     def pieceDropped(self):
  199.         for i in range(4):
  200.             x = self.curX + self.curPiece.x(i)
  201.             y = self.curY - self.curPiece.y(i)
  202.             self.setShapeAt(x, y, self.curPiece.shape())
  204.         self.removeFullLines()
  206.         if not self.isWaitingAfterLine:
  207.             self.newPiece()
  209.     def removeFullLines(self):
  210.         numFullLines = 0
  212.         rowsToRemove = []
  214.         for i in range(Board.BoardHeight):
  215.             n = 0
  216.             for j in range(Board.BoardWidth):
  217.                 if not self.shapeAt(j, i) == Tetrominoes.NoShape:
  218.                     n = n + 1
  220.             if n == 10:
  221.                 rowsToRemove.append(i)
  223.         rowsToRemove.reverse()
  225.         for m in rowsToRemove:
  226.             for k in range(m, Board.BoardHeight):
  227.                 for l in range(Board.BoardWidth):
  228.                         self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  230.         numFullLines = numFullLines + len(rowsToRemove)
  232.         if numFullLines > 0:
  233.             self.numLinesRemoved = self.numLinesRemoved + numFullLines
  234.             print self.numLinesRemoved
  235.             self.c.msgToSB.emit(str(self.numLinesRemoved))
  236.             self.isWaitingAfterLine = True
  237.             self.curPiece.setShape(Tetrominoes.NoShape)
  238.             self.update()
  240.     def newPiece(self):
  242.         self.curPiece = self.nextPiece
  243.         self.nextPiece.setRandomShape()
  244.         self.curX = Board.BoardWidth / 2 + 1
  245.         self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
  247.         if not self.tryMove(self.curPiece, self.curX, self.curY):
  248.             self.curPiece.setShape(Tetrominoes.NoShape)
  249.             self.timer.stop()
  250.             self.isStarted = False
  251.             self.c.msgToSB.emit("Game over")
  253.     def tryMove(self, newPiece, newX, newY):
  255.         for i in range(4):
  256.             x = newX + newPiece.x(i)
  257.             y = newY - newPiece.y(i)
  258.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  259.                 return False
  260.             if self.shapeAt(x, y) != Tetrominoes.NoShape:
  261.                 return False
  263.         self.curPiece = newPiece
  264.         self.curX = newX
  265.         self.curY = newY
  266.         self.update()
  267.         return True
  269.     def drawSquare(self, painter, x, y, shape):
  271.         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
  272.                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
  274.         color = QtGui.QColor(colorTable[shape])
  275.         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2, 
  276.             self.squareHeight() - 2, color)
  278.         painter.setPen(color.lighter())
  279.         painter.drawLine(x, y + self.squareHeight() - 1, x, y)
  280.         painter.drawLine(x, y, x + self.squareWidth() - 1, y)
  282.         painter.setPen(color.darker())
  283.         painter.drawLine(x + 1, y + self.squareHeight() - 1,
  284.             x + self.squareWidth() - 1, y + self.squareHeight() - 1)
  285.         painter.drawLine(x + self.squareWidth() - 1, 
  286.             y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
  288. class Tetrominoes(object):
  290.     NoShape = 0
  291.     ZShape = 1
  292.     SShape = 2
  293.     LineShape = 3
  294.     TShape = 4
  295.     SquareShape = 5
  296.     LShape = 6
  297.     MirroredLShape = 7
  299. class Shape(object):
  301.     coordsTable = (
  302.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
  303.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
  304.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
  305.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
  306.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
  307.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
  308.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
  309.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
  310.     )
  312.     def __init__(self):
  314.         self.coords = [[0,0] for i in range(4)]
  315.         self.pieceShape = Tetrominoes.NoShape
  317.         self.setShape(Tetrominoes.NoShape)
  319.     def shape(self):
  320.         return self.pieceShape
  322.     def setShape(self, shape):
  324.         table = Shape.coordsTable[shape]
  325.         for i in range(4):
  326.             for j in range(2):
  327.                 self.coords[i][j] = table[i][j]
  329.         self.pieceShape = shape
  331.     def setRandomShape(self):
  332.         self.setShape(random.randint(1, 7))
  334.     def x(self, index):
  335.         return self.coords[index][0]
  337.     def y(self, index):
  338.         return self.coords[index][1]
  340.     def setX(self, index, x):
  341.         self.coords[index][0] = x
  343.     def setY(self, index, y):
  344.         self.coords[index][1] = y
  346.     def minX(self):
  348.         m = self.coords[0][0]
  349.         for i in range(4):
  350.             m = min(m, self.coords[i][0])
  352.         return m
  354.     def maxX(self):
  356.         m = self.coords[0][0]
  357.         for i in range(4):
  358.             m = max(m, self.coords[i][0])
  360.         return m
  362.     def minY(self):
  364.         m = self.coords[0][1]
  365.         for i in range(4):
  366.             m = min(m, self.coords[i][1])
  368.         return m
  370.     def maxY(self):
  372.         m = self.coords[0][1]
  373.         for i in range(4):
  374.             m = max(m, self.coords[i][1])
  376.         return m
  378.     def rotatedLeft(self):
  380.         if self.pieceShape == Tetrominoes.SquareShape:
  381.             return self
  383.         result = Shape()
  384.         result.pieceShape = self.pieceShape
  386.         for i in range(4):
  387.             result.setX(i, self.y(i))
  388.             result.setY(i, -self.x(i))
  390.         return result
  392.     def rotatedRight(self):
  394.         if self.pieceShape == Tetrominoes.SquareShape:
  395.             return self
  397.         result = Shape()
  398.         result.pieceShape = self.pieceShape
  400.         for i in range(4):
  401.             result.setX(i, -self.y(i))
  402.             result.setY(i, self.x(i))
  404.         return result
  406. def main():
  408.     app = QtGui.QApplication(sys.argv)
  409.     t = Tetris()
  410.     t.show()
  411.     sys.exit(app.exec_())
  413. if __name__ == '__main__':
  414.     main()

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

  1. self.statusbar = self.statusBar()
  2. self.Tetrisboard.c.msgToSB[str].connect(self.statusbar.showMessage)

我们创建一个状态栏，在其中显示消息。 我们将显示三种可能的消息。 已删除的行数。 暂停的消息和游戏结束消息。

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

在开始游戏周期之前，我们先初始化一些重要的变量。 self.board变量是一个从 0 到 7 的数字的列表。它表示各种形状的位置以及板上形状的其余部分。

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

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

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

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

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

在keyPressEvent中，我们检查是否有按下的键。 如果按向右箭头键，我们将尝试将棋子向右移动。 我们说尝试，因为这片可能无法移动。

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

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

  1. def timerEvent(self, event):
  2.     if event.timerId() == self.timer.timerId():
  3.         if self.isWaitingAfterLine:
  4.             self.isWaitingAfterLine = False
  5.             self.newPiece()
  6.         else:
  7.             self.oneLineDown()
  8.     else:
  9.         QtGui.QFrame.timerEvent(self, event)

在计时器事件中，我们可以在上一个下降到底部之后创建一个新的片断，或者将下降的片断向下移动一行。

  1. def removeFullLines(self):
  2.     numFullLines = 0
  4.     rowsToRemove = []
  6.     for i in range(Board.BoardHeight):
  7.         n = 0
  8.         for j in range(Board.BoardWidth):
  9.             if not self.shapeAt(j, i) == Tetrominoes.NoShape:
  10.                 n = n + 1
  12.         if n == 10:
  13.             rowsToRemove.append(i)
  15.     rowsToRemove.reverse()
  17.     for m in rowsToRemove:
  18.         for k in range(m, Board.BoardHeight):
  19.             for l in range(Board.BoardWidth):
  20.                 self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  21. ...

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

  1. def newPiece(self):
  3.     self.curPiece = self.nextPiece
  4.     self.nextPiece.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):
  9.         self.curPiece.setShape(Tetrominoes.NoShape)
  10.         self.timer.stop()
  11.         self.isStarted = False
  12.         self.c.msgToSB.emit("Game over")

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

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

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

创建后，我们将创建一个空坐标列表。 该列表将保存俄罗斯方块的坐标。 例如，这些元组（0，-1），（0，0），（1，0），（1，1）表示旋转的 S 形。 下图说明了形状。

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

图：坐标

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

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

图：俄罗斯方块

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