本文将用Python写一个终端版俄罗斯方块，用游戏的方式学习编程。

这个小游戏分享给学习Python的朋友，感受一下Python的魅力，锻炼编程思维。

更多小游戏请看 这里。

演示效果图见下文。

代码如下：

# encoding:utf-8
# file: tetris.py
# author: Jason


# ##########################
# 终端俄罗斯方块Tetris
# ##########################


import time
import random
import sys
import select
import copy
import termios


# #################
# 全局变量定义
# #################


# 地图相关变量

# 下面的方块指7种基本方块 小方块指构成基本方块的最小单位
# 终端使用等宽字体时 小方块正好是个小正方形 1个小方块由2个英文字符组成
# 游戏区域即游戏地图的长与高
GAME_AREA_L, GAME_AREA_H = 16, 26
# 游戏区域内左上角坐标为坐标原点 X为横坐标 Y为纵坐标
GAME_AREA_X, GAME_AREA_Y = 2, 2
# 游戏边框图形 基本方块的小方块渲染图形
GAME_EDGE, GAME_SQUARE = '##', '  '
# 游戏区域背景色
GAME_BKGCOLOR = '\033[40;30m'
# 游戏区域位图 即游戏地图
GAME_BITMAP = [[[0, GAME_BKGCOLOR] for y in range(GAME_AREA_L)] for x in range(GAME_AREA_H)]

# 方块相关变量

# 7方块初始状态位图 2,2位置为方块实际长与高 3,3位置为此方块颜色
BLOCK_DICT = {
    # 天蓝色
    'I': [[1, 1, 1, 1],
          [0, 0, 0, 0],
          [0, 0, [4, 1], 0],
          [0, 0, 0, '\033[46;36m']],
    # 蓝色
    'J': [[1, 0, 0, 0],
          [1, 1, 1, 0],
          # [3,2]表示此方块长3高2 索引正好相反 x=2为两行y=3为三列
          # 3,2为游戏区域的坐标表示法的长与度 2,3为对应的二维列表索引表示法
          [0, 0, [3, 2], 0],
          [0, 0, 0, '\033[44;34m']],
    # 白色
    'L': [[0, 0, 1, 0],
          [1, 1, 1, 0],
          [0, 0, [3, 2], 0],
          [0, 0, 0, '\033[47;37m']],
    # 黄色
    'O': [[1, 1, 0, 0],
          [1, 1, 0, 0],
          [0, 0, [2, 2], 0],
          [0, 0, 0, '\033[43;33m']],
    # 绿色
    'S': [[0, 1, 1, 0],
          [1, 1, 0, 0],
          [0, 0, [3, 2], 0],
          [0, 0, 0, '\033[42;32m']],
    # 紫色
    'T': [[0, 1, 0, 0],
          [1, 1, 1, 0],
          [0, 0, [3, 2], 0],
          [0, 0, 0, '\033[45;35m']],
    # 红色
    'Z': [[1, 1, 0, 0],
          [0, 1, 1, 0],
          [0, 0, [3, 2], 0],
          [0, 0, 0, '\033[41;31m']]
}
# 方块存储位图
BLOCK_BITMAP = [[0, 0, [0, 0], 0] if i == 2 else [0, 0, 0, 0] for i in range(4)]
# 定义方块出生点的方块左上角的地图坐标
BLOCK_SX, BLOCK_SY = GAME_AREA_X + GAME_AREA_L // 2 - 2, GAME_AREA_Y
# 方块左上角地图坐标
BLOCK_COORD = {'x': BLOCK_SX, 'y': BLOCK_SY}
# 生成方块计数 得分 方块类型
BLOCK_COUNT, GAME_SCORE, BLOCK_TYPE = 0, 0, '_'

# 按键和信息相关变量

# 按键变量 按键检测间隔 方块打印间隔
KEY_DEFAULT, KEY_PAUSE = '_', ' '
KEY, KEY_INTERVAL, PNT_INTERVAL = KEY_DEFAULT, 0.01, 0.2
# 计分板左上角坐标
INFO_AREA_X, INFO_AREA_Y = GAME_AREA_X + GAME_AREA_L + 2, GAME_AREA_Y + 1
# 计分板区域长与高
INFO_AREA_L, INFO_AREA_H = 8, GAME_AREA_H


