用python自带的tkinter做游戏（二）—— 俄罗斯方块 篇_turtle俄罗斯方块

上回分享了博文 用python自带的tkinter做游戏（一）—— 贪吃蛇 篇
　　今天继续，尝试用tkinter来制作一个更经典的游戏 —— 俄罗斯方块。
　　
　　俄罗斯方块相信大家都玩过，一共有七个方块组，每个方块组由四个小方格组成，有四种旋转的状态。
　　
　　关于这七个方块组，构建的方法主要有二种，绝对构建和相对构建。什么意思呢？绝对构建就是直接用点阵图画出所需要的图形，比如[[1,1],[1,1]]，就是由四个1组成的一个大方块，[[1,1,0],[0,1,1]]就是Z字型的构件，以此类推。
　　
　　而我选择用的是相对构建。在这里我也解释一下，每个方块组由四个小方格组成，选择其中的一个为定位格，然后以这个定位格的坐标来决定其它三个格子的位置。也就是说这三个格子是随着定位格的移动而移动，所以我就把这三个格子命名为随从格。

如果还没明白相对构建的概念，那我图解一下吧。
　　
　　比如这个列表： [[0, 0],[-1, 0],[-1,-1],[-1,-2]]
　　[0, 0] 代表定位格的坐标，就是原点，图中的黄格子就是定位格。
　　[-1, 0]为1号随从格的相对坐标，-1为Y轴，0是X轴，也就是说紧贴着定位格的上方的那个格子。
　　2号随从格相对于定位格的XY轴都小1，所以是[-1,-1]。
　　以此类推，3号定位格的相对坐标就是[-1,-2]。
　　
　　别忘了还有九十度旋转的功能，顺时针旋转九十度后图片就成了这样。
　　
　　列表的描述就成了[[ 0,-2],[ 0, 1],[-1, 1],[-2, 1]]
　　解释一下，定位格的坐标成了[ 0,-2]，这是因为旋转后的定位格相对于之前的位置向左移动了两格，也就是X轴减去2，所以是[ 0,-2]。
　　那我们接下来继续旋转。
　　
列表描述为： [ 0, 0],[ 0, 1],[ 0, 2],[-1, 0]]

再旋转。

[[0, 0],[-1, 0],[-2, 0],[-2, 1]]
最后一种状态再旋转一次的话就回到了第一种状态。
因为定位格产生了位移，所以第一种状态的列表描述改为[[0, 2],[-1, 0],[-1,-1],[-1,-2]]
这样这个组件就可以不断的旋转而不会产生位移。

至此，四种旋转的状态齐了。由于四种状态下，四个定位格的选择都是在同一Y轴上，所以产生的位移都是发生在X轴上。
为了缩短列表长度，我就省略了Y轴坐标，用逆时针旋转时的位移（也只发生在X轴上）来替代。

最终七个组件的代码如下：

seven_shapes =   [[
                 [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]], [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]],
                 [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]], [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]]
                 ],[
                 [[-1,-1],[ 0, 1],[ 0, 2],[ 0, 3]], [[ 1, 1],[-1, 0],[-2, 0],[-3, 0]],
                 [[-1,-1],[ 0, 1],[ 0, 2],[ 0, 3]], [[ 1, 1],[-1, 0],[-2, 0],[-3, 0]]
                 ],[
                 [[ 0, 0],[-1,-1],[-1, 0],[-1, 1]], [[ 1, 0],[-1, 0],[-2, 0],[-1,-1]],
                 [[-1,-1],[ 0, 1],[ 0, 2],[-1, 1]], [[ 0, 1],[-1, 0],[-2, 0],[-1, 1]]
                 ],[
                 [[-1, 0],[-1, 0],[-1, 1],[-1, 2]], [[ 1, 1],[-2,-1],[-2, 0],[-1, 0]],
                 [[ 0,-1],[ 0, 1],[ 0, 2],[-1, 2]], [[ 0, 0],[ 0, 1],[-1, 0],[-2, 0]]
                 ],[
                 [[ 2, 2],[-1, 0],[-1,-1],[-1,-2]], [[ 0,-2],[ 0, 1],[-1, 1],[-2, 1]],
                 [[ 0, 0],[ 0, 1],[ 0, 2],[-1, 0]], [[-2, 0],[-1, 0],[-2, 0],[-2, 1]]
                 ],[
                 [[ 0, 0],[ 0, 1],[-1,-1],[-1, 0]], [[ 0, 0],[-1, 0],[-1, 1],[-2, 1]],
                 [[ 0, 0],[ 0, 1],[-1,-1],[-1, 0]], [[ 0, 0],[-1, 0],[-1, 1],[-2, 1]]
                 ],[ 
                 [[-1,-1],[ 0, 1],[-1, 2],[-1, 1]], [[ 1, 1],[-1, 0],[-1,-1],[-2,-1]],
                 [[-1,-1],[ 0, 1],[-1, 2],[-1, 1]], [[ 1, 1],[-1, 0],[-1,-1],[-2,-1]]
                 ]]

# seven_shapes[x]为七个组件，分别是O，I，T，L，J，Z，S七种形态。每个组件含有四种转向。
# seven_shapes[x][0]为初始转向状态，seven_shapes[x][1]为下一个顺时针90度转向状态，以此类推，一共四个。
# seven_shapes[x][0][1]为1号随从格的相对坐标，以此类推，随从格一共有三个。
# seven_shapes[x][0][0]为旋转偏差值。
# seven_shapes[x][0][0][0]为逆时针偏差值。
# seven_shapes[x][0][0][1]为顺时针偏差值。
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

