原文： http://zetcode.com/wxpython/thetetrisgame/

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

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

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

图：Tetrominoes

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

开发

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

游戏背后的一些想法：

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

tetris.py

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  4. """
  5. ZetCode wxPython tutorial
  7. This is Tetris game clone in wxPython.
  9. author: Jan Bodnar
  10. website: www.zetcode.com
  11. last modified: May 2018
  12. """
  14. import wx
  15. import random
  17. class Tetris(wx.Frame):
  19.     def __init__(self, parent):
  20.         wx.Frame.__init__(self, parent, size=(180, 380),
  21.             style=wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER ^ wx.MAXIMIZE_BOX)
  23.         self.initFrame()
  25.     def initFrame(self):
  27.         self.statusbar = self.CreateStatusBar()
  28.         self.statusbar.SetStatusText('0')
  29.         self.board = Board(self)
  30.         self.board.SetFocus()
  31.         self.board.start()
  33.         self.SetTitle("Tetris")
  34.         self.Centre()
  36. class Board(wx.Panel):
  38.     BoardWidth = 10
  39.     BoardHeight = 22
  40.     Speed = 300
  41.     ID_TIMER = 1
  43.     def __init__(self, *args, **kw):
  45.         super(Board, self).__init__(*args, **kw)
  47.         self.initBoard()
  49.     def initBoard(self):
  51.         self.timer = wx.Timer(self, Board.ID_TIMER)
  52.         self.isWaitingAfterLine = False
  53.         self.curPiece = Shape()
  54.         self.nextPiece = Shape()
  55.         self.curX = 0
  56.         self.curY = 0
  57.         self.numLinesRemoved = 0
  58.         self.board = []
  60.         self.isStarted = False
  61.         self.isPaused = False
  63.         self.Bind(wx.EVT_PAINT, self.OnPaint)
  64.         self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
  65.         self.Bind(wx.EVT_TIMER, self.OnTimer, id=Board.ID_TIMER)
  67.         self.clearBoard()
  69.     def shapeAt(self, x, y):
  71.         return self.board[(y * Board.BoardWidth) + x]
  73.     def setShapeAt(self, x, y, shape):
  75.         self.board[(y * Board.BoardWidth) + x] = shape
  77.     def squareWidth(self):
  79.         return self.GetClientSize().GetWidth() // Board.BoardWidth
  81.     def squareHeight(self):
  83.         return self.GetClientSize().GetHeight() // Board.BoardHeight
  85.     def start(self):
  87.         if self.isPaused:
  88.             return
  90.         self.isStarted = True
  91.         self.isWaitingAfterLine = False
  92.         self.numLinesRemoved = 0
  93.         self.clearBoard()
  95.         self.newPiece()
  96.         self.timer.Start(Board.Speed)
  98.     def pause(self):
  100.         if not self.isStarted:
  101.             return
  103.         self.isPaused = not self.isPaused
  104.         statusbar = self.GetParent().statusbar
  106.         if self.isPaused:
  107.             self.timer.Stop()
  108.             statusbar.SetStatusText('paused')
  109.         else:
  110.             self.timer.Start(Board.Speed)
  111.             statusbar.SetStatusText(str(self.numLinesRemoved))
  113.         self.Refresh()
  115.     def clearBoard(self):
  117.         for i in range(Board.BoardHeight * Board.BoardWidth):
  118.             self.board.append(Tetrominoes.NoShape)
  120.     def OnPaint(self, event):
  122.         dc = wx.PaintDC(self)
  124.         size = self.GetClientSize()
  125.         boardTop = size.GetHeight() - Board.BoardHeight * self.squareHeight()
  127.         for i in range(Board.BoardHeight):
  128.             for j in range(Board.BoardWidth):
  130.                 shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  132.                 if shape != Tetrominoes.NoShape:
  133.                     self.drawSquare(dc,
  134.                         0 + j * self.squareWidth(),
  135.                         boardTop + i * self.squareHeight(), shape)
  137.         if self.curPiece.shape() != Tetrominoes.NoShape:
  139.             for i in range(4):
  141.                 x = self.curX + self.curPiece.x(i)
  142.                 y = self.curY - self.curPiece.y(i)
  144.                 self.drawSquare(dc, 0 + x * self.squareWidth(),
  145.                     boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
  146.                     self.curPiece.shape())
  148.     def OnKeyDown(self, event):
  150.         if not self.isStarted or self.curPiece.shape() == Tetrominoes.NoShape:
  151.             event.Skip()
  152.             return
  154.         keycode = event.GetKeyCode()
  156.         if keycode == ord('P') or keycode == ord('p'):
  157.             self.pause()
  158.             return
  160.         if self.isPaused:
  161.             return
  163.         elif keycode == wx.WXK_LEFT:
  164.             self.tryMove(self.curPiece, self.curX - 1, self.curY)
  166.         elif keycode == wx.WXK_RIGHT:
  167.             self.tryMove(self.curPiece, self.curX + 1, self.curY)
  169.         elif keycode == wx.WXK_DOWN:
  170.             self.tryMove(self.curPiece.rotatedRight(), self.curX, self.curY)
  172.         elif keycode == wx.WXK_UP:
  173.             self.tryMove(self.curPiece.rotatedLeft(), self.curX, self.curY)
  175.         elif keycode == wx.WXK_SPACE:
  176.             self.dropDown()
  178.         elif keycode == ord('D') or keycode == ord('d'):
  179.             self.oneLineDown()
  181.         else:
  182.             event.Skip()
  184.     def OnTimer(self, event):
  186.         if event.GetId() == Board.ID_TIMER:
  188.             if self.isWaitingAfterLine:
  189.                 self.isWaitingAfterLine = False
  190.                 self.newPiece()
  192.             else:
  193.                 self.oneLineDown()
  195.         else:
  196.             event.Skip()
  198.     def dropDown(self):
  200.         newY = self.curY
  202.         while newY > 0:
  203.             if not self.tryMove(self.curPiece, self.curX, newY - 1):
  204.                 break
  205.             newY -= 1
  207.         self.pieceDropped()
  209.     def oneLineDown(self):
  211.         if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
  212.             self.pieceDropped()
  214.     def pieceDropped(self):
  216.         for i in range(4):
  218.             x = self.curX + self.curPiece.x(i)
  219.             y = self.curY - self.curPiece.y(i)
  220.             self.setShapeAt(x, y, self.curPiece.shape())
  222.         self.removeFullLines()
  224.         if not self.isWaitingAfterLine:
  225.             self.newPiece()
  227.     def removeFullLines(self):
  229.         numFullLines = 0
  231.         statusbar = self.GetParent().statusbar
  233.         rowsToRemove = []
  235.         for i in range(Board.BoardHeight):
  236.             n = 0
  237.             for j in range(Board.BoardWidth):
  238.                 if not self.shapeAt(j, i) == Tetrominoes.NoShape:
  239.                     n = n + 1
  241.             if n == 10:
  242.                 rowsToRemove.append(i)
  244.         rowsToRemove.reverse()
  246.         for m in rowsToRemove:
  247.             for k in range(m, Board.BoardHeight):
  248.                 for l in range(Board.BoardWidth):
  249.                         self.setShapeAt(l, k, self.shapeAt(l, k + 1))
  251.             numFullLines = numFullLines + len(rowsToRemove)
  253.             if numFullLines > 0:
  255.                 self.numLinesRemoved = self.numLinesRemoved + numFullLines
  256.                 statusbar.SetStatusText(str(self.numLinesRemoved))
  257.                 self.isWaitingAfterLine = True
  258.                 self.curPiece.setShape(Tetrominoes.NoShape)
  259.                 self.Refresh()
  261.     def newPiece(self):
  263.         self.curPiece = self.nextPiece
  264.         statusbar = self.GetParent().statusbar
  265.         self.nextPiece.setRandomShape()
  267.         self.curX = Board.BoardWidth // 2 + 1
  268.         self.curY = Board.BoardHeight - 1 + self.curPiece.minY()
  270.         if not self.tryMove(self.curPiece, self.curX, self.curY):
  272.             self.curPiece.setShape(Tetrominoes.NoShape)
  273.             self.timer.Stop()
  274.             self.isStarted = False
  275.             statusbar.SetStatusText('Game over')
  277.     def tryMove(self, newPiece, newX, newY):
  279.         for i in range(4):
  281.             x = newX + newPiece.x(i)
  282.             y = newY - newPiece.y(i)
  284.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  285.                 return False
  287.             if self.shapeAt(x, y) != Tetrominoes.NoShape:
  288.                 return False
  290.         self.curPiece = newPiece
  291.         self.curX = newX
  292.         self.curY = newY
  293.         self.Refresh()
  295.         return True
  297.     def drawSquare(self, dc, x, y, shape):
  299.         colors = ['#000000', '#CC6666', '#66CC66', '#6666CC',
  300.                   '#CCCC66', '#CC66CC', '#66CCCC', '#DAAA00']
  302.         light = ['#000000', '#F89FAB', '#79FC79', '#7979FC',
  303.                  '#FCFC79', '#FC79FC', '#79FCFC', '#FCC600']
  305.         dark = ['#000000', '#803C3B', '#3B803B', '#3B3B80',
  306.                  '#80803B', '#803B80', '#3B8080', '#806200']
  308.         pen = wx.Pen(light[shape])
  309.         pen.SetCap(wx.CAP_PROJECTING)
  310.         dc.SetPen(pen)
  312.         dc.DrawLine(x, y + self.squareHeight() - 1, x, y)
  313.         dc.DrawLine(x, y, x + self.squareWidth() - 1, y)
  315.         darkpen = wx.Pen(dark[shape])
  316.         darkpen.SetCap(wx.CAP_PROJECTING)
  317.         dc.SetPen(darkpen)
  319.         dc.DrawLine(x + 1, y + self.squareHeight() - 1,
  320.             x + self.squareWidth() - 1, y + self.squareHeight() - 1)
  321.         dc.DrawLine(x + self.squareWidth() - 1,
  322.         y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
  324.         dc.SetPen(wx.TRANSPARENT_PEN)
  325.         dc.SetBrush(wx.Brush(colors[shape]))
  326.         dc.DrawRectangle(x + 1, y + 1, self.squareWidth() - 2,
  327.         self.squareHeight() - 2)
  329. class Tetrominoes(object):
  331.     NoShape = 0
  332.     ZShape = 1
  333.     SShape = 2
  334.     LineShape = 3
  335.     TShape = 4
  336.     SquareShape = 5
  337.     LShape = 6
  338.     MirroredLShape = 7
  340. class Shape(object):
  342.     coordsTable = (
  343.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
  344.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
  345.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
  346.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
  347.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
  348.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
  349.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
  350.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
  351.     )
  353.     def __init__(self):
  355.         self.coords = [[0,0] for i in range(4)]
  356.         self.pieceShape = Tetrominoes.NoShape
  358.         self.setShape(Tetrominoes.NoShape)
  360.     def shape(self):
  362.         return self.pieceShape
  364.     def setShape(self, shape):
  366.         table = Shape.coordsTable[shape]
  367.         for i in range(4):
  368.             for j in range(2):
  369.                 self.coords[i][j] = table[i][j]
  371.         self.pieceShape = shape
  373.     def setRandomShape(self):
  375.         self.setShape(random.randint(1, 7))
  377.     def x(self, index):
  379.         return self.coords[index][0]
  381.     def y(self, index):
  383.         return self.coords[index][1]
  385.     def setX(self, index, x):
  387.         self.coords[index][0] = x
  389.     def setY(self, index, y):
  391.         self.coords[index][1] = y
  393.     def minX(self):
  395.         m = self.coords[0][0]
  396.         for i in range(4):
  397.             m = min(m, self.coords[i][0])
  399.         return m
  401.     def maxX(self):
  403.         m = self.coords[0][0]
  404.         for i in range(4):
  405.             m = max(m, self.coords[i][0])
  407.         return m
  409.     def minY(self):
  411.         m = self.coords[0][1]
  412.         for i in range(4):
  413.             m = min(m, self.coords[i][1])
  415.         return m
  417.     def maxY(self):
  419.         m = self.coords[0][1]
  421.         for i in range(4):
  422.             m = max(m, self.coords[i][1])
  424.         return m
  426.     def rotatedLeft(self):
  428.         if self.pieceShape == Tetrominoes.SquareShape:
  429.             return self
  431.         result = Shape()
  432.         result.pieceShape = self.pieceShape
  434.         for i in range(4):
  435.             result.setX(i, self.y(i))
  436.             result.setY(i, -self.x(i))
  438.         return result
  440.     def rotatedRight(self):
  442.         if self.pieceShape == Tetrominoes.SquareShape:
  443.             return self
  445.         result = Shape()
  446.         result.pieceShape = self.pieceShape
  448.         for i in range(4):
  449.             result.setX(i, -self.y(i))
  450.             result.setY(i, self.x(i))
  452.         return result
  454. def main():
  456.     app = wx.App()
  457.     ex = Tetris(None)
  458.     ex.Show()
  459.     app.MainLoop()
  461. if __name__ == '__main__':
  462.     main()

游戏进行了简化，以便于理解。 它在启动应用后立即启动。 我们可以通过按 p 键暂停游戏。 空格键将下降的俄罗斯方块片段立即放到底部。 d 键将棋子下降一行。 （可以用来加快跌落速度。）游戏以恒定速度进行，没有实现加速。 分数是我们已删除的行数。

  1. def __init__(self, *args, **kw):
  3.     super(Board, self).__init__(*args, **kw)

Windows 用户注意事项。 如果无法使用箭头键，则将style=wx.WANTS_CHARS添加到板子构造器中。

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

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

  1. for i in range(Board.BoardHeight):
  2.     for j in range(Board.BoardWidth):
  4.         shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  6.         if shape != Tetrominoes.NoShape:
  7.             self.drawSquare(dc,
  8.                 0 + j * self.squareWidth(),
  9.                 boardTop + i * self.squareHeight(), shape)

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

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

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

  1. elif keycode == wx.WXK_LEFT:
  2.     self.tryMove(self.curPiece, self.curX - 1, self.curY)

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

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

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

  1. def OnTimer(self, event):
  3.     if event.GetId() == Board.ID_TIMER:
  4.         if self.isWaitingAfterLine:
  5.             self.isWaitingAfterLine = False
  6.             self.newPiece()
  7.         else:
  8.             self.oneLineDown()
  9.     else:
  10.         event.Skip()

在OnTimer()方法中，我们可以创建一个新的片段，将前一个片段放到底部，或者将下降的片段向下移动一行。

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

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

  1. def newPiece(self):
  3.     self.curPiece = self.nextPiece
  4.     statusbar = self.GetParent().statusbar
  5.     self.nextPiece.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(Tetrominoes.NoShape)
  12.         self.timer.Stop()
  13.         self.isStarted = False
  14.         statusbar.SetStatusText('Game over')

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

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

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

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

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

图：坐标

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

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

图：俄罗斯方块

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