# #################
# 函数定义
# #################


# 初始化与通用函数
# 包括坐标定位 绘制地图边框 填充地图背景色等函数


def exit_clear(txt, e_code=0):
    """
    退出时做一些清理工作
    :param txt: 文本
    :param e_code: 退出码
    :return:
    """
    print(txt)
    exit(e_code)


def goto_blockxy(x=1, y=1):
    """
    将终端光标移动到方块的左上角位置 即坐标定位函数
    :param x: 方块的坐标x
    :param y: 方块的坐标y
    :return: None
    """
    if x < 1 or y < 1:
        x, y = 1, 1
    # 1个小方块占2个英文字符宽度
    # 实际坐标_x与方块坐标x的转换
    _x = (x - 1) * 2 + 1
    print('\033[{};{}H'.format(y, _x), end='', sep='')


def _gotoxy_print(x=1, y=1, *args, **kwargs):
    """打印调试信息"""
    goto_blockxy(x, y)
    print(*args, **kwargs)


def _edge_block(x=1, y=1, ln=1, h=1, b=GAME_EDGE):
    """
    绘制边框小方块
    :param x: 起点x
    :param y: 起点y
    :param ln: 边框小方块长
    :param h: 边框小方块高
    :param b: 边框小方块字符
    :return: None
    """
    for _y in range(y, y + h):
        goto_blockxy(x, _y)
        print('{}'.format(b * ln))


def draw_edge(x=1, y=1):
    """
    绘制游戏边框
    """
    ln1 = GAME_AREA_L + INFO_AREA_L + 3
    ln2 = GAME_AREA_L + 1
    ln3 = GAME_AREA_L + INFO_AREA_L + 2
    h = GAME_AREA_H
    _edge_block(x, y, ln1, 1)
    _edge_block(x, y + 1, 1, h)
    _edge_block(x + ln2, y + 1, 1, h)
    _edge_block(x + ln3, y + 1, 1, h)
    _edge_block(x, y + h + 1, ln1, 1)


# 地图处理函数
# 包括地图中方块清除 地图中方块显示等


def _clear_map_area(x, y, ln, h):
    """
    清除地图位图
    :param x: 坐标表示法的x
    :param y: 坐标表示法的y
    :param ln: 清除区域长度
    :param h: 清除区域高度
    :return: None
    """
    map_x, map_y = x - GAME_AREA_X, y - GAME_AREA_Y
    for _x in range(map_x, map_x + ln):
        for _y in range(map_y, map_y + h):
            # 坐标表示法与索引表示法互换
            GAME_BITMAP[_y][_x] = [0, GAME_BKGCOLOR]


def _fill_map_point(x, y, color):
    """
    填充地图位图点
    :param x: 坐标x
    :param y: 坐标y
    :param color: 颜色字符串转义序列
    """
    map_x, map_y = x - GAME_AREA_X, y - GAME_AREA_Y
    GAME_BITMAP[map_y][map_x] = [1, color]


def _clear_blockline(lenght=1, block=GAME_SQUARE, bkg=GAME_BKGCOLOR):
    """
    填充指定长度方块为背景色 即清除方块
    :param lenght: 方块长度 每个小方块占2英文字符宽度
    :param block: 填充的小方块
    :param bkg: 填充的背景色
    :return: None
    """
    # 因为标准输出缓冲区的原因 不要传参end='' 否则打印内容可能不会立刻显示
    print('{}{}\033[0m'.format(bkg, block * lenght))


def clear_area(x=GAME_AREA_X, y=GAME_AREA_Y, ln=GAME_AREA_L, h=GAME_AREA_H):
    """
    清除指定矩形区域 清除的最小单位是小方块 即2个英文字符 游戏区域为黑色背景
    :param x: 起始x坐标
    :param y: 起始y坐标
    :param ln: 区域长度
    :param h: 区域高度
    :return: None
    """
    for _y in range(y, y + h):
        goto_blockxy(x, _y)
        _clear_blockline(ln)
    _clear_map_area(x, y, ln, h)


