PyQt4 中的俄罗斯方块游戏

玖珈

已于 2023-08-07 19:21:34 修改

阅读量65

点赞数

分类专栏： PyQt4教程文章标签： python pyqt

于 2023-08-04 15:55:58 首次发布

原文链接：https://zetcode.com/gui/pyqt4/thetetrisgame/

版权

PyQt4教程专栏收录该内容

13 篇文章 0 订阅

订阅专栏

目录上一篇

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

俄罗斯方块

俄罗斯方块游戏是有史以来最流行的电脑游戏之一。最初的游戏是由俄罗斯程序员Alexey Pajitnov在1985年设计和编程的。从那时起，俄罗斯方块几乎可以在所有的计算机平台上以各种形式使用。

俄罗斯方块被称为一个下降块益智游戏。在这个游戏中，我们有七种不同的形状，称为Tetrominoes：S形、Z形、T形、L形、线形、镜像L形和方形。这些形状中的每一个由四个正方形形成。图形从板上掉下来。俄罗斯方块游戏的目的是移动和旋转的形状，使他们适合尽可能多的。如果我们设法形成一行，该行被销毁，我们得分。我们玩俄罗斯方块游戏，直到我们的顶部了。
Tetrominoes
PyQt4是一个用于创建应用程序的工具包。还有其他的库是针对创建计算机游戏。尽管如此，PyQt4和其他应用程序工具包可以用来创建简单的游戏。

创建一个电脑游戏是提高编程技能的好方法。

开发

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

游戏背后的一些想法：

我们使用QtCore.QBasicTimer来创建游戏循环。
四重奏已经画好了。
这些形状在一个正方形接一个正方形的基础上移动（而不是一个像素接一个像素）。
从数学上讲，棋盘是一个简单的数字列表。

代码由四个类组成：俄罗斯方块，棋盘，方块和形状。俄罗斯方块类设置游戏。棋盘是编写游戏逻辑的地方。Tetrominoe类包含所有俄罗斯方块的名称，Shape类包含俄罗斯方块的代码。

#!/usr/bin/python

"""
ZetCode PyQt4 tutorial 

This is a Tetris game clone.

author: Jan Bodnar
website: zetcode.com
"""

import sys, random
from PyQt4 import QtCore, QtGui


class Tetris(QtGui.QMainWindow):
    
    def __init__(self):
        super(Tetris, self).__init__()
        
        self.initUI()
        
        
    def initUI(self):    

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

        self.statusbar = self.statusBar()        
        self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)
        
        self.tboard.start()
        
        self.resize(180, 380)
        self.center()
        self.setWindowTitle('Tetris')        
        self.show()
        

    def center(self):
        
        screen = QtGui.QDesktopWidget().screenGeometry()
        size = self.geometry()
        self.move((screen.width()-size.width())/2, 
            (screen.height()-size.height())/2)
        

