用100行python代码制作俄罗斯方块游戏，俄罗斯方块游戏教程-附完整代码

本项目通过python自带库tkinter实现，无需安装第三方库

本项目基于python3版本开发（如果你的是python2.x，运行可能会有问题）

一、基础界面

1、搭建基础窗体

使用tkinter库实现基础窗体，不加入任何功能只需如下三行代码

接下来我们需要在窗体里面，添加一个画布容器用来“装”俄罗斯方块，就是让这个画布作为面板，俄罗斯方块的移动和绘制均在这个画板上实现。

这里我们设定一些俄罗斯方块游戏参数

行数为row（取20）

列数为col（取12）

俄罗斯方块的边长为cell_size（取30）

通过tkinger的画布类Canvas实现的代码如下

接下来在画板上绘制俄罗斯方块空白位

首先建立一个函数draw_cell_by_cr，用于在画板上绘制单个俄罗斯方块

然后建立一个函数draw_blank_board，用于在画板上绘制所有空白方块（也就是空白方块板，为了和背景区分，所以设置空白方块为轻灰色）

此时整体代码如下：

此时运行代码生成的窗口如下

3、绘制o形俄罗斯方块

先从最简单的o型俄罗斯方块（即田字格，如下图）

我们先要记录每各形状所有格子的坐标

以格子所在行序号为纵坐标，所在列序号为横坐标

[       (-1, -1),        (0, -1),        (-1, 0),        (0, 0)   ]   

我们将俄罗斯方块形状字符串和坐标列表的映射关系存到字典SHAPES里（映射关系这里可以理解为一一对应的关系），

同时建立一个字典SHAPESCOLOR，来记录俄罗斯方块形状字符串和颜色的一一对应关系。

由于一个形状可以看成多个方格组成的，所以我们可以新建函数draw_cells用来绘制这个形状

最后选择一个地方来绘制这个形状。

此时运行代码生成的窗口如下

3、其他俄罗斯方块

俄罗斯方块主流分七种，除去上面的O型，其他六俄罗斯方块如图所示

对应的，要在SHAPES和SHAPESCOLOR中添加其他方块的坐标和颜色

将原来绘制O型俄罗斯方块处的代码改成如下代码，将这七种俄罗斯方块绘制出来

绘制出来的效果如图

二、界面动起来

0、思路

要让游戏界面动起来，需要实现两点

• 1-定时刷新页面

• 2-移动页面内部的俄罗斯方块

这块说一下，光实现一的话理论上页面也算动起来了，但是如果界面内容不变，每次新的页面和旧的界面看起来是一样的，给人的观看感觉跟没有动没有区别

所以必须要实现2，来更改界面内容，给人“动”起来的感觉

1、定时刷新页面

实现定时刷新页面，很简单

写一个方法用于循环刷新，再定时调用

此时运行发现命令行中会有如下输出，说明这个页面确实是每隔500ms刷新了一次

但是由于我之前说的，每次刷新后页面的内容是没有变化的，给观众的感觉还是更没动一样

所以需要配合每次刷新，移动俄罗斯方块的位置

2、移动俄罗斯方块

对于某个俄罗斯方块，要绘制出来需要知道它的位置和类型，以及内部的各个方格。

这三个数据可以用字典存起来，这里我们规定格式如下

运行代码就发现界面中的俄罗斯方块动起来了，动画如下

三、生成、移动、固定、消除

1、随机生成俄罗斯方块

这里需要导入python自带的随机库random

使用其中的choice方法，从俄罗斯方块形状列表中随机选出一个。

并在game_loop方法下面设置初始的俄罗斯方块为空（None）

此时每次运行代码都会发现生成了随机的俄罗斯方块

当然，此时还有问题没有解决，就是俄罗斯方块生成后，会一直往下移动，就算出了可视范围还是会往下移动（只是这时再也看不到了）。

所以接下来我们要实现的是：当俄罗斯方块落地的时候，将它固定住，然后再去生成新的。

2、固定失效俄罗斯方块

判断俄罗斯方块落地的原则是，该方块是否可以继续向下移动

这里我们首先需要的是一个方法check_move需要判断俄罗斯方块是否可以向指定位置移动

该generate_new_block方法的下面，添加check_move方法代码如下

def check_move(block, direction=[0, 0]):
    
        判断俄罗斯方块是否可以朝制定方向移动
        :param block: 俄罗斯方块对象
        :param direction: 俄罗斯方块移动方向
        :return: boolean 是否可以朝制定方向移动
        
    cc, cr = block['cr']
    cell_list = block['cell_list']

    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc + direction[0]
        r = cell_r + cr + direction[1]
        # 判断该位置是否超出左右边界，以及下边界
        # 一般不判断上边界，因为俄罗斯方块生成的时候，可能有一部分在上边界之上还没有出来
        if c < 0 or c >= C or r >= R:
            return False

    return True