def print_map_area(x, y, ln=GAME_AREA_L, h=GAME_AREA_H):
    """
    根据地图位图刷新游戏区域
    :param x: 地图起点坐标x
    :param y: 地图起点坐标y
    :param ln: 区域长
    :param h: 区域高
    :return: None
    """
    map_x, map_y = x - GAME_AREA_X, y - GAME_AREA_Y
    for _x in range(map_y, map_y + h):
        for _y in range(map_x, map_x + ln):
            goto_blockxy(_y + GAME_AREA_Y, _x + GAME_AREA_X)
            print('{}{}\033[0m'.format(GAME_BITMAP[_x][_y][1], GAME_SQUARE))


def _print_map_bits():
    """
    打印地图点 用于调试
    :return: None
    """
    a, b = GAME_AREA_X + GAME_AREA_L + INFO_AREA_L + 3, GAME_AREA_Y
    for x in range(len(GAME_BITMAP)):
        goto_blockxy(a, b)
        for y in range(len(GAME_BITMAP[0])):
            if GAME_BITMAP[x][y][0] == 1:
                print('\033[31m{}\033[0m,'.format(GAME_BITMAP[x][y][0]), end='')
            else:
                print('{},'.format(GAME_BITMAP[x][y][0]), end='')
        b += 1


def draw_background():
    """游戏区域背景色填充
    """
    clear_area()


def restore_cursor():
    """恢复隐藏的光标
    """
    print('\033[?25h')


def tetris_init():
    """初始化工作
    """
    # 清屏与隐藏光标
    print('\033[2J\033[?25l')
    # 绘制游戏区域边框
    draw_edge()
    # 地图填充背景色
    draw_background()


# 方块处理函数
# 包括选取方块 打印方块 方块旋转 方块平移等函数


def _pick_block(b_bitmap, b_type):
    """
    选取特定类型的方块
    :param b_bitmap: 方块位图
    :param b_type: 方块类型
    :return: None
    """
    for x in range(4):
        for y in range(4):
            b_bitmap[x][y] = BLOCK_DICT[b_type][x][y]


def print_block(x, y, b_bitmap, fill_flag=True):
    """
    打印一种方块
    :param x: 起始点x
    :param y: 起始点y
    :param b_bitmap: 方块位图
    :param fill_flag: 填充地图位图标记 False为单纯打印方块不填充
    :return: None
    """
    if not fill_flag:
        # 清除上个方块
        for _x in range(len(b_bitmap)):
            for _y in range(len(b_bitmap[0])):
                goto_blockxy(_y + x, _x + y)
                print('{}'.format(GAME_SQUARE))
    b_l, b_h = b_bitmap[-2][-2][0], b_bitmap[-2][-2][1]
    b_color = b_bitmap[-1][-1]
    # 这里的_x,_y为索引表示法 参数x,y为坐标表示法
    for _y in range(b_l):
        for _x in range(b_h):
            # 必须判断是否等于1 不要用True/False判断
            # b_bitmap坐标互换 让位图中所有1呈现的图像与实际打印的图像一致
            # 即b_bitmap中纵向扫描 print也纵向打印
            if b_bitmap[_x][_y] == 1:
                # 方块位图坐标转换游戏区域坐标 索引到坐标表示法需互换坐标
                goto_blockxy(_y + x, _x + y)
                if fill_flag:
                    _fill_map_point(_y + x, _x + y, b_color)
                # 打印行数超过终端窗口高度 可能会提前折行导致方块错乱
                print('{}{}\033[0m'.format(b_color, GAME_SQUARE))