其实俄罗斯方块和贪吃蛇游戏类似，都属于方格类游戏，原理都差不多，部分代码甚至可以通用。

class Tetris():
    """ 俄罗斯方块游戏  """
    def __init__(self):
        """ 游戏参数设置 """
        self.FPS        = 200                 # 降落速度 1000 = 1秒
        self.col_cells  = 12                  # 一行多少个单元格(含边框)
        self.row_cells  = 24                  # 一共多少行单元格(含边框)
        self.canvas_bg  = 'white'             # 游戏背景色
        self.cell_gap   = 1                   # 方格间距
        self.frame_x    = 5                   # 左右边距
        self.frame_y    = 5                   # 上下边距
        self.win_w_plus = 280                 # 窗口右边额外多出的宽度
        self.color_dict = {0:  '#e0e0e0',     # 0表示空白
                           1:  '#8f8f8f',     # 1为已落地的方块色
                           2:    'green',     # 2为定位格
                           3:    'green',     # 3为组件中除了定位格剩下的三个单元格
                           4:  '#b3b3b3'}     # 4代表边框
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

开场还是游戏的参数的设置。颜色分了五种，但定位格和随从格的颜色相同，确保整体性。

单元格（cell_size）的大小没有定义，这次我打算根据显示器的高度来自动匹配。

        screenHeight = window.winfo_screenheight()  # 获取显示区域的高度
        cell_size = screenHeight / 30
1
2

然后创建游戏地图。

    def create_map(self,col,row):
        """ 创建地图列表 """
        global game_map
        game_map = []
        for y in range(0,col):
            game_map.append([])
        for y in range(0,col):
           for x in range(0,row):
              game_map[y].append(x)   
              game_map[y][x] = 0 # 生成一个全是0的空数列


    def create_wall(self):
        """ 绘制边框 """ # 除了顶部，三个边全部是边框
        for i in range(0,self.col_cells-1):
            game_map[self.row_cells-1][i] = 4
        
        for i in range(0,self.row_cells-1):
            game_map[i][0] = 4
            game_map[i][self.col_cells-1] = 4
            
        game_map[-1][-1] = 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

创建好了地图，并绘制边框。与贪吃蛇不同，这次就不封顶了。

接下来创建画布。

    def create_canvas(self):
        """ 创建画布 """
        global canvas,window
        canvas_h = cell_size * self.row_cells + self.frame_y*2
        canvas_w = cell_size * self.col_cells + self.frame_x*2
        canvas = tk.Canvas(window, 
                           bg = self.canvas_bg, 
                       height =       canvas_h,
                        width =       canvas_w,
           highlightthickness =              0)


    def fresh_cells(self): 
        """ 刷新单元格 """
        for y in range(0,self.row_cells):
            for x in range(0,self.col_cells):
                a = self.frame_x + cell_size*x
                b = self.frame_y + cell_size*y
                c = self.frame_x + cell_size*(x+1)
                d = self.frame_y + cell_size*(y+1)
                e = self.canvas_bg
                f = self.cell_gap
                g = self.color_dict[game_map[y][x]]
                
                canvas.itemconfig(canvas.create_rectangle(a,b,c,d,outline = e, width = f, fill = g),
                                  fill = g)
        canvas.place(x=0,y=0)
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

这次将create_canvas单独做成一个函数，因为我发现在loop中反复刷新创建画布的话，时间久了会造成BUG。

俄罗斯方块游戏进行的时候，会有下一个shape的提示，所以需要随机生成2个shape

now_and_next_shape = [] # 存放当前和之后的2个shape

    def random_shape(self):
        """ 生成随机的shape """
        global turn_times
        turn_times = 0 # 翻转的次数
        x_shape = random.randint(0,6)  # 七个组件随机出现
        now_and_next_shape.append(x_shape)
1
2
3
4
5
6
7
8

生成了shape，就可以抓取定位格的坐标了。

    def shape_xy(self):
        """ 获取定位格坐标 """  # 每个shape由4个单元格组成，一个定位格和三个随从单元格
        global shape_x, shape_y
        xy = []
        for i in range(0,self.row_cells):
            try: # 查找数值为2的坐标，没有就返回0。为防止在0列，先加上1，最后再减去。
                x = game_map[i].index(2) + 1 
            except:
                x = 0
            xy.append(x)
        shape_x = max(xy)
        shape_y = xy.index(shape_x)
        shape_x = shape_x - 1 # 之前加1，现在减回
1
2
3
4
5
6
7
8
9
10
11
12
13

定位格有了，就可以定义随从格了。

    def other_shapes(self,a,b):  # 每个shape由4个单元格组成，一个定位格和三个随从单元格
        """ 三个随从单元格的坐标。a为当前或是下一个shape，b是旋转次数 """
        global y1,x1,y2,x2,y3,x3
        y1 = seven_shapes[now_and_next_shape[a]][b][1][0]
        x1 = seven_shapes[now_and_next_shape[a]][b][1][1]
        y2 = seven_shapes[now_and_next_shape[a]][b][2][0]
        x2 = seven_shapes[now_and_next_shape[a]][b][2][1]
        y3 = seven_shapes[now_and_next_shape[a]][b][3][0]
        x3 = seven_shapes[now_and_next_shape[a]][b][3][1]