再将游戏运行方法game_loop修改成如下，便可以每次俄罗斯方块落地后都会生成新的

def game_loop():
    win.update()
    global current_block

    if current_block is None:
        new_block = generate_new_block()
        # 新生成的俄罗斯方块需要先在生成位置绘制出来
        draw_block_move(canvas, new_block)
        current_block = new_block
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            current_block = None

    win.after(FPS, game_loop)

此时运行效果如下图

此时仍然有个问题就是老的俄罗斯方块会被新的落地的俄罗斯方块，这个需要处理

当俄罗斯方块发现下面有已固定的俄罗斯方块时，也不能移动

首先，我们需要添加一个变量block_list来记录已固定的俄罗斯方块

在原代码draw_blank_board(canvas)的位置的下面，应该是80行上下的地方，添加如下代码

block_list = []
for i in range(R):
    i_row = ['' for j in range(C)]
    block_list.append(i_row)

然后再在固定俄罗斯方块的时候记录进去，所以

• 一要添加一个save_block_to_list方法，将无法移动的俄罗斯方块记录进去

• 二要修改game_loop

具体如下

def save_block_to_list(block):
    shape_type = block['kind']
    cc, cr = block['cr']
    cell_list = block['cell_list']

    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc
        r = cell_r + cr
        # block_list 在对应位置记下其类型
        block_list[r][c] = shape_type

def game_loop():
    win.update()
    global current_block
    if current_block is None:
        new_block = generate_new_block()
        # 新生成的俄罗斯方块需要先在生成位置绘制出来
        draw_block_move(canvas, new_block)
        current_block = new_block
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            # 无法移动，记入 block_list 中
            save_block_to_list(current_block)
            current_block = None

    win.after(FPS, game_loop)

然后还要再修改原来的check_move方法，就是发现下面有已固定的俄罗斯方块时，也不能移动，具体如下

def check_move(block, direction=[0, 0]):
    
        判断俄罗斯方块是否可以朝制定方向移动
        :param block: 俄罗斯方块对象
        :param direction: 俄罗斯方块移动方向
        :return: boolean 是否可以朝制定方向移动
        
    cc, cr = block['cr']
    cell_list = block['cell_list']

    for cell in cell_list:
        cell_c, cell_r = cell
        c = cell_c + cc + direction[0]
        r = cell_r + cr + direction[1]
        # 判断该位置是否超出左右边界，以及下边界
        # 一般不判断上边界，因为俄罗斯方块生成的时候，可能有一部分在上边界之上还没有出来
        if c < 0 or c >= C or r >= R:
            return False

        # 必须要判断r不小于0才行，具体原因你可以不加这个判断，试试会出现什么效果
        if r >= 0 and block_list[r][c]:
            return False

    return True

3、左右移动俄罗斯方块

首先，我们需要新建一个左右移动俄罗斯方块的方法horizontal_move_block，其中的参数event对应键鼠事件

在save_block_to_list方法下面添加horizontal_move_block方法的代码如下，

def horizontal_move_block(event):
    
    左右水平移动俄罗斯方块
    
    direction = [0, 0]
    if event.keysym == 'Left':
        direction = [-1, 0]
    elif event.keysym == 'Right':
        direction = [1, 0]
    else:
        return

    global current_block
    if current_block is not None and check_move(current_block, direction):
        draw_block_move(canvas, current_block, direction)

然后把键盘上的左右键绑定（bind）这个方法，代码如下

# 在game_loop方法（之外）下面添加
canvas.focus_set() # 聚焦到canvas画板对象上
canvas.bind(<KeyPress-Left>, horizontal_move_block)
canvas.bind(<KeyPress-Right>, horizontal_move_block)

此时运行，就可以按左右方向键来移动俄罗斯方块了

4、变换俄罗斯方块

左右键是移动俄罗斯方块，

上下键我们则实现变换俄罗斯方块

按上键俄罗斯方块会进行顺时针九十度旋转

按下键俄罗斯方块会进行顺时针九十度旋转

这里我们需要添加

旋转俄罗斯方块的方法rotate_block

以及让俄罗斯方块着陆的方法land

在horizontal_move_block方法下面添加rotate_block方法的代码如下，