def _copy_rotatedblock(rotated_block, origin_block):
    """
    方块拷贝函数
    :param rotated_block: 旋转后的方块位图
    :param origin_block: 原始方块位图 必须是4x4方块
    :return: None
    """
    b_length, b_height = origin_block[-2][-2][0], origin_block[-2][-2][1]
    for _x in range(4):
        for _y in range(4):
            if _x < b_length and _y < b_height:
                # 原始方块长x高 => 位图[高][长] => 旋转后方块的 位图[长][高]
                # 所以这里_x是b_length _y是b_height
                origin_block[_x][_y] = rotated_block[_x][_y]
            elif _x == _y and _x == 2:
                # 长x高变换
                origin_block[_x][_y] = origin_block[_x][_y][::-1]
            elif _x == _y and _x == 3:
                # 颜色值不改变
                continue
            else:
                origin_block[_x][_y] = 0


def copy_block(fr_bitmap: list, to_bitmap: list):
    """
    拷贝方块存储位图
    :param fr_bitmap: 原始方块
    :param to_bitmap: 目的方块
    :return:
    """
    for i in range(4):
        for j in range(4):
            to_bitmap[i][j] = fr_bitmap[i][j]


def _rotate_block(flag=True):
    """
    逆时针旋转方块 即求NxM到MxN的转置矩阵
    :param flag: True生成旋转后的方块 False只旋转不生成旋转后方块
    :return: None
    """
    b_length, b_height = BLOCK_BITMAP[-2][-2][0], BLOCK_BITMAP[-2][-2][1]
    # b_lengthXb_height 方块索引表示法即 b_heightXb_length
    b_target = [[0 for _y in range(b_height)] for _x in range(b_length)]
    for _y in range(b_length):
        for _x in range(b_height):
            # 逆时针旋转90度
            offset = len(BLOCK_BITMAP[_x]) - b_length
            b_target[_y][_x] = BLOCK_BITMAP[_x][-_y - 1 - offset]
    # flag为真 生成旋转后方块
    if flag:
        _copy_rotatedblock(b_target, BLOCK_BITMAP)
    # 生成临时旋转后方块用于检测
    else:
        # 拷贝未旋转的方块为模板
        tmp_bitmap = copy.deepcopy(BLOCK_BITMAP)
        # 生成为临时方块
        _copy_rotatedblock(b_target, tmp_bitmap)
        return tmp_bitmap


def _edge_detect(x, y, b_bitmap):
    """
    方块是否超出游戏地图检测
    :param x: 方块左上角坐标x
    :param y: 方块左上角坐标y
    :param b_bitmap: 方块位图
    :return: 布尔型
    """
    b_l, b_h = b_bitmap[-2][-2][0], b_bitmap[-2][-2][1]
    if x < GAME_AREA_X or y < GAME_AREA_Y or \
            x + b_l - 1 >= GAME_AREA_X + GAME_AREA_L or \
            y + b_h - 1 >= GAME_AREA_Y + GAME_AREA_H:
        return False
    else:
        return True


def _clear_block(x, y, ln, h):
    """
    清除指定方块
    :param x: 起始x坐标
    :param y: 起始y坐标
    :param ln: 区域长度
    :param h: 区域高度
    :return: None
    """
    for _x in range(x, x + ln):
        for _y in range(y, y + h):
            if BLOCK_BITMAP[_y - y][_x - x] == 1:
                goto_blockxy(_x, _y)
                # 因为标准输出缓冲区的原因 不要传参end='' 否则打印内容可能不会立刻显示
                print('{}{}\033[0m'.format(GAME_BKGCOLOR, GAME_SQUARE))
                # 清除地图点
                _clear_map_area(_x, _y, 1, 1)


