本文代码基于 python3.6 和 pygame1.9.4。python

俄罗斯方块是儿时最经典的游戏之一，刚开始接触 pygame 的时候就想写一个俄罗斯方块。可是想到旋转，停靠，消除等操做，感受好像很难啊，等真正写完了发现，一共也就 300 行代码，并无什么难的。数组

先来看一个游戏截图，有点丑，好吧，我没啥美术细胞，可是主体功能都实现了，能够玩起来。app

image

如今来看一下实现的过程。dom

外形

俄罗斯方块整个界面分为两部分，一部分是左边的游戏区域，另外一部分是右边的显示区域，显示得分、速度、下一个方块样式等。这里就不放截图了，看上图就能够。字体

游戏区域跟贪吃蛇同样，是由一个个小方格组成的，为了看得直观，我特地画了网格线。code

import sys

import pygame

from pygame.locals import *

SIZE = 30 # 每一个小方格大小

BLOCK_HEIGHT = 20 # 游戏区高度

BLOCK_WIDTH = 10 # 游戏区宽度

BORDER_WIDTH = 4 # 游戏区边框宽度

BORDER_COLOR = (40, 40, 200) # 游戏区边框颜色

SCREEN_WIDTH = SIZE * (BLOCK_WIDTH + 5) # 游戏屏幕的宽

SCREEN_HEIGHT = SIZE * BLOCK_HEIGHT # 游戏屏幕的高

BG_COLOR = (40, 40, 60) # 背景色

BLACK = (0, 0, 0)

def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):

imgText = font.render(text, True, fcolor)

screen.blit(imgText, (x, y))

def main():

pygame.init()

screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.display.set_caption('俄罗斯方块')

font1 = pygame.font.SysFont('SimHei', 24) # 黑体24

font_pos_x = BLOCK_WIDTH * SIZE + BORDER_WIDTH + 10 # 右侧信息显示区域字体位置的X坐标

font1_height = int(font1.size('得分')[1])

score = 0 # 得分

while True:

for event in pygame.event.get():

if event.type == QUIT:

sys.exit()

# 填充背景色

screen.fill(BG_COLOR)

# 画游戏区域分隔线

