• 俄罗斯方块游戏
    • Tetris
    • 开发

    俄罗斯方块游戏

    本章我们要制作一个俄罗斯方块游戏。

    Tetris

    译注：称呼：方块是由四个小方格组成的

    俄罗斯方块游戏是世界上最流行的游戏之一。是由一名叫Alexey Pajitnov的俄罗斯程序员在1985年制作的，从那时起，这个游戏就风靡了各个游戏平台。

    俄罗斯方块归类为下落块迷宫游戏。游戏有7个基本形状：S、Z、T、L、反向L、直线、方块，每个形状都由4个方块组成，方块最终都会落到屏幕底部。所以玩家通过控制形状的左右位置和旋转，让每个形状都以合适的位置落下，如果有一行全部被方块填充，这行就会消失，并且得分。游戏结束的条件是有形状接触到了屏幕顶部。

    方块展示：

    tetrominoes

    PyQt5是专门为创建图形界面产生的，里面一些专门为制作游戏而开发的组件，所以PyQt5是能制作小游戏的。

    制作电脑游戏也是提高自己编程能力的一种很好的方式。

    开发

    没有图片，所以就自己用绘画画出来几个图形。每个游戏里都有数学模型的，这个也是。

    开工之前：

    • 用QtCore.QBasicTimer()创建一个游戏循环
    • 模型是一直下落的
    • 模型的运动是以小块为基础单位的，不是按像素
    • 从数学意义上来说，模型就是就是一串数字而已

    代码由四个类组成：Tetris, Board, Tetrominoe和Shape。Tetris类创建游戏，Board是游戏主要逻辑。Tetrominoe包含了所有的砖块，Shape是所有砖块的代码。

    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()
    27.     def initUI(self):    
    28.         '''initiates application UI'''
    30.         self.tboard = Board(self)
    31.         self.setCentralWidget(self.tboard)
    33.         self.statusbar = self.statusBar()        
    34.         self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)
    36.         self.tboard.start()
    38.         self.resize(180, 380)
    39.         self.center()
    40.         self.setWindowTitle('Tetris')        
    41.         self.show()
    44.     def center(self):
    45.         '''centers the window on the screen'''
    47.         screen = QDesktopWidget().screenGeometry()
    48.         size = self.geometry()
    49.         self.move((screen.width()-size.width())/2, 
    50.             (screen.height()-size.height())/2)
    53. class Board(QFrame):
    55.     msg2Statusbar = pyqtSignal(str)
    57.     BoardWidth = 10
    58.     BoardHeight = 22
    59.     Speed = 300
    61.     def __init__(self, parent):
    62.         super().__init__(parent)
    64.         self.initBoard()
    67.     def initBoard(self):     
    68.         '''initiates board'''
    70.         self.timer = QBasicTimer()
    71.         self.isWaitingAfterLine = False
    73.         self.curX = 0
    74.         self.curY = 0
    75.         self.numLinesRemoved = 0
    76.         self.board = []
    78.         self.setFocusPolicy(Qt.StrongFocus)
    79.         self.isStarted = False
    80.         self.isPaused = False
    81.         self.clearBoard()
    84.     def shapeAt(self, x, y):
    85.         '''determines shape at the board position'''
    87.         return self.board[(y * Board.BoardWidth) + x]
    90.     def setShapeAt(self, x, y, shape):
    91.         '''sets a shape at the board'''
    93.         self.board[(y * Board.BoardWidth) + x] = shape
    96.     def squareWidth(self):
    97.         '''returns the width of one square'''
    99.         return self.contentsRect().width() // Board.BoardWidth
    102.     def squareHeight(self):
    103.         '''returns the height of one square'''
    105.         return self.contentsRect().height() // Board.BoardHeight
    108.     def start(self):
    109.         '''starts game'''
    111.         if self.isPaused:
    112.             return
    114.         self.isStarted = True
    115.         self.isWaitingAfterLine = False
    116.         self.numLinesRemoved = 0
    117.         self.clearBoard()
    119.         self.msg2Statusbar.emit(str(self.numLinesRemoved))
    121.         self.newPiece()
    122.         self.timer.start(Board.Speed, self)
    125.     def pause(self):
    126.         '''pauses game'''
    128.         if not self.isStarted:
    129.             return
    131.         self.isPaused = not self.isPaused
    133.         if self.isPaused:
    134.             self.timer.stop()
    135.             self.msg2Statusbar.emit("paused")
    137.         else:
    138.             self.timer.start(Board.Speed, self)
    139.             self.msg2Statusbar.emit(str(self.numLinesRemoved))
    141.         self.update()
    144.     def paintEvent(self, event):
    145.         '''paints all shapes of the game'''
    147.         painter = QPainter(self)
    148.         rect = self.contentsRect()
    150.         boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()
    152.         for i in range(Board.BoardHeight):
    153.             for j in range(Board.BoardWidth):
    154.                 shape = self.shapeAt(j, Board.BoardHeight - i - 1)
    156.                 if shape != Tetrominoe.NoShape:
    157.                     self.drawSquare(painter,
    158.                         rect.left() + j * self.squareWidth(),
    159.                         boardTop + i * self.squareHeight(), shape)
    161.         if self.curPiece.shape() != Tetrominoe.NoShape:
    163.             for i in range(4):
    165.                 x = self.curX + self.curPiece.x(i)
    166.                 y = self.curY - self.curPiece.y(i)
    167.                 self.drawSquare(painter, rect.left() + x * self.squareWidth(),
    168.                     boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
    169.                     self.curPiece.shape())
    172.     def keyPressEvent(self, event):
    173.         '''processes key press events'''
    175.         if not self.isStarted or self.curPiece.shape() == Tetrominoe.NoShape:
    176.             super(Board, self).keyPressEvent(event)
    177.             return
    179.         key = event.key()
    181.         if key == Qt.Key_P:
    182.             self.pause()
    183.             return
    185.         if self.isPaused:
    186.             return
    188.         elif key == Qt.Key_Left:
    189.             self.tryMove(self.curPiece, self.curX - 1, self.curY)
    191.         elif key == Qt.Key_Right:
    192.             self.tryMove(self.curPiece, self.curX + 1, self.curY)
    194.         elif key == Qt.Key_Down:
    195.             self.tryMove(self.curPiece.rotateRight(), self.curX, self.curY)
    197.         elif key == Qt.Key_Up:
    198.             self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)
    200.         elif key == Qt.Key_Space:
    201.             self.dropDown()
    203.         elif key == Qt.Key_D:
    204.             self.oneLineDown()
    206.         else:
    207.             super(Board, self).keyPressEvent(event)
    210.     def timerEvent(self, event):
    211.         '''handles timer event'''
    213.         if event.timerId() == self.timer.timerId():
    215.             if self.isWaitingAfterLine:
    216.                 self.isWaitingAfterLine = False
    217.                 self.newPiece()
    218.             else:
    219.                 self.oneLineDown()
    221.         else:
    222.             super(Board, self).timerEvent(event)
    225.     def clearBoard(self):
    226.         '''clears shapes from the board'''
    228.         for i in range(Board.BoardHeight * Board.BoardWidth):
    229.             self.board.append(Tetrominoe.NoShape)
    232.     def dropDown(self):
    233.         '''drops down a shape'''
    235.         newY = self.curY
    237.         while newY > 0:
    239.             if not self.tryMove(self.curPiece, self.curX, newY - 1):
    240.                 break
    242.             newY -= 1
    244.         self.pieceDropped()
    247.     def oneLineDown(self):
    248.         '''goes one line down with a shape'''
    250.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
    251.             self.pieceDropped()
    254.     def pieceDropped(self):
    255.         '''after dropping shape, remove full lines and create new shape'''
    257.         for i in range(4):
    259.             x = self.curX + self.curPiece.x(i)
    260.             y = self.curY - self.curPiece.y(i)
    261.             self.setShapeAt(x, y, self.curPiece.shape())
    263.         self.removeFullLines()
    265.         if not self.isWaitingAfterLine:
    266.             self.newPiece()
    269.     def removeFullLines(self):
    270.         '''removes all full lines from the board'''
    272.         numFullLines = 0
    273.         rowsToRemove = []
    275.         for i in range(Board.BoardHeight):
    277.             n = 0
    278.             for j in range(Board.BoardWidth):
    279.                 if not self.shapeAt(j, i) == Tetrominoe.NoShape:
    280.                     n = n + 1
    282.             if n == 10:
    283.                 rowsToRemove.append(i)
    285.         rowsToRemove.reverse()
    288.         for m in rowsToRemove:
    290.             for k in range(m, Board.BoardHeight):
    291.                 for l in range(Board.BoardWidth):
    292.                         self.setShapeAt(l, k, self.shapeAt(l, k + 1))
    294.         numFullLines = numFullLines + len(rowsToRemove)
    296.         if numFullLines > 0:
    298.             self.numLinesRemoved = self.numLinesRemoved + numFullLines
    299.             self.msg2Statusbar.emit(str(self.numLinesRemoved))
    301.             self.isWaitingAfterLine = True
    302.             self.curPiece.setShape(Tetrominoe.NoShape)
    303.             self.update()
    306.     def newPiece(self):
    307.         '''creates a new shape'''
    309.         self.curPiece = Shape()
    310.         self.curPiece.setRandomShape()
    311.         self.curX = Board.BoardWidth // 2 + 1
    312.         self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
    314.         if not self.tryMove(self.curPiece, self.curX, self.curY):
    316.             self.curPiece.setShape(Tetrominoe.NoShape)
    317.             self.timer.stop()
    318.             self.isStarted = False
    319.             self.msg2Statusbar.emit("Game over")
    323.     def tryMove(self, newPiece, newX, newY):
    324.         '''tries to move a shape'''
    326.         for i in range(4):
    328.             x = newX + newPiece.x(i)
    329.             y = newY - newPiece.y(i)
    331.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
    332.                 return False
    334.             if self.shapeAt(x, y) != Tetrominoe.NoShape:
    335.                 return False
    337.         self.curPiece = newPiece
    338.         self.curX = newX
    339.         self.curY = newY
    340.         self.update()
    342.         return True
    345.     def drawSquare(self, painter, x, y, shape):
    346.         '''draws a square of a shape'''        
    348.         colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
    349.                       0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
    351.         color = QColor(colorTable[shape])
    352.         painter.fillRect(x + 1, y + 1, self.squareWidth() - 2, 
    353.             self.squareHeight() - 2, color)
    355.         painter.setPen(color.lighter())
    356.         painter.drawLine(x, y + self.squareHeight() - 1, x, y)
    357.         painter.drawLine(x, y, x + self.squareWidth() - 1, y)
    359.         painter.setPen(color.darker())
    360.         painter.drawLine(x + 1, y + self.squareHeight() - 1,
    361.             x + self.squareWidth() - 1, y + self.squareHeight() - 1)
    362.         painter.drawLine(x + self.squareWidth() - 1, 
    363.             y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
    366. class Tetrominoe(object):
    368.     NoShape = 0
    369.     ZShape = 1
    370.     SShape = 2
    371.     LineShape = 3
    372.     TShape = 4
    373.     SquareShape = 5
    374.     LShape = 6
    375.     MirroredLShape = 7
    378. class Shape(object):
    380.     coordsTable = (
    381.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
    382.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
    383.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
    384.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
    385.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
    386.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
    387.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
    388.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
    389.     )
    391.     def __init__(self):
    393.         self.coords = [[0,0] for i in range(4)]
    394.         self.pieceShape = Tetrominoe.NoShape
    396.         self.setShape(Tetrominoe.NoShape)
    399.     def shape(self):
    400.         '''returns shape'''
    402.         return self.pieceShape
    405.     def setShape(self, shape):
    406.         '''sets a shape'''
    408.         table = Shape.coordsTable[shape]
    410.         for i in range(4):
    411.             for j in range(2):
    412.                 self.coords[i][j] = table[i][j]
    414.         self.pieceShape = shape
    417.     def setRandomShape(self):
    418.         '''chooses a random shape'''
    420.         self.setShape(random.randint(1, 7))
    423.     def x(self, index):
    424.         '''returns x coordinate'''
    426.         return self.coords[index][0]
    429.     def y(self, index):
    430.         '''returns y coordinate'''
    432.         return self.coords[index][1]
    435.     def setX(self, index, x):
    436.         '''sets x coordinate'''
    438.         self.coords[index][0] = x
    441.     def setY(self, index, y):
    442.         '''sets y coordinate'''
    444.         self.coords[index][1] = y
    447.     def minX(self):
    448.         '''returns min x value'''
    450.         m = self.coords[0][0]
    451.         for i in range(4):
    452.             m = min(m, self.coords[i][0])
    454.         return m
    457.     def maxX(self):
    458.         '''returns max x value'''
    460.         m = self.coords[0][0]
    461.         for i in range(4):
    462.             m = max(m, self.coords[i][0])
    464.         return m
    467.     def minY(self):
    468.         '''returns min y value'''
    470.         m = self.coords[0][1]
    471.         for i in range(4):
    472.             m = min(m, self.coords[i][1])
    474.         return m
    477.     def maxY(self):
    478.         '''returns max y value'''
    480.         m = self.coords[0][1]
    481.         for i in range(4):
    482.             m = max(m, self.coords[i][1])
    484.         return m
    487.     def rotateLeft(self):
    488.         '''rotates shape to the left'''
    490.         if self.pieceShape == Tetrominoe.SquareShape:
    491.             return self
    493.         result = Shape()
    494.         result.pieceShape = self.pieceShape
    496.         for i in range(4):
    498.             result.setX(i, self.y(i))
    499.             result.setY(i, -self.x(i))
    501.         return result
    504.     def rotateRight(self):
    505.         '''rotates shape to the right'''
    507.         if self.pieceShape == Tetrominoe.SquareShape:
    508.             return self
    510.         result = Shape()
    511.         result.pieceShape = self.pieceShape
    513.         for i in range(4):
    515.             result.setX(i, -self.y(i))
    516.             result.setY(i, self.x(i))
    518.         return result
    521. if __name__ == '__main__':
    523.     app = QApplication([])
    524.     tetris = Tetris()    
    525.     sys.exit(app.exec_())

    游戏很简单，所以也就很好理解。程序加载之后游戏也就直接开始了，可以用P键暂停游戏，空格键让方块直接落到最下面。游戏的速度是固定的，并没有实现加速的功能。分数就是游戏中消除的行数。

    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)

    创建一个statusbar来显示三种信息：消除的行数，游戏暂停状态或者游戏结束状态。msg2Statusbar是一个自定义的信号，用在（和）Board类（交互），showMessage()方法是一个内建的，用来在statusbar上显示信息的方法。

    1. self.tboard.start()

    初始化游戏：

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

    创建了一个自定义信号msg2Statusbar，当我们想往statusbar里显示信息的时候，发出这个信号就行了。

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

    这些是Board类的变量。BoardWidth和BoardHeight分别是board的宽度和高度。Speed是游戏的速度，每300ms出现一个新的方块。

    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()决定了board里方块的的种类。

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

    board的大小可以动态的改变。所以方格的大小也应该随之变化。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()方法用来暂停游戏，停止计时并在statusbar上显示一条信息。

    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 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()是尝试移动方块的方法。如果方块已经到达board的边缘或者遇到了其他方块，就返回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)

    在计时器事件里，要么是等一个方块下落完之后创建一个新的方块，要么是让一个方块直接落到底（move a falling piece one line down）。

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

    clearBoard()方法通过Tetrominoe.NoShape清空broad。

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

    上面创建了一个新的空坐标数组，这个数组将用来保存方块的坐标。

    坐标系示意图：

    coordinates

    上面的图片可以帮助我们更好的理解坐标值的意义。比如元组(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()方法向右旋转一个方块。正方形的方块就没必要旋转，就直接返回了。其他的是返回一个新的，能表示这个形状旋转了的坐标。

    程序展示：

    Tetris