def move_block(x, y, direction, distance=1):
    """
    移动方块或旋转方块
    :param x: 当前位置x
    :param y: 当前位置y
    :param direction: 移动方向 'to_l'向左 'to_r'向右 'to_d'向下 'to_u'原地旋转
    :param distance: 移动距离
    :return: 布尔型
    """
    global KEY
    respawn_flag = False
    b_l, b_h = BLOCK_BITMAP[-2][-2][0], BLOCK_BITMAP[-2][-2][1]
    if direction == 'to_l' and _edge_detect(x - distance, y, BLOCK_BITMAP) and \
            _collision_detect(x - distance, y, 'to_l'):
        _clear_block(x, y, b_l, b_h)
        print_block(x - distance, y, BLOCK_BITMAP)
        BLOCK_COORD['x'], BLOCK_COORD['y'] = x - distance, y
    elif direction == 'to_r' and _edge_detect(x + distance, y, BLOCK_BITMAP) and \
            _collision_detect(x + distance, y, 'to_r'):
        _clear_block(x, y, b_l, b_h)
        print_block(x + distance, y, BLOCK_BITMAP)
        BLOCK_COORD['x'], BLOCK_COORD['y'] = x + distance, y
    elif direction == 'to_d' and _edge_detect(x, y + distance, BLOCK_BITMAP) and \
            _collision_detect(x, y + distance, 'to_d'):
        _clear_block(x, y, b_l, b_h)
        print_block(x, y + distance, BLOCK_BITMAP)
        BLOCK_COORD['x'], BLOCK_COORD['y'] = x, y + distance
    elif direction == 'to_d' and (not _edge_detect(x, y + distance, BLOCK_BITMAP)
                                  or not _collision_detect(x, y + distance, 'to_d')):
        respawn_flag = True
    elif direction == 'to_u' and _edge_detect(x, y, _rotate_block(False)) and \
            _collision_detect_r(x, y, _rotate_block(False)):
        _clear_block(x, y, b_l, b_h)
        _rotate_block()
        print_block(x, y, BLOCK_BITMAP)
    # 恢复向下移动 区别于get_keys获取的's'
    KEY = KEY_DEFAULT
    return respawn_flag


def spawn_newblock(b_bitmap, t=None):
    """新方块生成
    """
    global BLOCK_COUNT, BLOCK_TYPE
    # 方块挑选
    b_type = 'IJLOSTZ'
    if t is None:
        BLOCK_TYPE = random.choice(b_type)
    else:
        BLOCK_TYPE = t
    _pick_block(b_bitmap, BLOCK_TYPE)
    # 新方块出生点初始化
    BLOCK_COORD['x'], BLOCK_COORD['y'] = BLOCK_SX, BLOCK_SY
    BLOCK_COUNT += 1


# 按键处理函数
# 包括获取按键 按键转换方向等


def get_keys(delay=None):
    """
    按键获取函数 p键退出 不支持方向键
    :param delay: 传递额外延迟
    :return: None
    """
    global KEY
    fd = sys.stdin.fileno()
    old = termios.tcgetattr(fd)
    new = termios.tcgetattr(fd)
    # 关闭回显和回车
    new[3] = new[3] & ~termios.ECHO & ~termios.ICANON
    # 在一个方块打印间隔时间内检测times次按键输入
    # get_keys函数充当sleep函数等待PNT_INTERVAL秒的过程中获取按键
    count, times = 0, PNT_INTERVAL // KEY_INTERVAL
    try:
        termios.tcsetattr(fd, termios.TCSADRAIN, new)
        while count < times:
            if delay is not None:
                time.sleep(delay)
            time.sleep(KEY_INTERVAL)
            # support non-blocking input
            if select.select([sys.stdin], [], [], 0) == ([sys.stdin], [], []):
                KEY = sys.stdin.read(1)
                if KEY in 'wad':  # 2倍加速移动或旋转
                    times //= 2
                if KEY == 's':  # 4倍加速下降
                    times //= 4
                # 暂停
                if KEY == KEY_PAUSE:
                    break
            count += 1
    except KeyboardInterrupt:
        exit_clear('Get: Ctrl-C to EXIT', 1)
    finally:
        termios.tcsetattr(fd, termios.TCSADRAIN, old)


def get_direction():
    """
    按键转换为方向 'to_l'向左 'to_r'向右 'to_d'向下 'to_u'原地旋转
    :return: 方向
    """
    if KEY == 'a':
        return 'to_l'
    elif KEY == 'd':
        return 'to_r'
    elif KEY == 's':
        return 'to_d'
    elif KEY == 'w':
        return 'to_u'
    elif KEY == KEY_DEFAULT:
        return 'to_d'


# 碰撞检测与计分函数
# 包括方块向下运动碰撞检测 地图中方块的消除 消除后计分等