class Board(QtGui.QFrame):
    
    msg2Statusbar = QtCore.pyqtSignal(str)
    
    BoardWidth = 10
    BoardHeight = 22
    Speed = 300

    def __init__(self, parent):
        super(Board, self).__init__(parent)
        
        self.initBoard()
        
        
    def initBoard(self):     

        self.timer = QtCore.QBasicTimer()
        self.isWaitingAfterLine = False
        
        self.curX = 0
        self.curY = 0
        self.numLinesRemoved = 0
        self.board = []

        self.setFocusPolicy(QtCore.Qt.StrongFocus)
        self.isStarted = False
        self.isPaused = False
        self.clearBoard()
        
        
    def shapeAt(self, x, y):
        return self.board[(y * Board.BoardWidth) + x]

        
    def setShapeAt(self, x, y, shape):
        self.board[(y * Board.BoardWidth) + x] = shape
        

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

    def squareHeight(self):
        return self.contentsRect().height() / Board.BoardHeight
        

    def start(self):
        
        if self.isPaused:
            return

        self.isStarted = True
        self.isWaitingAfterLine = False
        self.numLinesRemoved = 0
        self.clearBoard()

        self.msg2Statusbar.emit(str(self.numLinesRemoved))

        self.newPiece()
        self.timer.start(Board.Speed, self)

        
    def pause(self):
        
        if not self.isStarted:
            return

        self.isPaused = not self.isPaused
        
        if self.isPaused:
            self.timer.stop()
            self.msg2Statusbar.emit("paused")
            
        else:
            self.timer.start(Board.Speed, self)
            self.msg2Statusbar.emit(str(self.numLinesRemoved))

        self.update()

        
    def paintEvent(self, event):
        
        painter = QtGui.QPainter(self)
        rect = self.contentsRect()

        boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()

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

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

                    
    def keyPressEvent(self, event):
        
        if not self.isStarted or self.curPiece.shape() == Tetrominoe.NoShape:
            super(Board, self).keyPressEvent(event)
            return

        key = event.key()
        
        if key == QtCore.Qt.Key_P:
            self.pause()
            return
            
        if self.isPaused:
            return
                
        elif key == QtCore.Qt.Key_Left:
            self.tryMove(self.curPiece, self.curX - 1, self.curY)
            
        elif key == QtCore.Qt.Key_Right:
            self.tryMove(self.curPiece, self.curX + 1, self.curY)
            
        elif key == QtCore.Qt.Key_Down:
            self.tryMove(self.curPiece.rotateRight(), self.curX, self.curY)
            
        elif key == QtCore.Qt.Key_Up:
            self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)
            
        elif key == QtCore.Qt.Key_Space:
            self.dropDown()
            
        elif key == QtCore.Qt.Key_D:
            self.oneLineDown()
            
        else:
            super(Board, self).keyPressEvent(event)
                

    def timerEvent(self, event):
        
        if event.timerId() == self.timer.timerId():
            
            if self.isWaitingAfterLine:
                self.isWaitingAfterLine = False
                self.newPiece()
            else:
                self.oneLineDown()
                
        else:
            super(Board, self).timerEvent(event)

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

        
    def dropDown(self):
        
        newY = self.curY
        
        while newY > 0:
            
            if not self.tryMove(self.curPiece, self.curX, newY - 1):
                break
                
            newY -= 1

        self.pieceDropped()
        

    def oneLineDown(self):
        
        if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
            self.pieceDropped()
            

    def pieceDropped(self):
        
        for i in range(4):
            
            x = self.curX + self.curPiece.x(i)
            y = self.curY - self.curPiece.y(i)
            self.setShapeAt(x, y, self.curPiece.shape())

        self.removeFullLines()

        if not self.isWaitingAfterLine:
            self.newPiece()
            

    def removeFullLines(self):
        
        numFullLines = 0
        rowsToRemove = []

        for i in range(Board.BoardHeight):
            
            n = 0
            for j in range(Board.BoardWidth):
                if not self.shapeAt(j, i) == Tetrominoe.NoShape:
                    n = n + 1

            if n == 10:
                rowsToRemove.append(i)

        rowsToRemove.reverse()
        

        for m in rowsToRemove:
            
            for k in range(m, Board.BoardHeight):
                for l in range(Board.BoardWidth):
                        self.setShapeAt(l, k, self.shapeAt(l, k + 1))

        numFullLines = numFullLines + len(rowsToRemove)

        if numFullLines > 0:
            
            self.numLinesRemoved = self.numLinesRemoved + numFullLines
            self.msg2Statusbar.emit(str(self.numLinesRemoved))
                
            self.isWaitingAfterLine = True
            self.curPiece.setShape(Tetrominoe.NoShape)
            self.update()
            

    def newPiece(self):
        
        self.curPiece = Shape()
        self.curPiece.setRandomShape()
        self.curX = Board.BoardWidth / 2 + 1
        self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
        
        #print self.curY

        if not self.tryMove(self.curPiece, self.curX, self.curY):
            
            self.curPiece.setShape(Tetrominoe.NoShape)
            self.timer.stop()
            self.isStarted = False
            self.msg2Statusbar.emit("Game over")



    def tryMove(self, newPiece, newX, newY):
        
        for i in range(4):
            
            x = newX + newPiece.x(i)
            y = newY - newPiece.y(i)
            
            if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
                return False
                
            if self.shapeAt(x, y) != Tetrominoe.NoShape:
                return False

        self.curPiece = newPiece
        self.curX = newX
        self.curY = newY
        self.update()
        
        return True
        

    def drawSquare(self, painter, x, y, shape):
        
        colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
                      0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]

        color = QtGui.QColor(colorTable[shape])
        painter.fillRect(x + 1, y + 1, self.squareWidth() - 2, 
            self.squareHeight() - 2, color)

        painter.setPen(color.light())
        painter.drawLine(x, y + self.squareHeight() - 1, x, y)
        painter.drawLine(x, y, x + self.squareWidth() - 1, y)

        painter.setPen(color.dark())
        painter.drawLine(x + 1, y + self.squareHeight() - 1,
            x + self.squareWidth() - 1, y + self.squareHeight() - 1)
        painter.drawLine(x + self.squareWidth() - 1, 
            y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)


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


