共计 5092 个字符，预计需要花费 13 分钟才能阅读完成。
【pygame】Python 不到 300 行代码实现俄罗斯方块
本文代码基于 python3.6 和 pygame1.9.4。
俄罗斯方块是儿时最经典的游戏之一，刚开始接触 pygame 的时候就想写一个俄罗斯方块。然而想到旋转，停泊，打消等操作，感觉如同很难啊，等真正写完了发现，一共也就 300 行代码，并没有什么难的。
先来看一个游戏截图，有点丑，好吧，我没啥美术细胞，然而主体性能都实现了，能够玩起来。
当初来看一下实现的过程。
形状
俄罗斯方块整个界面分为两局部，一部分是右边的游戏区域，另一部分是左边的显示区域，显示得分、速度、下一个方块款式等。这里就不放截图了，看上图就能够。
游戏区域跟贪吃蛇一样，是由一个个小方格组成的，为了看得直观，我特意画了网格线。
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 种：
I 型
O 型
T 型
S 型
Z 型
L 型
J 型
这里我做了屡次的更改，因为方块最大的长度是长条形的，为 4 格，所以我对立用了 4 × 4 的方格来定义。这也是能够的，只是起初发现不不便。
为了直观，间接以一个二维数组来定义方块，其中 . 示意空的，0 示意实心的。（用 . 示意空是为了看得直观，如果用空格会看不清。）
例如 I 行，以 4 × 4 方格定义为
[‘.0..’,
‘.0..’,
‘.0..’,
‘.0..’]
和
[‘….’,
‘….’,
‘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至此，整个俄罗斯方块的主体性能就算是实现了。
这里很多参数是能够调的，例如感觉旋转顺当，能够间接调整方块的定义，而无需去改变代码逻辑。