def _collision_detect(x, y, direction):
    """
    方块与方块之间碰撞检测
    :param x: 方块左上角坐标x
    :param y: 方块左上角坐标y
    :param direction: 移动方向 'to_l'向左 'to_r'向右 'to_d'向下
    :return: 布尔型
    """
    b_l, b_h = BLOCK_BITMAP[-2][-2][0], BLOCK_BITMAP[-2][-2][1]
    distance = 1000000
    if direction == 'to_l':
        for _y in range(y, y + b_h):
            block_y = _y - y
            map_y = _y - GAME_AREA_Y
            for block_x in range(b_l):  # 0->b_l-1
                if BLOCK_BITMAP[block_y][block_x] == 1:
                    sx = x - GAME_AREA_X + block_x
                    for map_x in range(sx, -1, -1):
                        if GAME_BITMAP[map_y][map_x][0] == 1:
                            if abs(sx - map_x) < distance:
                                distance = abs(sx - map_x)
                                break
                    break
    elif direction == 'to_r':
        for _y in range(y, y + b_h):
            block_y = _y - y
            map_y = _y - GAME_AREA_Y
            for block_x in range(b_l - 1, -1, -1):
                if BLOCK_BITMAP[block_y][block_x] == 1:
                    sx = x - GAME_AREA_X + block_x
                    for map_x in range(sx, len(GAME_BITMAP[0])):
                        if GAME_BITMAP[map_y][map_x][0] == 1:
                            if abs(map_x - sx) < distance:
                                distance = abs(map_x - sx)
                                break
                    break
    elif direction == 'to_d':
        for _x in range(x, x + b_l):
            block_x = _x - x
            map_x = _x - GAME_AREA_X
            for block_y in range(b_h - 1, -1, -1):
                # 从左往右从下往上 寻找方块上第一个值为1的点 纵坐标为block_y
                if BLOCK_BITMAP[block_y][block_x] == 1:
                    # 从block_y映射到地图对应的点的下一个点 此点为方块下次将到达的点 纵坐标起点为sy
                    # 传递y的实参为y + distance 已包含移动方向distance
                    sy = y - GAME_AREA_Y + block_y
                    # 从sy开始竖直向下到地图纵坐标最大值len(GAME_BITMAP) 查找值为1的地图点
                    for map_y in range(sy, len(GAME_BITMAP)):
                        if GAME_BITMAP[map_y][map_x][0] == 1:
                            # 计算地图点map_y到方块下次将到达的点sy之间距离
                            if abs(map_y - sy) < distance:
                                distance = abs(map_y - sy)
                                break
                    # 只需要查找一次地图上的点
                    break
    # 距离为0 则为假 表示点有重叠 不能移动
    return distance


def _collision_detect_r(x, y, b_bitmap):
    """
    旋转后碰撞检测
    :param x: 方块左上角坐标x
    :param y: 方块左上角坐标y
    :param b_bitmap: 临时方块位图
    :return: 布尔型
    """
    # 迭代临时方块与对应地图上的点
    for _x in range(4):
        for _y in range(4):
            # 原始方块和旋转后方块有重叠
            if b_bitmap[_x][_y] == 1 and BLOCK_BITMAP[_x][_y] == 1:
                # 排除重叠的点
                b_bitmap[_x][_y] = 0
            # 旋转后方块与地图是否有重叠点
            map_x, map_y = y - GAME_AREA_Y + _x, x - GAME_AREA_X + _y
            if b_bitmap[_x][_y] == 1 and GAME_BITMAP[map_x][map_y][0] == 1:
                return False
    return True