1
2
3
4
5
6
7
8
9

有了这个函数，再加上定位格的坐标，就可以在任意地点显示所生成的shape了。

在正式游戏之前，先把下一个shape的预览做好。
我们之前只创建了主游戏的map，现在需要再建立一个mini map，用来存放下一个shape。

    def creat_mini_canvas(self):
        """ 创建预览图用的mini——canvas """
        global canvas2
        canvas2 = tk.Canvas(window,bg = self.canvas_bg,
                               height = self.cell_size * 2 + self.frame_y*2,
                                width = self.cell_size * 4 + self.frame_x*2,
                   highlightthickness = 0)
        

    def creat_mini_map(self):
        """ 创建预览图 """
        mini_map = [] 
        for y in range(0,2):
            mini_map.append([])
        for y in range(0,2):
           for x in range(0,4):
              mini_map[y].append(x)
              mini_map[y][x] = 0        # 生成一个全是0的空数列
        
        l0 = [1,0,1,0,2,1,0]            # 七个组件每个初始出现的X坐标值
        y0 = 1                          # 初始的Y坐标值
        x0 = l0[now_and_next_shape[1]]  # 初始的X坐标值
        
        # 其余三个shape的坐标
        Tetris().other_shapes(1, 0)     # 1是下一个shape，0是旋转的次数
        
        mini_map[y0     ][x0     ] = 4
        mini_map[y0 + y1][x0 + x1] = 4
        mini_map[y0 + y2][x0 + x2] = 4
        mini_map[y0 + y3][x0 + x3] = 4
        

        for y in range(0,2):
              for x in range(0,4):
                canvas2.itemconfig(canvas2.create_rectangle(self.frame_x + cell_size*x,
                                         self.frame_y + cell_size*y,
                                         self.frame_x + cell_size*(x+1),
                                         self.frame_y + cell_size*(y+1),
                                         outline      = self.canvas_bg,
                                         width        = self.cell_gap),
                                         fill         = self.color_dict[mini_map[y][x]])
                
        canvas2.place(x= cell_size * self.col_cells + cell_size*2, y = 0)
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

说明一下，因为七个shape长短不一，所以初始出现的X坐标需要定义一下。l0 = [1,0,1,0,2,1,0] 这里面的七个数字就是七个shape初始出现的X坐标。

预览图搞定了，继续回到主画面，开始定义当前的shape。

    def shape_follow(self,x,a): # 三个随从格绑定与定位格的坐标
        """ x为turn_times的翻转值，a为单元格的颜色代码 """
        Tetris().shape_xy()
        
        l0 = [5,4,5,5,6,5,5]            # 七个组件每个初始出现的X坐标值
        y0 = 1                          # 初始的Y坐标值
        x0 = l0[now_and_next_shape[0]]  # 初始的X坐标值
        
        Tetris().other_shapes(0, x)
        
        if  shape_x != -1: # 等于-1的话就代表没有shape，不是刚开始就是刚落地
            if game_map[shape_y + y1][shape_x + x1] in [0,2,3] and \
               game_map[shape_y + y2][shape_x + x2] in [0,2,3] and \
               game_map[shape_y + y3][shape_x + x3] in [0,2,3]:
                   game_map[shape_y + y1][shape_x + x1] = a
                   game_map[shape_y + y2][shape_x + x2] = a
                   game_map[shape_y + y3][shape_x + x3] = a
        else: # 出现在画面顶端
            game_map[y0     ][x0     ] = 2
            game_map[y0 + y1][x0 + x1] = 3
            game_map[y0 + y2][x0 + x2] = 3
            game_map[y0 + y3][x0 + x3] = 3
            
        Tetris().shape_xy()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

再定义一个移动中的shape

    def shape_move(self,x,y,z):
        """ shape移动。x，y为XY轴的偏移，z为颜色代码（当前shape或是已落地的shape，1或3） """
        Tetris().shape_follow(turn_times,0)     # 把三个随从格颜色变成0，即删除
        game_map[shape_y + 0][shape_x + 0] = 0  # 把定位格颜色变为0，即删除
        game_map[shape_y + y][shape_x + x] = 2  # X轴或Y轴移动一格后生成新的定位格
        Tetris().shape_follow(turn_times,z)     # 根据新的定位格坐标生成随从格，颜色是1或者是3（当前shape或已落地的shape）
1
2
3
4
5
6

移动shape的代码和贪吃蛇的差不多，就不详细说明了。直接看最下方的完整代码或者看上一篇博文吧，在这里我就省点精力了。

因为shape还能翻转，这里的代码我说明一下：

        def clockwise_key(key):
            """ 顺时针转向按键 """
            global turn_times
            direction = event.keysym
            if(direction == key):
                turn_times = turn_times + 1 # 旋转次数，每旋转一次数值加1
                if turn_times > 3: # 总共4个转向，大于3就变回0
                    turn_times = 0
                
                x4 = seven_shapes[now_and_next_shape[0]][turn_times][0][1]
                Tetris().shape_follow(turn_times - 1, 0)
                Tetris().shape_move(x4,0,3)

        def clockwise_key_estimate():
            """ 顺时针转向判断 """ # 如果遇上墙或者已完成的方块，阻止其转向
            x = turn_times + 1
            if x > 3:
                x = 0
            
            x0 = seven_shapes[now_and_next_shape[0]][x][0][1]
            Tetris().other_shapes(0, x)
            
            if shape_y + y1 > 0 or shape_y + y2 > 0 or shape_y + y3 > 0:
                if    game_map[shape_y +  0][shape_x + x0 +  0] in [1,4] or \
                      game_map[shape_y + y1][shape_x + x0 + x1] in [1,4] or \
                      game_map[shape_y + y2][shape_x + x0 + x2] in [1,4] or \
                      game_map[shape_y + y3][shape_x + x0 + x3] in [1,4]:
                          Tetris().shape_move(0,0,3)
                else:
                      clockwise_key('j')

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

