http://zetcode.com/tutorials/ironpythontutorial/tetris/

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

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

IronPython Mono Winforms 中的俄罗斯方块游戏 - 图1

图：Tetrominoes

开发

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

游戏背后的一些想法。

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

以下示例是俄罗斯方块游戏的修改版，可用于 PyQt4 安装文件。

tetris.py

  1. #!/usr/bin/ipy
  3. import clr
  5. clr.AddReference("System.Windows.Forms")
  6. clr.AddReference("System.Drawing")
  7. clr.AddReference("System")
  9. from System.Windows.Forms import Application, Form, FormBorderStyle
  10. from System.Windows.Forms import UserControl, Keys, Timer, StatusBar
  11. from System.Drawing import Size, Color, SolidBrush, Pen
  12. from System.Drawing.Drawing2D import LineCap
  13. from System.ComponentModel import Container
  14. from System import Random
  16. class Tetrominoes(object):
  17.     NoShape = 0
  18.     ZShape = 1
  19.     SShape = 2
  20.     LineShape = 3
  21.     TShape = 4
  22.     SquareShape = 5
  23.     LShape = 6
  24.     MirroredLShape = 7
  26. class Board(UserControl):
  27.     BoardWidth = 10
  28.     BoardHeight = 22
  29.     Speed = 200
  30.     ID_TIMER = 1
  32.     def __init__(self):
  33.         self.Text = 'Snake'
  35.         self.components = Container()
  36.         self.isWaitingAfterLine = False
  37.         self.curPiece = Shape()
  38.         self.nextPiece = Shape()
  39.         self.curX = 0
  40.         self.curY = 0
  41.         self.numLinesRemoved = 0
  42.         self.board = []
  44.         self.DoubleBuffered = True
  46.         self.isStarted = False
  47.         self.isPaused = False
  49.         self.timer = Timer(self.components)
  50.         self.timer.Enabled = True
  51.         self.timer.Interval = Board.Speed
  52.         self.timer.Tick += self.OnTick
  54.         self.Paint += self.OnPaint
  55.         self.KeyUp += self.OnKeyUp
  57.         self.ClearBoard()
  59.     def ShapeAt(self, x, y):
  60.         return self.board[(y * Board.BoardWidth) + x]
  62.     def SetShapeAt(self, x, y, shape):
  63.         self.board[(y * Board.BoardWidth) + x] = shape
  65.     def SquareWidth(self):
  66.         return self.ClientSize.Width / Board.BoardWidth
  68.     def SquareHeight(self):
  69.         return self.ClientSize.Height / Board.BoardHeight
  71.     def Start(self):
  72.         if self.isPaused:
  73.             return
  75.         self.isStarted = True
  76.         self.isWaitingAfterLine = False
  77.         self.numLinesRemoved = 0
  78.         self.ClearBoard()
  80.         self.NewPiece()
  82.     def Pause(self):
  83.         if not self.isStarted:
  84.             return
  86.         self.isPaused = not self.isPaused        
  87.         statusbar = self.Parent.statusbar
  89.         if self.isPaused:
  90.             self.timer.Stop()
  91.             statusbar.Text = 'paused'
  92.         else:
  93.             self.timer.Start()
  94.             statusbar.Text = str(self.numLinesRemoved)
  96.         self.Refresh()
  98.     def ClearBoard(self):
  99.         for i in range(Board.BoardHeight * Board.BoardWidth):
  100.             self.board.append(Tetrominoes.NoShape)
  102.     def OnPaint(self, event):
  104.         g = event.Graphics
  106.         size = self.ClientSize
  107.         boardTop = size.Height - Board.BoardHeight * self.SquareHeight()
  109.         for i in range(Board.BoardHeight):
  110.             for j in range(Board.BoardWidth):
  111.                 shape = self.ShapeAt(j, Board.BoardHeight - i - 1)
  112.                 if shape != Tetrominoes.NoShape:
  113.                     self.DrawSquare(g,
  114.                         0 + j * self.SquareWidth(),
  115.                         boardTop + i * self.SquareHeight(), shape)
  117.         if self.curPiece.GetShape() != Tetrominoes.NoShape:
  118.             for i in range(4):
  119.                 x = self.curX + self.curPiece.x(i)
  120.                 y = self.curY - self.curPiece.y(i)
  121.                 self.DrawSquare(g, 0 + x * self.SquareWidth(),
  122.                     boardTop + (Board.BoardHeight - y - 1) * self.SquareHeight(),
  123.                     self.curPiece.GetShape())
  125.         g.Dispose()
  127.     def OnKeyUp(self, event): 
  129.         if not self.isStarted or self.curPiece.GetShape() == Tetrominoes.NoShape:
  130.             return
  132.         key = event.KeyCode
  134.         if key == Keys.P:
  135.             self.Pause()
  136.             return
  138.         if self.isPaused:
  139.             return    
  140.         elif key == Keys.Left:
  141.             self.TryMove(self.curPiece, self.curX - 1, self.curY)
  142.         elif key == Keys.Right:
  143.             self.TryMove(self.curPiece, self.curX + 1, self.curY)
  144.         elif key == Keys.Down:
  145.             self.TryMove(self.curPiece.RotatedRight(), self.curX, self.curY)
  146.         elif key == Keys.Up:
  147.             self.TryMove(self.curPiece.RotatedLeft(), self.curX, self.curY)
  148.         elif key == Keys.Space:
  149.             self.DropDown()
  150.         elif key == Keys.D:
  151.             self.OneLineDown()
  153.     def OnTick(self, sender, event):
  155.         if self.isWaitingAfterLine:
  156.             self.isWaitingAfterLine = False
  157.             self.NewPiece()
  158.         else:
  159.             self.OneLineDown()
  161.     def DropDown(self):
  162.         newY = self.curY
  163.         while newY > 0:
  164.             if not self.TryMove(self.curPiece, self.curX, newY - 1):
  165.                 break
  166.             newY -= 1
  168.         self.PieceDropped()
  170.     def OneLineDown(self):
  171.         if not self.TryMove(self.curPiece, self.curX, self.curY - 1):
  172.             self.PieceDropped()
  174.     def PieceDropped(self):
  175.         for i in range(4):
  176.             x = self.curX + self.curPiece.x(i)
  177.             y = self.curY - self.curPiece.y(i)
  178.             self.SetShapeAt(x, y, self.curPiece.GetShape())
  180.         self.RemoveFullLines()
  182.         if not self.isWaitingAfterLine:
  183.             self.NewPiece()
  185.     def RemoveFullLines(self):
  186.         numFullLines = 0
  188.         statusbar = self.Parent.statusbar
  190.         rowsToRemove = []
  192.         for i in range(Board.BoardHeight):
  193.             n = 0
  194.             for j in range(Board.BoardWidth):
  195.                 if not self.ShapeAt(j, i) == Tetrominoes.NoShape:
  196.                     n = n + 1
  198.             if n == 10:
  199.                 rowsToRemove.append(i)
  201.         rowsToRemove.reverse()
  203.         for m in rowsToRemove:
  204.             for k in range(m, Board.BoardHeight):
  205.                 for l in range(Board.BoardWidth):
  206.                     self.SetShapeAt(l, k, self.ShapeAt(l, k + 1))
  208.         numFullLines = numFullLines + len(rowsToRemove)
  210.         if numFullLines > 0:
  211.             self.numLinesRemoved = self.numLinesRemoved + numFullLines
  212.             statusbar.Text = str(self.numLinesRemoved)
  213.             self.isWaitingAfterLine = True
  214.             self.curPiece.SetShape(Tetrominoes.NoShape)
  215.             self.Refresh()
  217.     def NewPiece(self):
  218.         self.curPiece = self.nextPiece
  219.         statusbar = self.Parent.statusbar
  220.         self.nextPiece.SetRandomShape()
  221.         self.curX = Board.BoardWidth / 2 + 1
  222.         self.curY = Board.BoardHeight - 1 + self.curPiece.MinY()
  224.         if not self.TryMove(self.curPiece, self.curX, self.curY):
  225.             self.curPiece.SetShape(Tetrominoes.NoShape)
  226.             self.timer.Stop()
  227.             self.isStarted = False
  228.             statusbar.Text = 'Game over'
  230.     def TryMove(self, newPiece, newX, newY):
  231.         for i in range(4):
  232.             x = newX + newPiece.x(i)
  233.             y = newY - newPiece.y(i)
  234.             if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  235.                 return False
  236.             if self.ShapeAt(x, y) != Tetrominoes.NoShape:
  237.                 return False
  239.         self.curPiece = newPiece
  240.         self.curX = newX
  241.         self.curY = newY
  242.         self.Refresh()
  243.         return True
  245.     def DrawSquare(self, g, x, y, shape):
  246.         colors = [ (0, 0, 0), (204, 102, 102), 
  247.             (102, 204, 102), (102, 102, 204), 
  248.             (204, 204, 102), (204, 102, 204), 
  249.             (102, 204, 204), (218, 170, 0) ]
  251.         light = [ (0, 0, 0), (248, 159, 171), 
  252.             (121, 252, 121), (121, 121, 252), 
  253.             (252, 252, 121), (252, 121, 252), 
  254.             (121, 252, 252), (252, 198, 0) ]
  256.         dark = [ (0, 0, 0), (128, 59, 59), 
  257.             (59, 128, 59), (59, 59, 128), 
  258.             (128, 128, 59), (128, 59, 128), 
  259.             (59, 128, 128), (128, 98, 0) ]   
  261.         pen = Pen(Color.FromArgb(light[shape][0], light[shape][1],
  262.             light[shape][2]), 1)
  263.         pen.StartCap = LineCap.Flat
  264.         pen.EndCap = LineCap.Flat
  266.         g.DrawLine(pen, x, y + self.SquareHeight() - 1, x, y)
  267.         g.DrawLine(pen, x, y, x + self.SquareWidth() - 1, y)
  269.         darkpen = Pen(Color.FromArgb(dark[shape][0], dark[shape][1],
  270.             dark[shape][2]), 1)
  271.         darkpen.StartCap = LineCap.Flat
  272.         darkpen.EndCap = LineCap.Flat
  274.         g.DrawLine(darkpen, x + 1, y + self.SquareHeight() - 1,
  275.             x + self.SquareWidth() - 1, y + self.SquareHeight() - 1)
  276.         g.DrawLine(darkpen, x + self.SquareWidth() - 1, 
  277.             y + self.SquareHeight() - 1, x + self.SquareWidth() - 1, y + 1)
  279.         g.FillRectangle(SolidBrush(Color.FromArgb(colors[shape][0], colors[shape][1], 
  280.             colors[shape][2])), x + 1, y + 1, self.SquareWidth() - 1, 
  281.             self.SquareHeight() - 2)
  283.         pen.Dispose()
  284.         darkpen.Dispose()
  286. class Shape(object):
  287.     coordsTable = (
  288.         ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
  289.         ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
  290.         ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
  291.         ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
  292.         ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
  293.         ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
  294.         ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
  295.         ((1, -1),    (0, -1),    (0, 0),     (0, 1))
  296.     )
  298.     def __init__(self):
  299.         self.coords = [[0,0] for i in range(4)]
  300.         self.pieceShape = Tetrominoes.NoShape
  302.         self.SetShape(Tetrominoes.NoShape)
  304.     def GetShape(self):
  305.         return self.pieceShape
  307.     def SetShape(self, shape):
  308.         table = Shape.coordsTable[shape]
  309.         for i in range(4):
  310.             for j in range(2):
  311.                 self.coords[i][j] = table[i][j]
  313.         self.pieceShape = shape
  315.     def SetRandomShape(self):
  316.         rand = Random()
  317.         self.SetShape(rand.Next(1, 7))
  319.     def x(self, index):
  320.         return self.coords[index][0]
  322.     def y(self, index):
  323.         return self.coords[index][1]
  325.     def SetX(self, index, x):
  326.         self.coords[index][0] = x
  328.     def SetY(self, index, y):
  329.         self.coords[index][1] = y
  331.     def MaxX(self):
  332.         m = self.coords[0][0]
  333.         for i in range(4):
  334.             m = max(m, self.coords[i][0])
  336.         return m
  338.     def MinY(self):
  339.         m = self.coords[0][1]
  340.         for i in range(4):
  341.             m = min(m, self.coords[i][1])
  343.         return m
  345.     def RotatedLeft(self):
  346.         if self.pieceShape == Tetrominoes.SquareShape:
  347.             return self
  349.         result = Shape()
  350.         result.pieceShape = self.pieceShape
  351.         for i in range(4):
  352.             result.SetX(i, self.y(i))
  353.             result.SetY(i, -self.x(i))
  355.         return result
  357.     def RotatedRight(self):
  358.         if self.pieceShape == Tetrominoes.SquareShape:
  359.             return self
  361.         result = Shape()
  362.         result.pieceShape = self.pieceShape
  363.         for i in range(4):
  364.             result.SetX(i, -self.y(i))
  365.             result.SetY(i, self.x(i))
  367.         return result   
  369. class IForm(Form):
  371.     def __init__(self):
  372.         self.Text = 'Tetris'
  373.         self.Width = 200
  374.         self.Height = 430
  375.         self.FormBorderStyle = FormBorderStyle.FixedSingle
  376.         board = Board()
  377.         board.Width = 195
  378.         board.Height = 380
  379.         self.Controls.Add(board)
  381.         self.statusbar = StatusBar()
  382.         self.statusbar.Parent = self
  383.         self.statusbar.Text = 'Ready'
  384.         board.Start()
  385.         self.CenterToScreen()
  387. Application.Run(IForm())

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

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

