python tkinter实现俄罗斯方块基础版——三、生成、移动、固定、消除_canvas.bind("",land)

总目录

一、基础界面

二、界面动起来

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

四、消除与得分

======================= 大爽歌作，made by big shuang =======================

1、随机生成俄罗斯方块

这里需要导入python自带的随机库random
使用其中的choice方法，从俄罗斯方块形状列表中随机选出一个。
该方法源码说明如图

首先我们需要删除原来的位于game_loop方法上面的a_block = ... 和draw_block_move(canvas, a_block)这2行代码（这两行代码俄罗斯方块是在固定位置，按照指定形状生成的，需要删掉这部分代码），
然后再在原来的这2行代码所在位置，添加一个随机生成俄罗斯方块的方法generate_new_block

def generate_new_block():
    # 随机生成新的俄罗斯方块
 
    kind = random.choice(list(SHAPES.keys()))
    # 对应横纵坐标，以左上角为原点，水平向右为x轴正方向，
    # 竖直向下为y轴正方向，x对应横坐标，y对应纵坐标
    cr = [C // 2, 0]
    new_block = {
        'kind': kind,  # 对应俄罗斯方块的类型
        'cell_list': SHAPES[kind],
        'cr': cr
    }
 
    return new_block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

再将游戏运行方法game_loop修改成如下，其中，将当前的俄罗斯方块对象通过全局变量来存储，
并在game_loop方法下面设置初始的俄罗斯方块为空（None）
此时每次运行代码都会发现生成了随机的俄罗斯方块

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:
        draw_block_move(canvas, current_block, [0, 1])
 
    win.after(FPS, game_loop)
 
current_block = None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

当然，此时还有问题没有解决，就是俄罗斯方块生成后，会一直往下移动，就算出了可视范围还是会往下移动（只是这时再也看不到了）。
所以接下来我们要实现的是：当俄罗斯方块落地的时候，将它固定住，然后再去生成新的。

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'
运行
运行

再将游戏运行方法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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

此时运行效果如下图

此时仍然有个问题就是老的俄罗斯方块会被新的落地的俄罗斯方块，这个需要处理
当俄罗斯方块发现下面有已固定的俄罗斯方块时，也不能移动
首先，我们需要添加一个变量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)
1
2
3
4

然后再在固定俄罗斯方块的时候记录进去，所以
一要添加一个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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
'
运行
运行

然后还要再修改原来的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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

此时运行效果如下

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

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

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

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

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
'
运行
运行

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

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