def rotate_block(event):
    global current_block
    if current_block is None:
        return

    cell_list = current_block['cell_list']
    rotate_list = []
    for cell in cell_list:
        cell_c, cell_r = cell
        rotate_cell = [cell_r, -cell_c]
        rotate_list.append(rotate_cell)

    block_after_rotate = {
        'kind': current_block['kind'],  # 对应俄罗斯方块的类型
        'cell_list': rotate_list,
        'cr': current_block['cr']
    }

    if check_move(block_after_rotate):
        cc, cr= current_block['cr']
        draw_cells(canvas, cc, cr, current_block['cell_list'])
        draw_cells(canvas, cc, cr, rotate_list,SHAPESCOLOR[current_block['kind']])
        current_block = block_after_rotate

def land(event):
    global current_block
    if current_block is None:
        return

    cell_list = current_block['cell_list']
    cc, cr = current_block['cr']
    min_height = R
    for cell in cell_list:
        cell_c, cell_r = cell
        c, r = cell_c + cc, cell_r + cr
        if block_list[r][c]:
            return
        h = 0
        for ri in range(r+1, R):
            if block_list[ri][c]:
                break
            else:
                h += 1
        if h < min_height:
            min_height = h

    down = [0, min_height]
    if check_move(current_block, down):
        draw_block_move(canvas, current_block, down)

然后再在上一步绑定左右方向键的地方添加下面这行代码，让上键绑定（bind）这个方法

canvas.bind(<KeyPress-Up>, rotate_block)
canvas.bind(<KeyPress-Down>, land)

运行结果：

四、消除与得分

1、消除与得分

最后，要实现俄罗斯方块的消除，就是当一行满了的时候，需要消除这行，同时在通过窗口标题展示得分情况

这里需要添加check_row_completed方法判断指定行是否可以消除

同时添加check_and_clear方法检查所有行并消除

而消除之后，我们需要在画板上重新绘制一遍消除后剩余的俄罗斯方块

这里最好将之前的draw_blank_board方法修改为，可以绘制面板上残留的俄罗斯方块的方法，方法名改为draw_board

修改代码如下

# 绘制面板，将draw_blank_board方法修改成如下方法
def draw_board(canvas, block_list):
    for ri in range(R):
        for ci in range(C):
            cell_type = block_list[ri][ci]
            if cell_type:
                draw_cell_by_cr(canvas, ci, ri, SHAPESCOLOR[cell_type])
            else:
                draw_cell_by_cr(canvas, ci, ri)

# 在原有的rotate_block方法（外）下面添加
def check_row_complete(row):
    for cell in row:
        if cell=='':
            return False

    return True

score = 0
win.title(SCORES: %s % score) # 标题中展示分数

def check_and_clear():
    has_complete_row =False
    for ri in range(len(block_list)):
        if check_row_complete(block_list[ri]):
            has_complete_row = True
            # 当前行可消除
            if ri > 0:
                for cur_ri in range(ri, 0, -1):
                    block_list[cur_ri] = block_list[cur_ri-1][:]
        block_list[0] = ['' for j in range(C)]
            else:
                block_list[ri] = ['' for j in range(C)]
            global score
            score += 10

    if has_complete_row:
        draw_board(canvas, block_list)

        win.title(SCORES: %s % score)

同时将原有的这两行代码

draw_blank_board(canvas)

block_list = []
for i in range(R):
    i_row = ['' for j in range(C)]
    block_list.append(i_row)

修改成

block_list = []
for i in range(R):
    i_row = ['' for j in range(C)]
    block_list.append(i_row)

draw_board(canvas, block_list)

再在game_loop方法内部的win.after(FPS, game_loop)语句之前添加下面语句

 `check_and_clear()`

一般来说，当新的俄罗斯方块无法移动时，游戏就算game over了

这里的判断机制是，新生成的俄罗斯方块已经无法在出生点放置了，也就是出生点都已经被之前的固定的方块占用了，就算游戏结束。

在代码文件开头添加

from tkinter import messagebox   

再修改game_loop方法如下就好

def game_loop():
    win.update()
    global current_block
    if current_block is None:
        new_block = generate_new_block()
        # 新生成的俄罗斯方块需要先在生成位置绘制出来
        draw_block_move(canvas, new_block)
        current_block = new_block
        if not check_move(current_block, [0, 0]):
            messagebox.showinfo(Game Over!, Your Score is %s % score)
            win.destroy()
            return
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            # 无法移动，记入 block_list 中
            save_block_to_list(current_block)
            current_block = None
    check_and_clear()

    win.after(FPS, game_loop)

到这里，俄罗斯方块基础版就算完成了

戳这里：拿完整码