class Shape(object):
    
    coordsTable = (
        ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
        ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
        ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
        ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
        ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
        ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
        ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
        ((1, -1),    (0, -1),    (0, 0),     (0, 1))
    )

    def __init__(self):
        
        self.coords = [[0,0] for i in range(4)]
        self.pieceShape = Tetrominoe.NoShape

        self.setShape(Tetrominoe.NoShape)
        

    def shape(self):
        return self.pieceShape
        

    def setShape(self, shape):
        
        table = Shape.coordsTable[shape]
        
        for i in range(4):
            for j in range(2):
                self.coords[i][j] = table[i][j]

        self.pieceShape = shape
        

    def setRandomShape(self):
        self.setShape(random.randint(1, 7))

        
    def x(self, index):
        return self.coords[index][0]

        
    def y(self, index):
        return self.coords[index][1]

        
    def setX(self, index, x):
        self.coords[index][0] = x

        
    def setY(self, index, y):
        self.coords[index][1] = y

        
    def minX(self):
        
        m = self.coords[0][0]
        for i in range(4):
            m = min(m, self.coords[i][0])

        return m

        
    def maxX(self):
        
        m = self.coords[0][0]
        for i in range(4):
            m = max(m, self.coords[i][0])

        return m

        
    def minY(self):
        
        m = self.coords[0][1]
        for i in range(4):
            m = min(m, self.coords[i][1])

        return m

        
    def maxY(self):
        
        m = self.coords[0][1]
        for i in range(4):
            m = max(m, self.coords[i][1])

        return m

        
    def rotateLeft(self):
        
        if self.pieceShape == Tetrominoe.SquareShape:
            return self

        result = Shape()
        result.pieceShape = self.pieceShape
        
        for i in range(4):
            
            result.setX(i, self.y(i))
            result.setY(i, -self.x(i))

        return result

        
    def rotateRight(self):
        
        if self.pieceShape == Tetrominoe.SquareShape:
            return self

        result = Shape()
        result.pieceShape = self.pieceShape
        
        for i in range(4):
            
            result.setX(i, -self.y(i))
            result.setY(i, self.x(i))

        return result


def main():
    
    app = QtGui.QApplication([])
    tetris = Tetris()    
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

游戏被简化了一点，以便更容易理解。游戏在启动后立即开始。我们可以按P键暂停游戏。空格键将俄罗斯方块块立即下降到底部。游戏以恒定的速度进行，没有实现加速。分数是我们删除的行数。

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

创建了Board类的一个实例，并将其设置为应用程序的中心小部件。

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

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

self.tboard.start()

这条线启动游戏。

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

创建自定义信号。msg2Statusbar是一个信号，当我们想要向状态栏写入消息或分数时，它会发出这个信号。