tetrominoes 有七种不同类型。

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

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

  1. def ClearBoard(self):
  2.     for i in range(Board.BoardHeight * Board.BoardWidth):
  3.         self.board.append(Tetrominoes.NoShape)

ClearBoard()方法清除电路板。 它用Tetrominoes.NoShape值填充self.board变量。

俄罗斯方块游戏中的绘图是通过OnPaint()方法完成的。

  1. for i in range(Board.BoardHeight):
  2.     for j in range(Board.BoardWidth):
  3.         shape = self.shapeAt(j, Board.BoardHeight - i - 1)
  4.         if shape != Tetrominoes.NoShape:
  5.             self.drawSquare(g,
  6.                 0 + j * self.squareWidth(),
  7.                 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(g, 0 + x * self.squareWidth(),
  6.             boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
  7.             self.curPiece.shape())

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

在OnKeyUp()方法中，我们检查按键是否按下。

  1. elif key == Keys.Left:
  2.     self.tryMove(self.curPiece, self.curX - 1, self.curY)

如果按向左箭头键，我们将尝试将棋子向左移动。 我们说尝试，因为这片可能无法移动。

在TryMove()方法中，我们尝试移动形状。 如果无法移动该片段，则返回False。

  1. for i in range(4):
  2.     x = newX + newPiece.x(i)
  3.     y = newY - newPiece.y(i)
  4.     if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
  5.         return False
  6.     if self.ShapeAt(x, y) != Tetrominoes.NoShape:
  7.         return False

如果形状在板的边缘或与其他零件相邻，则返回False。

  1. self.curPiece = newPiece
  2. self.curX = newX
  3. self.curY = newY
  4. self.Refresh()
  5. return True

否则，我们将当前的下降片放到新位置并返回True。

  1. def OnTick(self, sender, event):
  3.    if self.isWaitingAfterLine:
  4.        self.isWaitingAfterLine = False
  5.        self.NewPiece()
  6.    else:
  7.        self.OneLineDown()

在OnTick()方法中，我们要么在前一个击中底部之后创建一个新片段，要么将下降的片段向下移动一行。

如果片段触底，我们将调用RemoveFullLines()方法。 首先，我们找出所有实线。

  1. rowsToRemove = []
  2. for i in range(Board.BoardHeight):
  3.     n = 0
  4.     for j in range(Board.BoardWidth):
  5.         if not self.ShapeAt(j, i) == Tetrominoes.NoShape:
  6.             n = n + 1
  7.     if n == 10:
  8.         rowsToRemove.append(i)

我们在董事会中循环。 一排可以有十个形状。 如果该行已满，例如 n 等于 10，我们存储行号以供以后删除。

  1. rowsToRemove.reverse()
  3. for m in rowsToRemove:
  4.     for k in range(m, Board.BoardHeight):
  5.         for l in range(Board.BoardWidth):
  6.             self.SetShapeAt(l, k, self.ShapeAt(l, k + 1))

这些代码行将删除所有行。 我们颠倒了rowsToRemove列表的顺序，因此我们从最底部的全行开始。 我们要做的是通过将一行中的所有行向下放置一行来删除整行。 对于所有实线都会发生这种情况。在我们的情况下，我们使用天真重力。 这意味着碎片可能漂浮在空的间隙上方。

  1. def NewPiece(self):
  2.     self.curPiece = self.nextPiece
  3.     statusbar = self.Parent.statusbar
  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.         statusbar.Text = 'Game over'

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

  1. colors = [ (0, 0, 0), (204, 102, 102), 
  2.     ... ]
  4. light = [ (0, 0, 0), (248, 159, 171), 
  5.     ... ]
  7. dark = [ (0, 0, 0), (128, 59, 59), 
  8.     ... ]

一共有三种颜色。 colours列表存储正方形填充的颜色值。 七块每个都有其自己的颜色。 light和dark存储线条的颜色，使正方形看起来像 3D。 这些颜色是相同的，只是越来越浅。 我们将在正方形的顶部和左侧绘制两条浅色的线条，并在右侧和底部绘制两条深色的线条。

  1. g.DrawLine(pen, x, y + self.SquareHeight() - 1, x, y)
  2. g.DrawLine(pen, x, y, x + self.SquareWidth() - 1, y)

这两条线绘制一个正方形的亮线。

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

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

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

IronPython Mono Winforms 中的俄罗斯方块游戏 - 图2

图：坐标

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

RotateLeft()方法将一块向左旋转。

  1. if self.pieceShape == Tetrominoes.SquareShape:
  2.     return self

如果我们有Tetrominoes.SquareShape个，我们什么也不做。 此形状始终相同。

  1. result = Shape()
  2. result.pieceShape = self.pieceShape
  3. for i in range(4):
  4.     result.SetX(i, self.y(i))
  5.     result.SetY(i, -self.x(i))
  7. return result

在其他情况下，我们更改作品的坐标。 要了解此代码，请查看上图。

IronPython Mono Winforms 中的俄罗斯方块游戏 - 图3

图：俄罗斯方块

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