逆时针旋转的差不多，我也略过省时间了。
FC红白机里的俄罗斯方块还有减速和加速功能，我这里也复刻了，代码比较简单，我也就不详细解读了，请自行阅读代码。

根据游戏设计，满行即消除。这消除的代码如下：

    def full_del(self):
        """ 满行清除并新增一行 """
        global r1,r2,r3,r4
        r = 0 # 一次消除的行数
        for i in range(1,self.row_cells-1): # 某行若出现10个1，就删除该行，并在第2行之后再插入一行空的
            if game_map[i].count(1) == self.col_cells - 2:
                del game_map[i]
                r = r + 1
                new_row = [] # 准备要插入的新行
                for x in range(0,self.col_cells):
                    new_row.append(0)
                new_row[ 0] = 4 # 第一格和最后一格是边框
                new_row[-1] = 4
                game_map.insert(2,new_row)
        
        if   r == 1:       # 本次一共消除了一行
             r1 = r1 + 1
        elif r == 2:       # 本次一共消除了二行
             r2 = r2 + 1
        elif r == 3:       # 本次一共消除了三行
             r3 = r3 + 1
        elif r == 4:       # 本次一共消除了四行
             r4 = r4 + 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

原理很简单，满行就删除，然后再插入一行空白的。
再加入一个统计，记录下每次一共消除了几行，供计分用。

    def scoring_loop(self):
        """ 计分更新 """
        global r5,r6,scoring_lable
        r5 = r1 + r2*2 + r3*3 + r4*4 # 消除的总数
        r6 = r1 + r2*2*2 + r3*3*3 + r4*4*4 # 计分。消的越多，奖励越多
        
        scoring_lable['text'] = "\n" \
                              + "\n单消： " + str(r1) \
                              + "\n双消： " + str(r2) \
                              + "\n三消： " + str(r3) \
                              + "\n四消： " + str(r4) \
                              + "\n" \
                              + "\n总消： " + str(r5) \
                              + "\n总分： " + str(r6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上回贪吃蛇没有计分系统，这次弥补上。
本人设计的计分系统比较变态，大大鼓励一次性消除四行。
本来想设计成只消除一行的话就扣分，后来仔细想想自己都觉得变态，还是算了吧。。。

是游戏总得有个尽头。

    def game_over(self):
        """ 游戏结束 """
        global r1,r2,r3,r4,r5,r6,scoring_lable
        if game_map[2].count(1) > 0: # 有1出现了就算失败
            showinfo('Game Over','再来一局')
            scoring_lable['text'] = ''
            Tetris().game_start()
1
2
3
4
5
6
7

只要在地图的第三行出现了数值1就算游戏失败。
胜利条件？那是不存在的！

至此整个俄罗斯方块算是完成了，UI是简陋了些，也就够自娱自乐。
懒得做起始页面了，就用暂停的方式来做初始界面。
所以游戏开始前需要按空格键，确认后方可进行游戏。

此外游戏中所有的按键必须要小写，不能设置成和贪吃蛇一样，大小写均可。
具体原因我还没分析，应该和按键释放有关，若有高人能指点一二，本人将感激不尽！

晒一下游戏画面：
（欢迎加本人WX一同交流：znix1116）

最终附上完整代码：
（剧透：下一期的主题——用python自带的tkinter做游戏（三）—— 推箱子 篇）
2022.03.25 更新了代码，修复了些BUG。

# -*- coding: utf-8 -*-
"""
Created on Sun Apr  4 10:12:46 2021

@author: Juni Zhu
"""

import tkinter as tk
from tkinter.messagebox import showinfo
import random


seven_shapes  =  [[
                 [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]], [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]],
                 [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]], [[ 0, 0],[ 0, 1],[-1, 0],[-1, 1]]
                 ],[
                 [[-1,-1],[ 0, 1],[ 0, 2],[ 0, 3]], [[ 1, 1],[-1, 0],[-2, 0],[-3, 0]],
                 [[-1,-1],[ 0, 1],[ 0, 2],[ 0, 3]], [[ 1, 1],[-1, 0],[-2, 0],[-3, 0]]
                 ],[
                 [[ 0, 0],[-1,-1],[-1, 0],[-1, 1]], [[ 1, 0],[-1, 0],[-2, 0],[-1,-1]],
                 [[-1,-1],[ 0, 1],[ 0, 2],[-1, 1]], [[ 0, 1],[-1, 0],[-2, 0],[-1, 1]]
                 ],[
                 [[-1, 0],[-1, 0],[-1, 1],[-1, 2]], [[ 1, 1],[-2,-1],[-2, 0],[-1, 0]],
                 [[ 0,-1],[ 0, 1],[ 0, 2],[-1, 2]], [[ 0, 0],[ 0, 1],[-1, 0],[-2, 0]]
                 ],[
                 [[ 2, 2],[-1, 0],[-1,-1],[-1,-2]], [[ 0,-2],[ 0, 1],[-1, 1],[-2, 1]],
                 [[ 0, 0],[ 0, 1],[ 0, 2],[-1, 0]], [[-2, 0],[-1, 0],[-2, 0],[-2, 1]]
                 ],[
                 [[ 0, 0],[ 0, 1],[-1,-1],[-1, 0]], [[ 0, 0],[-1, 0],[-1, 1],[-2, 1]],
                 [[ 0, 0],[ 0, 1],[-1,-1],[-1, 0]], [[ 0, 0],[-1, 0],[-1, 1],[-2, 1]]
                 ],[ 
                 [[-1,-1],[ 0, 1],[-1, 2],[-1, 1]], [[ 1, 1],[-1, 0],[-1,-1],[-2,-1]],
                 [[-1,-1],[ 0, 1],[-1, 2],[-1, 1]], [[ 1, 1],[-1, 0],[-1,-1],[-2,-1]]
                 ]]