BoardWidth = 10
BoardHeight = 22
Speed = 300

这些是Board的类变量。BoardWidth和BoardHeight以块为单位定义电路板的大小。速度决定了游戏的速度。每300ms将开始新的游戏循环。

...
self.curX = 0
self.curY = 0
self.numLinesRemoved = 0
self.board = []
...

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

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

shapeAt方法确定给定块处的形状的类型。

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

电路板可以动态调整大小。因此，块的大小可以改变。squareWidth以像素为单位计算单个正方形的宽度并返回它。BoardWidth是以块为单位的电路板的大小。

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

游戏的绘制分为两个步骤。在第一步中，我们绘制所有的形状，或已被放置到板底部的形状的剩余部分。所有的方格都被存储在self.board列表变量中。使用shapeAt方法访问变量。

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

下一步是绘制正在下落的实际碎片。

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

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

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

向上箭头键将使下落的棋子向左旋转。

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

空格键会使下落的棋子立即落到底部。

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

按下d键，棋子将向下移动一个街区。它可以用来加速一个小块的下落。

def tryMove(self, newPiece, newX, newY):
    
    for i in range(4):
        
        x = newX + newPiece.x(i)
        y = newY - newPiece.y(i)
        
        if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
            return False
            
        if self.shapeAt(x, y) != Tetrominoe.NoShape:
            return False

    self.curPiece = newPiece
    self.curX = newX
    self.curY = newY
    self.update()
    return True

在tryMove方法中，我们尝试移动形状。如果形状位于棋盘的边缘或与其他棋子相邻，则返回False。否则，我们将当前下落的棋子放置到一个新的位置。

def timerEvent(self, event):
    
    if event.timerId() == self.timer.timerId():
        
        if self.isWaitingAfterLine:
            self.isWaitingAfterLine = False
            self.newPiece()
        else:
            self.oneLineDown()
            
    else:
        super(Board, self).timerEvent(event)

在计时器事件中，我们要么在前一个块被放到底部后创建一个新块，要么将一个正在下降的块向下移动一行。

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

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

def removeFullLines(self):
    
    numFullLines = 0
    rowsToRemove = []

    for i in range(Board.BoardHeight):
        
        n = 0
        for j in range(Board.BoardWidth):
            if not self.shapeAt(j, i) == Tetrominoe.NoShape:
                n = n + 1

        if n == 10:
            rowsToRemove.append(i)

    rowsToRemove.reverse()
    

    for m in rowsToRemove:
        
        for k in range(m, Board.BoardHeight):
            for l in range(Board.BoardWidth):
                    self.setShapeAt(l, k, self.shapeAt(l, k + 1))

    numFullLines = numFullLines + len(rowsToRemove)
 ...

如果这一段到达底部，我们调用removeFullLines方法。我们找出所有完整的行并删除它们。我们通过将当前整行以上的所有行向下移动一行来实现。请注意，我们颠倒了要删除的行的顺序。否则，它将无法正常工作。在我们的例子中，我们使用一个朴素的引力。这意味着这些块可以浮在空的间隙上方。

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

newPiece方法随机创建一个新的俄罗斯方块棋子。如果棋子不能回到初始位置，游戏结束。

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

Tetrominoe类包含所有可能形状的名称。我们也有一个空的空间NoShape。

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

class Shape(object):
    
    coordsTable = (
        ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
        ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
        ...
    )
...

coordsTable元组包含etris块的所有可能的坐标值。这是一个模板，所有片段都从中获取其坐标值。

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

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

上图将有助于更好地理解坐标值。例如，元组（0，-1）、（0，0）、（-1，0）、（-1，-1）表示Z形。该图说明了形状。

def rotateLeft(self):
    
    if self.pieceShape == Tetrominoe.SquareShape:
        return self

    result = Shape()
    result.pieceShape = self.pieceShape
    
    for i in range(4):
        
        result.setX(i, self.y(i))
        result.setY(i, -self.x(i))

    return result