def print_info():
    x, y = INFO_AREA_X, INFO_AREA_Y
    str_len = INFO_AREA_L - GAME_AREA_X + 1
    goto_blockxy(x, y)
    # '按键：'占3个小方块宽度 2个英文字符占一个小方块宽度
    print('按键：{:<{}}'.format(str(KEY), (str_len - 3) * 2))
    goto_blockxy(x, y + 2)
    print('方块数：{:<{}}'.format(str(BLOCK_COUNT), (str_len - 4) * 2))
    goto_blockxy(x, y + 4)
    print('方块：{:<{}}'.format(str(BLOCK_TYPE), (str_len - 3) * 2))
    goto_blockxy(x, y + 6)
    print('得分：{:<{}}'.format(str(GAME_SCORE), (str_len - 3) * 2))
    goto_blockxy(x, y + 9)
    print('按 {}'.format('空格' if KEY_PAUSE == ' ' else KEY_PAUSE))
    goto_blockxy(x, y + 10)
    print('暂停/开始')
    goto_blockxy(x, y + 12)
    print('下个方块：')


def _is_eliminable(x):
    """
    判断地图位图的某行能否消除
    :param x: 地图位图索引x
    :return: 布尔型
    """
    v_count = 0
    for v in GAME_BITMAP[x]:
        if v[0] == 1:
            v_count += 1
    return v_count == len(GAME_BITMAP[x])


def _is_emptyline(x):
    """
    判断地图中某行是不是空行
    :param x: 地图位图索引x
    :return: 布尔型
    """
    v_count = 0
    for v in GAME_BITMAP[x]:
        if v[0] == 0:
            v_count += 1
    return v_count == len(GAME_BITMAP[x])


def _do_eliminate(x):
    """
    消除地图中的某行
    :param x: 能消除行的索引x
    :return: None
    """
    global GAME_SCORE
    GAME_SCORE += 1
    # 向下逐行覆盖消除的行
    for _x in range(x - 1, -1, -1):
        GAME_BITMAP[_x + 1] = copy.deepcopy(GAME_BITMAP[_x])
        if _is_emptyline(_x):
            break


def eliminate_blocks(x=len(GAME_BITMAP) - 1):
    """
    消除方块函数
    :param x: 地图位图的某一行 即索引x
    :return: None
    """
    # 从下到上扫描能消除的行 逐行消除 使用递归
    if x < 0 or _is_emptyline(x):
        return
    if _is_eliminable(x):
        _do_eliminate(x)
        eliminate_blocks(x)
    else:
        eliminate_blocks(x - 1)


# 网络对战功能
# 包括网络数据传输 输赢判断等


def data_transmit():
    pass


def winner_judge():
    pass


def player2_print_block():
    pass


def player2_print_info():
    pass


if __name__ == '__main__':
    tetris_init()
    tmp_score = GAME_SCORE
    block_nextbm = copy.deepcopy(BLOCK_BITMAP)
    spawn_newblock(block_nextbm)
    while True:
        # 生成新方块
        copy_block(block_nextbm, BLOCK_BITMAP)
        spawn_newblock(block_nextbm)
        print_block(INFO_AREA_X, INFO_AREA_Y + 14, block_nextbm, fill_flag=False)
        print_block(BLOCK_COORD['x'], BLOCK_COORD['y'], BLOCK_BITMAP)
        down_move_count = 0
        while True:
            get_keys()
            # 暂停
            if KEY == KEY_PAUSE:
                KEY = KEY_DEFAULT
                while KEY != ' ':
                    try:
                        get_keys(0.2)
                    except KeyboardInterrupt:
                        exit_clear('Get: Ctrl-C to EXIT', 1)
            # 打印信息
            print_info()
            reborn_flag = move_block(BLOCK_COORD['x'], BLOCK_COORD['y'], get_direction())
            if down_move_count == 0 and reborn_flag:
                restore_cursor()
                exit_clear('Gam Over!!!', 0)
            # 退出循环 生成新方块
            if reborn_flag:
                # 消除
                eliminate_blocks()
                # 有方块消除时 才全地图刷新
                if GAME_SCORE > tmp_score:
                    # _gotoxy_print(28,29, 'in printmaparea')
                    print_map_area(GAME_AREA_X, GAME_AREA_Y)
                    tmp_score = GAME_SCORE
                break
            # _print_map_bits()
            down_move_count += 1

在终端中运行命令（使用python3执行）：

python tetris.py （如果出现显示不全，把终端窗口最大化即可）

操作：

a s w d 为方向键，空格 暂停/开始，ctrl+c 退出程序

执行效果：