# seven_shapes[x]为七个组件，分别是O，I，T，L，J，Z，S七种形态。每个组件含有四种转向。
# seven_shapes[x][0]为初始转向状态，seven_shapes[x][1]为下一个顺时针90度转向状态，以此类推，一共四个。
# seven_shapes[x][0][1]为1号随从格的相对坐标，以此类推，随从格一共有三个。
# seven_shapes[x][0][0]为旋转偏差值。
# seven_shapes[x][0][0][0]为逆时针偏差值。
# seven_shapes[x][0][0][1]为顺时针偏差值。

now_and_next_shape = [] # 存放当前和之后的2个shape


class Tetris():
    """ 俄罗斯方块游戏  """
    def __init__(self):
        """ 游戏参数设置 """
        self.FPS        = 150                 # 降落速度 1000 = 1秒
        self.col_cells  = 12                  # 一行多少个单元格(含边框)
        self.row_cells  = 24                  # 一共多少行单元格(含边框)
        self.canvas_bg  = 'white'             # 游戏背景色
        self.cell_gap   = 1                   # 方格间距
        self.frame_x    = 5                   # 左右边距
        self.frame_y    = 5                   # 上下边距
        self.win_w_plus = 280                 # 窗口右边额外多出的宽度
        self.color_dict = {0:  '#e0e0e0',     # 0表示空白
                           1:  '#8f8f8f',     # 1为已落地的方块色
                           2:    'green',     # 2为定位格
                           3:    'green',     # 3为组件中除了定位格剩下的三个单元格
                           4:  '#b3b3b3'}     # 4代表边框
        
        self.run_game()
        
        
    def window_center(self,window,w_size,h_size):
        """ 窗口居中 """
        screenWidth  =  window.winfo_screenwidth()  # 获取显示区域的宽度
        screenHeight = window.winfo_screenheight()  # 获取显示区域的高度
        left         =  (screenWidth - w_size) // 2
        top          = (screenHeight - h_size) // 2 - 10
        window.geometry("%dx%d+%d+%d" % (w_size, h_size, left, top))
        
        
    def create_map(self,col,row):
        """ 创建地图列表 """
        global game_map
        game_map = []
        for y in range(0,col):
            game_map.append([])
        for y in range(0,col):
           for x in range(0,row):
              game_map[y].append(x)   
              game_map[y][x] = 0 # 生成一个全是0的空数列


    def create_wall(self):
        """ 绘制边框 """ # 除了顶部，三个边全部是边框
        for i in range(0,self.col_cells-1):
            game_map[self.row_cells-1][i] = 4
        
        for i in range(0,self.row_cells-1):
            game_map[i][0] = 4
            game_map[i][self.col_cells-1] = 4
            
        game_map[-1][-1] = 4
        
        
    def create_canvas(self):
        """ 创建画布 """
        global canvas,window
        canvas_h = cell_size * self.row_cells + self.frame_y*2
        canvas_w = cell_size * self.col_cells + self.frame_x*2
        
        canvas = tk.Canvas(window, 
                           bg = self.canvas_bg,
                       height =       canvas_h,
                        width =       canvas_w,
           highlightthickness =              0)
        
        
    def fresh_cells(self): 
        """ 刷新单元格 """
        for y in range(0,self.row_cells):
            for x in range(0,self.col_cells):
                a = self.frame_x + cell_size*x
                b = self.frame_y + cell_size*y
                c = self.frame_x + cell_size*(x+1)
                d = self.frame_y + cell_size*(y+1)
                e = self.canvas_bg
                f = self.cell_gap
                g = self.color_dict[game_map[y][x]]
                
                canvas.itemconfig(canvas.create_rectangle(a,b,c,d,outline = e, width = f, fill = g),
                                  fill = g)
        canvas.place(x=0,y=0)
        
        
    def random_shape(self):
        """ 生成随机的shape """
        global turn_times
        turn_times = 0 # 翻转的次数
        x_shape = random.randint(0,6)  # 七个组件随机出现
        now_and_next_shape.append(x_shape)
        
        
    def get_locator_cell_pos(self):
        """ 获取定位格坐标 """  # 每个shape由4个单元格组成，一个定位格和三个随从单元格
        global shape_x, shape_y
        xy = []
        for i in range(0,self.row_cells):
            try: # 查找数值为2的坐标，没有就返回0。为防止在0列，先加上1，最后再减去。
                x = game_map[i].index(2) + 1 
            except:
                x = 0
            xy.append(x)
        shape_x = max(xy)
        shape_y = xy.index(shape_x)
        shape_x = shape_x - 1 # 之前加1，现在减回
        
        
    def get_follow_cells_pos(self,a,b):  # 每个shape由4个单元格组成，一个定位格和三个随从单元格
        """ 三个随从单元格的坐标。a为当前或是下一个shape，b是旋转次数 """
        global y1,x1,y2,x2,y3,x3
        y1 = seven_shapes[now_and_next_shape[a]][b][1][0]
        x1 = seven_shapes[now_and_next_shape[a]][b][1][1]
        y2 = seven_shapes[now_and_next_shape[a]][b][2][0]
        x2 = seven_shapes[now_and_next_shape[a]][b][2][1]
        y3 = seven_shapes[now_and_next_shape[a]][b][3][0]
        x3 = seven_shapes[now_and_next_shape[a]][b][3][1]
        
        
    def creat_mini_canvas(self):
        """ 创建预览图用的mini canvas """
        global canvas2
        canvas2 = tk.Canvas(window,bg = self.canvas_bg,
                               height = cell_size * 2 + self.frame_y*2,
                                width = cell_size * 4 + self.frame_x*2,
                   highlightthickness = 0)
        

    def creat_mini_map(self):
        """ 创建预览图 """
        mini_map = [] 
        for y in range(0,2):
            mini_map.append([])
        for y in range(0,2):
           for x in range(0,4):
              mini_map[y].append(x)
              mini_map[y][x] = 0        # 生成一个全是0的空数列
        
        l0 = [1,0,1,0,2,1,0]            # 七个组件每个初始出现的X坐标值
        y0 = 1                          # 初始的Y坐标值
        x0 = l0[now_and_next_shape[1]]  # 初始的X坐标值
        
        # 其余三个shape的坐标
        self.get_follow_cells_pos(1, 0)     # 1是下一个shape，0是旋转的次数
        
        mini_map[y0     ][x0     ] = 4
        mini_map[y0 + y1][x0 + x1] = 4
        mini_map[y0 + y2][x0 + x2] = 4
        mini_map[y0 + y3][x0 + x3] = 4
        

        for y in range(0,2):
              for x in range(0,4):
                canvas2.itemconfig(canvas2.create_rectangle(self.frame_x + cell_size*x,
                                         self.frame_y + cell_size*y,
                                         self.frame_x + cell_size*(x+1),
                                         self.frame_y + cell_size*(y+1),
                                         outline      = self.canvas_bg,
                                         width        = self.cell_gap),
                                         fill         = self.color_dict[mini_map[y][x]])
                
        canvas2.place(x= cell_size * self.col_cells + cell_size*2, y = 0)
        
        
    def follow_cells_bind_to_locator(self,x,a): # 三个随从格绑定与定位格的坐标
        """ x为turn_times的翻转值，a为单元格的颜色代码 """
        self.get_locator_cell_pos()
        
        l0 = [5,4,5,5,6,5,5]            # 七个组件每个初始出现的X坐标值
        y0 = 1                          # 初始的Y坐标值
        x0 = l0[now_and_next_shape[0]]  # 初始的X坐标值
        
        self.get_follow_cells_pos(0, x)
        
        if  shape_x != -1: # 等于-1的话就代表没有shape，不是刚开始就是刚落地
            if game_map[shape_y + y1][shape_x + x1] in [0,2,3] and \
               game_map[shape_y + y2][shape_x + x2] in [0,2,3] and \
               game_map[shape_y + y3][shape_x + x3] in [0,2,3]:
                   game_map[shape_y + y1][shape_x + x1] = a
                   game_map[shape_y + y2][shape_x + x2] = a
                   game_map[shape_y + y3][shape_x + x3] = a
        else: # 出现在画面顶端
            game_map[y0     ][x0     ] = 2
            game_map[y0 + y1][x0 + x1] = 3
            game_map[y0 + y2][x0 + x2] = 3
            game_map[y0 + y3][x0 + x3] = 3
            
        self.get_locator_cell_pos()
        
        
    def Release_speed(self,event):
        """ 上下键释放 """ # 弹起上键或下键，触发速度的改变
        def speed_Release(up,down):
            """ 上下键释放 """
            global speed
            direction = event.keysym
            if(direction == up):
                speed[0] = 0
            if(direction == down):
                speed[0] = 0
                
        speed_Release('w','s')
        
        
    def shape_move(self,x,y,z):
        """ shape移动。x，y为XY轴的偏移，z为颜色代码（当前shape或是已落地的shape，1或3） """
        self.follow_cells_bind_to_locator(turn_times,0)     # 把三个随从格颜色变成0，即删除
        game_map[shape_y + 0][shape_x + 0] = 0                  # 把定位格颜色变为0，即删除
        game_map[shape_y + y][shape_x + x] = 2                  # X轴或Y轴移动一格后生成新的定位格
        self.follow_cells_bind_to_locator(turn_times,z)     # 根据新的定位格坐标生成随从格，颜色是1或者是3（当前shape或已落地的shape）
        
        
    def control_shape(self,event):
        """ 操控shape """
        def speed_key(up,down):
            """ 上下键控制速度 """
            global speed
            direction = event.keysym
            if(direction == up):
                speed[0] = 1
            elif(direction == down):
                speed[0] = 2
            else:
                speed[0] = 0
                
                
        def move_key(key,x):
            """ 左右移动按键，x为左右移动数 """
            global turn_times
            direction = event.keysym
            if(direction == key): 
                self.get_follow_cells_pos(0, turn_times)
                # 如果遇上墙或者已固定的方块，则不做移动
                if    game_map[shape_y +  0][shape_x +  0 + x] in [1,4] or \
                      game_map[shape_y + y1][shape_x + x1 + x] in [1,4] or \
                      game_map[shape_y + y2][shape_x + x2 + x] in [1,4] or \
                      game_map[shape_y + y3][shape_x + x3 + x] in [1,4]:
                          pass
                else:
                    self.shape_move(x,0,3)
                    
                    
        def clockwise_key(key):
            """ 顺时针转向按键 """
            global turn_times
            direction = event.keysym
            if(direction == key):
                turn_times = turn_times + 1 # 旋转次数，每旋转一次数值加1
                if turn_times > 3: # 总共4个转向，大于3就变回0
                    turn_times = 0
                
                x4 = seven_shapes[now_and_next_shape[0]][turn_times][0][1]
                self.follow_cells_bind_to_locator(turn_times - 1, 0)
                self.shape_move(x4,0,3)
                
                
        def counterclockwise_key(key):
            """ 逆时针转向按键 """
            global turn_times
            direction = event.keysym
            if(direction == key):
                turn_times = turn_times - 1
                if turn_times < 0: # 和顺时针相反，小于0就变成3
                    turn_times = 3
                    
                x4 = seven_shapes[now_and_next_shape[0]][turn_times][0][0]
                
                if turn_times < 3:
                    self.follow_cells_bind_to_locator(turn_times + 1, 0)
                else:
                    self.follow_cells_bind_to_locator(0, 0)
                    
                self.shape_move(x4,0,3)
        
        
        def pause_key(key):
            """ 暂停键 """
            global loop,gloop
            direction = event.keysym
            if(direction == key):
                loop = 0
                showinfo('暂停','按确定键继续')
                loop = 1
                gloop = window.after(FPS, self.game_loop)
                
                
        def clockwise_key_estimate():
            """ 顺时针转向判断 """ # 如果遇上墙或者已完成的方块，阻止其转向
            x = turn_times + 1
            if x > 3:
                x = 0
            
            x0 = seven_shapes[now_and_next_shape[0]][x][0][1]
            self.get_follow_cells_pos(0, x)
            
            if shape_y + y1 > 0 or shape_y + y2 > 0 or shape_y + y3 > 0:
                if    game_map[shape_y +  0][shape_x + x0 +  0] in [1,4] or \
                      game_map[shape_y + y1][shape_x + x0 + x1] in [1,4] or \
                      game_map[shape_y + y2][shape_x + x0 + x2] in [1,4] or \
                      game_map[shape_y + y3][shape_x + x0 + x3] in [1,4]:
                          self.shape_move(0,0,3)
                else:
                      clockwise_key('j')
                      
        
        def counterclockwise_estimate():
            """ 逆时针转向判断 """ # 如果遇上墙或者已完成的方块，阻止其转向
            x = turn_times - 1
            if x < 0:
                x = 3
            
            x0 = seven_shapes[now_and_next_shape[0]][x][0][0]
            self.get_follow_cells_pos(0, x)
        
            if shape_y + y1 > 0 or shape_y + y2 > 0 or shape_y + y3 > 0:
              if          game_map[shape_y +  0][shape_x + x0 +  0] in [1,4] or \
                          game_map[shape_y + y1][shape_x + x0 + x1] in [1,4] or \
                          game_map[shape_y + y2][shape_x + x0 + x2] in [1,4] or \
                          game_map[shape_y + y3][shape_x + x0 + x3] in [1,4]:
                              self.shape_move(0,0,3)
              else:
                              counterclockwise_key('k')
                              
                              
        move_key('a', -1)
        move_key('d',  1)
        
        speed_key('w','s')
        pause_key('space')
        
        clockwise_key_estimate()
        counterclockwise_estimate()
        self.fresh_cells()
        
    def auto_down(self):
        """ 组件自动下降 """
        global turn_times,FPS
        self.get_follow_cells_pos(0, turn_times)
        # 当前shape下方是墙或者是已完成的shape，那当前shape变成已完成的状态，即值等于1
        if    game_map[shape_y +  0 + 1][shape_x +  0] in [1,4] or \
              game_map[shape_y + y1 + 1][shape_x + x1] in [1,4] or \
              game_map[shape_y + y2 + 1][shape_x + x2] in [1,4] or \
              game_map[shape_y + y3 + 1][shape_x + x3] in [1,4]:
                  self.shape_move(0,0,1)     # 三个随从格变成1
                  game_map[shape_y][shape_x] = 1 # 定位格也变成1
                  
                  del now_and_next_shape[0]  # 删除当前shape，准备出现下一个
                  self.random_shape()    # 再随机创建一个新的shape
                  canvas2.delete('all')      # 清除预览图的canvas，创建过多会有BUG
                  self.creat_mini_map()
                  self.follow_cells_bind_to_locator(0,3)
                  speed[0] = 0
                  FPS = self.FPS
        else:
                  self.shape_move(0,1,3)
                  
                  
    def full_del(self):
        """ 满行清除并新增一行 """
        global r1,r2,r3,r4
        r = 0 # 一次消除的行数
        for i in range(1,self.row_cells-1): # 某行若出现10个1，就删除该行，并在第2行之后再插入一行空的
            if game_map[i].count(1) == self.col_cells - 2:
                del game_map[i]
                r = r + 1
                new_row = [] # 准备要插入的新行
                for x in range(0,self.col_cells):
                    new_row.append(0)
                new_row[ 0] = 4 # 第一格和最后一格是边框
                new_row[-1] = 4
                game_map.insert(2,new_row)
        
        if   r == 1:       # 本次一共消除了一行
             r1 = r1 + 1
        elif r == 2:       # 本次一共消除了二行
             r2 = r2 + 1
        elif r == 3:       # 本次一共消除了三行
             r3 = r3 + 1
        elif r == 4:       # 本次一共消除了四行
             r4 = r4 + 1
        
                
    def scoring(self):
        """ 计分牌 """
        global scoring_lable
        scoring_lable = tk.Label(window, text="",font=('Yahei', 12),anchor="ne", justify="left")
        
        scoring_lable.place(x= cell_size * self.col_cells + cell_size*2, 
                        y = cell_size*16)        


    def scoring_loop(self):
        """ 计分更新 """
        global r5,r6,scoring_lable
        r5 = r1 + r2*2 + r3*3 + r4*4 # 消除的总数
        r6 = r1 + r2*2*2 + r3*3*3 + r4*4*4 # 计分。消的越多，奖励越多
        
        scoring_lable['text'] = "\n" \
                              + "\n单消： " + str(r1) \
                              + "\n双消： " + str(r2) \
                              + "\n三消： " + str(r3) \
                              + "\n四消： " + str(r4) \
                              + "\n" \
                              + "\n总消： " + str(r5) \
                              + "\n总分： " + str(r6)

    def game_over(self):
        """ 游戏结束 """
        global r1,r2,r3,r4,r5,r6,scoring_lable
        if game_map[2].count(1) > 0: # 有1出现了就算失败
            showinfo('Game Over','再来一局')
            scoring_lable['text'] = ''
            self.game_start()
            
            
    def game_loop(self):
        """ 游戏循环刷新 """
        global window, FPS, gloop
        canvas.delete('all') # 清除canvas，不清除的话时间久了有BUG
        self.fresh_cells()
        self.auto_down()
        self.full_del()
        self.scoring_loop()
        
        if   speed[0] == 1:  # 值为1时，速度减慢
             FPS = self.FPS * 5   
        elif speed[0] == 2:  # 值为2时，速度加快
             FPS = 20
        else:
             FPS = self.FPS
        
        self.game_over()
        
        if loop == 1: # 暂停开关
            gloop = window.after(FPS, self.game_loop)
        
        
    def game_start(self):
        """  """
        global window,speed,FPS,loop,r1,r2,r3,r4,r5,r6
        r1 = 0 # 消除一行的次数
        r2 = 0 # 消除二行的次数
        r3 = 0 # 消除三行的次数
        r4 = 0 # 消除四行的次数
        r5 = 0 # 消除的总数
        r6 = 0 # 计分
        
        loop = 0    # 暂停开关。1为开启，0为暂停
        speed = [0] # 速度调节参数
        self.create_map(self.row_cells,self.col_cells)
        self.create_wall()
        self.random_shape()
        self.random_shape() # 执行2次，生成2个随机的shape
        self.creat_mini_canvas()
        self.creat_mini_map()
        self.follow_cells_bind_to_locator(0,3)
        window.bind('<KeyPress>',   self.control_shape)
        window.bind('<KeyRelease>', self.Release_speed)
        FPS = self.FPS
        self.create_canvas()
        self.scoring()
        self.game_loop()
        
        def close_w():
            if loop == 1:
                window.after_cancel(gloop)
            window.destroy()
            
        window.protocol('WM_DELETE_WINDOW', close_w)
        window.mainloop()
        
        
    def run_game(self):
        """ 开启游戏 """
        global window,cell_size,gloop
        
        window = tk.Tk()
        window.focus_force()
        window.title('Tetris')
        gloop = None
        screenHeight = window.winfo_screenheight()  # 获取显示区域的高度
        cell_size = screenHeight / (self.row_cells + 5)
        
        win_w_size = self.col_cells * cell_size + self.frame_x*2 + self.win_w_plus 
        win_h_size = self.row_cells * cell_size + self.frame_y*2
        
        self.window_center(window,win_w_size,win_h_size)
        
        txt_lable = tk.Label(window, text=
                              "按 空格键 开始游戏"
                             +"\n"
                             +"\n字母键AD左右移动"
                             +"\n字母键W减速"
                             +"\n字母键S加速下降"
                             +"\n"
                             +"\n字母键J顺时针旋转"
                             +"\n字母键K逆时针旋转"
                             +"\n"
                             +"\n以上所有的字母"
                             +"\n均为小写状态"
                             +"\n"
                             +"\n空格键暂停"
                             +"\n"
                             +"\n"
                             +"\n版本：1.1"
                             +"\n作者：Juni Zhu"
                             +"\n微信：znix1116",
                             font=('Yahei', 12),anchor="ne", justify="left")
        
        txt_lable.place(x= cell_size * self.col_cells + cell_size*2, 
                        y = cell_size*4)
        
        self.game_start()
        

if __name__ == '__main__':
    
    Tetris()
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562