pygame.draw.line(screen, BORDER_COLOR,

(SIZE * BLOCK_WIDTH + BORDER_WIDTH // 2, 0),

(SIZE * BLOCK_WIDTH + BORDER_WIDTH // 2, SCREEN_HEIGHT), BORDER_WIDTH)

# 画网格线 竖线

for x in range(BLOCK_WIDTH):

pygame.draw.line(screen, BLACK, (x * SIZE, 0), (x * SIZE, SCREEN_HEIGHT), 1)

# 画网格线 横线

for y in range(BLOCK_HEIGHT):

pygame.draw.line(screen, BLACK, (0, y * SIZE), (BLOCK_WIDTH * SIZE, y * SIZE), 1)

print_text(screen, font1, font_pos_x, 10, f'得分: ')

print_text(screen, font1, font_pos_x, 10 + font1_height + 6, f'{score}')

print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 2, f'速度: ')

print_text(screen, font1, font_pos_x, 20 + (font1_height + 6) * 3, f'{score // 10000}')

print_text(screen, font1, font_pos_x, 30 + (font1_height + 6) * 4, f'下一个：')

pygame.display.flip()

if __name__ == '__main__':

main()

方块

接下来就是要定义方块，方块的形状一共有如下 7 种：blog

I 型

O 型

T 型

S 型

Z 型

L 型

J 型

这里我作了屡次的更改，由于方块最大的长度是长条形的，为4格，因此我统一用了 4 × 4 的方格来定义。这也是能够的，只是后来发现不方便。游戏

为了直观，直接以一个二维数组来定义方块，其中 . 表示空的， 0 表示实心的。(用 . 表示空是为了看得直观，若是用空格会看不清。)

例如 I 行，以 4 × 4 方格定义为ip

['.0..',

'.0..',

'.0..',

'.0..']

和rem

['....',

'....',

'0000',

'....']

方块最难的是须要实现旋转功能，好比 I 型，就有横和竖两种形态。所谓旋转，表面上看，是把方块顺时针旋转了 90°，但实际作的时候，咱们并不须要正真的去实现这个“旋转”的效果。

最终实现的时候，这些图形都是咱们画在界面上的，而每一次刷新，界面上全部内容都会被清空重画，因此旋转只是画当前方块的时候再也不画以前的形状，而是画旋转后的形状。

好比这个 I 型，定义成了 4 × 4 的形状，但实际上只须要 1 × 4 或 4 × 1 就能够了，其余剩下的地方都是空的。它不像 T 型，T 型不是一个矩形，若是用一个矩形来定义，必然有 2 个位置是空的。那么，I 型真的有必要定义成 4 × 4 吗？

答案是确定的。想一想看，若是是 4 × 1 的一个横条，旋转后变成 1 × 4 的竖条，这个位置怎么肯定？好像有点困难。可是若是是 4 × 4 的正方形，咱们只须要固定起点坐标(左上角)不变，把竖条的 4 × 4 直接替换掉横条的 4 × 4 区域，是否是就实现旋转了？并且位置很容易计算。

另一点，在有些状况下是不能够旋转的。好比 I 型的竖条，在紧贴左右边框的时候是不能够旋转的。这点我有印象，能够确定。可是对于其余的形状，我就不是很肯定了，我百度搜了下，找了个网页版的俄罗斯方块玩了下，发现也是不能够的。例如：

在紧贴右边框的时候是没法旋转的。若是要每个形状都去判断一下，那实在是太烦了。从方块的定义入手，就能够很简单的实现。

例如竖条行，定义是：

['.0..',

'.0..',

'.0..',

'.0..']

竖条是能够贴边的，因此当它在最左边的时候，X 轴坐标是 -1，这是由于定义中左边一竖排是空的。咱们只需断定，当方块所定义的形状(包括空的部分)彻底在游戏区域内时才能够旋转。

我以前所说，全都定义成 4 × 4 很差，缘由就在这里，对于 T 型等其余形状，没法作这个断定。因此，对于 T 型等形状，咱们能够定义成 3 × 3 的格式：

['.0.',

'000',

'...']

还有一种状况是没法旋转的，就是旋转后的位置已经被别的方块占了。另外下落，左右移动，都要作这个判断。既然这些是一致的，那么就能够用同一个方法来判断。

先要定义一个 game_area 变量，用于存放整个游戏区域当前的状态：

game_area = [['.'] * BLOCK_WIDTH for _ in range(BLOCK_HEIGHT)]

初始状态全是空的，因此所有用 . 初始化就能够了。

另外，须要一些变量定义当前下落方块的状态

cur_block = None # 当前下落方块

cur_pos_x, cur_pos_y = 0, 0 # 当前下落方块的坐标

方块咱们是以二维数组的方式定义的，而且存在空行和空列，若是咱们遍历这个二维数组判断其所在的区域在当前游戏区域内是否已经被别的方块所占，这个是能够实现的。咱们考虑另一种状况，一个竖条形，左边一排是空的，这空的一排是能够移出游戏区域的，这个怎么判断？每次左移的时候都去判断一下左边一排全都是空吗？这太麻烦了。而且方块都是固定的，因此这些咱们能够提早定义好。最终方块定义以下：

from collections import namedtuple

Point = namedtuple('Point', 'X Y')

Block = namedtuple('Block', 'template start_pos end_pos name next')

# S形方块

S_BLOCK = [Block(['.00',

'00.',

'...'], Point(0, 0), Point(2, 1), 'S', 1),

Block(['0..',

'00.',

'.0.'], Point(0, 0), Point(1, 2), 'S', 0)]

方块须要包含两个方法，获取随机一个方块和旋转时获取旋转后的方块

BLOCKS = {'O': O_BLOCK,

'I': I_BLOCK,

'Z': Z_BLOCK,

'T': T_BLOCK,

'L': L_BLOCK,

'S': S_BLOCK,

'J': J_BLOCK}

def get_block():

block_name = random.choice('OIZTLSJ')

b = BLOCKS[block_name]

idx = random.randint(0, len(b) - 1)

return b[idx]

# 获取旋转后的方块

def get_next_block(block):

b = BLOCKS[block.name]

return b[block.next]

判断是否能够旋转，下落，移动的方法也很容易实现了

def _judge(pos_x, pos_y, block):

nonlocal game_area

for _i in range(block.start_pos.Y, block.end_pos.Y + 1):

if pos_y + block.end_pos.Y >= BLOCK_HEIGHT:

return False

for _j in range(block.start_pos.X, block.end_pos.X + 1):

if pos_y + _i >= 0 and block.template[_i][_j] != '.' and game_area[pos_y + _i][pos_x + _j] != '.':

return False

return True

停靠

最后一个问题是停靠，当方块下落到底或者遇到别的方块以后，就不能在下落了。我将此称之为”停靠“，有个名字提及来也方便一点。

首先是要判断是否能够停靠，停靠发生以后，就是将当前方块的非空点画到游戏区域上，说白了，就是将cur_block的非空点按对应位置复制到game_area里去。而且计算是否有一排被所有填满了，所有填满则消除。

def _dock():

nonlocal cur_block, next_block, game_area, cur_pos_x, cur_pos_y, game_over

for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):

for _j in range(cur_block.start_pos.X, cur_block.end_pos.X + 1):

if cur_block.template[_i][_j] != '.':

game_area[cur_pos_y + _i][cur_pos_x + _j] = '0'

if cur_pos_y + cur_block.start_pos.Y <= 0:

game_over = True

else:

# 计算消除

remove_idxs = []

for _i in range(cur_block.start_pos.Y, cur_block.end_pos.Y + 1):

if all(_x == '0' for _x in game_area[cur_pos_y + _i]):

remove_idxs.append(cur_pos_y + _i)

if remove_idxs:

# 消除

_i = _j = remove_idxs[-1]

while _i >= 0:

while _j in remove_idxs:

_j -= 1

if _j < 0:

game_area[_i] = ['.'] * BLOCK_WIDTH

else:

game_area[_i] = game_area[_j]

_i -= 1

_j -= 1

cur_block = next_block

next_block = blocks.get_block()

cur_pos_x, cur_pos_y = (BLOCK_WIDTH - cur_block.end_pos.X - 1) // 2, -1 - cur_block.end_pos.Y

至此，整个俄罗斯方块的主体功能就算是完成了。

这里不少参数是能够调的，例如以为旋转别扭，能够直接调整方块的定义，而无需去改动代码逻辑。

后台回复 俄罗斯方块，获取源码。

扫码关注个人我的公众号