**
Python tkinter还原俄罗斯方块
**
一,分析和代码实现
1)砖块对象的生成及呈现
俄罗斯方块的砖块类型有7种,对应不同的形状。
我们创建一个字典(砖块类型和形状的双射),用以在砖块和形状,砖块和颜色之间建立联系(这里sheapes在下面的砖块呈现解释)。
`# 定义各种形状
SHAPES = {
"O": [(-1, -1), (0, -1), (-1, 0), (0, 0)],
"S": [(-1, 0), (0, 0), (0, -1), (1, -1)],
"T": [(-1, 0), (0, 0), (0, -1), (1, 0)],
"I": [(0, 1), (0, 0), (0, -1), (0, -2)],
"L": [(-1, 0), (0, 0), (-1, -1), (-1, -2)],
"J": [(-1, 0), (0, 0), (0, -1), (0, -2)],
"Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
}
# 定义各种形状的颜色
SHAPESCOLOR = {
"O": "blue",
"S": "red",
"T": "yellow",
"I": "green",
"L": "purple",
"J": "orange",
"Z": "Cyan",
}`
shapes的数组是干什么的?
在此之前我们需要知道,tkinter的坐标轴和生活中的有所不同,生活中,y轴向上,x轴向右,skinter中x轴也是向右,而y轴是向下的,也就是以窗口的左上角为原点。
以o为例子,在中心建立直角坐标系,以每个数组的数据为坐标带入下列的函数。
def draw_cell_by_cr(canvas, c, r, color="#CCCCCC"):
"""
:param canvas: 画板,用于绘制一个方块的Canvas对象
:param c: 方块所在列
:param r: 方块所在行
:param color: 方块颜色,默认为#CCCCCC,轻灰色
:return:
"""
x0 = c * cell_size
y0 = r * cell_size
x1 = c * cell_size + cell_size
y1 = r * cell_size + cell_size
canvas.create_rectangle(x0, y0, x1, y1,
fill=color, outline="white", width=2)
我们知道,create_rectangle画矩形需要两个坐标,一个是左上角的坐标,一个是右下角的坐标。数组作为方块的左上角坐标,坐标加上size(砖块大小)后就是右下角的坐标,从而满足函数参数要求。将draw_cell_by_cr作为画图基础函数,此时需要一个函数,接收砖块的形状数据和颜色数据,并利用砖块形状数据调用draw_cell_by_cr来画砖块。
def draw_cells(canvas, c, r, cell_list, color="#CCCCCC"):
"""
绘制指定形状指定颜色的俄罗斯方块
:param canvas: 画板
:param r: 该形状设定的原点所在的行
:param c: 该形状设定的原点所在的列
:param cell_list: 该形状各个方格相对自身所处位置
:param color: 该形状颜色
:return:
"""
for cell in cell_list:
cell_c, cell_r = cell
ci = cell_c + c
ri = cell_r + r
# 判断该位置方格在画板内部(画板外部的方格不再绘制)
if 0 <= c < C and 0 <= r < R:
draw_cell_by_cr(canvas, ci, ri, color)
我们写完了砖块的特性,此时我们需要一个砖块的对象,创建一个函数,取名generate_new_block,无需参数,返回值为字典,用random的choice方法每次取出一个砖块的类型,同时我们希望砖块在窗口的正中间生成。
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
2)基础界面
俄罗斯方块背景为长方形,用tk库创建一个宽12 * 30,长20 * 30的窗口,其中,30为砖块的长度(砖块为正方形)。随后创建一个列表,其中嵌套了20个小列表,每个小列表中有12个空字符(为什么是空字符?具体见消除与得分),创建这个列表的目的是模拟背景的数据。用线把窗口分为12 * 30个小方块。
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)
block_list = []
for i in range(R):
i_row = ['' for j in range(C)]
block_list.append(i_row)
小结一下
前两部分的程序结果如图
3)砖块移动合理判断,砖块下移,左右移动,旋转
我们知道,砖块是不能超过窗口边界,同时当下面有已经固定的砖块时也要固定。
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] #cell_c+cc是方块的绝对x坐标(相对原点)
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
这里需要注意的是,最后一个判断的r >= 0,方块必须在窗口内部才能判断下方是否有方块。当r < 0时,block_list取的是倒数第r行,此时新生成的方块下面明明没有方块,但却无法下行,从而需要添加条件r > 0。
下移的底层逻辑很巧妙,先用背景颜色把移动前的方块覆盖掉,然后方块的坐标y坐标+1,即可实现移动效果。
def draw_block_move(canvas, block, direction=[0, 0]):
"""
绘制向指定方向移动后的俄罗斯方块
:param canvas: 画板
:param block: 俄罗斯方块对象
:param direction: 俄罗斯方块移动方向
:return:
"""
shape_type = block['kind']
c, r = block['cr']
cell_list = block['cell_list']
# 移动前,先清除原有位置绘制的俄罗斯方块,也就是用背景色绘制原有的俄罗斯方块
draw_cells(canvas, c, r, cell_list)
dc, dr = direction
new_c, new_r = c+dc, r+dr
block['cr'] = [new_c, new_r]
# 在新位置绘制新的俄罗斯方块就好
draw_cells(canvas, new_c, new_r, cell_list, SHAPESCOLOR[shape_type])
左右移动的原理类似,不同在于direction,并且需要监听事件,当用户摁下左右时触发。利用bind函数,将左右键按下和左右移动事件绑定
canvas.bind("<KeyPress-Left>", horizontal_move_block)
canvas.bind("<KeyPress-Right>", horizontal_move_block)
horizontal_move_block函数为左右移动的函数 (因其与事件绑定,故函数需要参数event)
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)
direction的第一个位置代表x坐标的变化,第二个位置代表y的变化。
在实现旋转之前,我们需要先认识到一个数学问题,一个点(x, y)坐标关于原点旋转90度后坐标会如何变化?
由图可知,旋转后坐标(x0,y0)有等式关系x0 = y, y0 = -x
于此同时,是否可以旋转也是很需要考虑的。
设计函数
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
4)底部砖块固定
在写固定的代码前,我们先写一个方法将方块的数据记录到列表block_list的列表中,当方块到底部时调用。
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 在对应位置记下其类型draw_cells
block_list[r][c] = shape_type
固定是游戏中比较频繁发生的操作,因此固定在主函数中写入比较合适。
判断也比较简单,只需查看下一位是否有方块,有方块就固定。
if check_move(current_block, [0, 1]):
draw_block_move(canvas, current_block, [0, 1])
else:
# 无法移动,记入 block_list 中
save_block_to_list(current_block)
主函数见末尾
5)消除,得分和游戏结束
消除的条件是游戏的方块有整行都是满的,因为我们把方块的数据都存入了block_list,因此我们只需遍历列表,如果一行有空的地方就说明没满。
def check_row_complete(row):
for cell in row:
if cell=='':
return False
return True
随后正式写消除
遍历列表,判断行是否满(这里需要一个变量记录是否满,从而为后面刷新页面提供判断),这里的行也要进行区分,如果是第一行满了,那么就无需迁移数据,其他行则需要。迁移数据就是将上一行的数据复制到下一行,循环完后,最上面的一行数据清0即可。
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)
关于得分就比较简单,只需设置一个变量,在消除后变量加10即可。
游戏结束的判断条件。游戏结束时,有某个列是全有数据的,我们可以通过遍历列表数据来判断,但另外有一个简单的办法,当数据从窗口外掉下来时,方块中有一些砖块的坐标还是负值,从刚刚我们调试的地方知道,它们不管坐标在列表下面是否有数据都会向下,因此,在他们向下一步时,在坐标在列表中的数据是有值的,在这种情况下,游戏就结束了。
简单来说,就判断砖块的坐标在数据列表中是否有数据来决定游戏是否结束。
下面即为主程序(负责联系各个板块和判断游戏结束)
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()
# 等待FPS毫秒后执行game_loop
win.after(FPS, game_loop)
最后是详细代码
import tkinter as tk
from tkinter import messagebox
import random
cell_size = 30
C = 12
R = 20
height = R * cell_size
width = C * cell_size
FPS = 200 # 刷新页面的毫秒间隔
# 定义各种形状
SHAPES = {
"O": [(-1, -1), (0, -1), (-1, 0), (0, 0)],
"S": [(-1, 0), (0, 0), (0, -1), (1, -1)],
"T": [(-1, 0), (0, 0), (0, -1), (1, 0)],
"I": [(0, 1), (0, 0), (0, -1), (0, -2)],
"L": [(-1, 0), (0, 0), (-1, -1), (-1, -2)],
"J": [(-1, 0), (0, 0), (0, -1), (0, -2)],
"Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
}
# 定义各种形状的颜色
SHAPESCOLOR = {
"O": "blue",
"S": "red",
"T": "yellow",
"I": "green",
"L": "purple",
"J": "orange",
"Z": "Cyan",
}
def draw_cell_by_cr(canvas, c, r, color="#CCCCCC"):
"""
:param canvas: 画板,用于绘制一个方块的Canvas对象
:param c: 方块所在列
:param r: 方块所在行
:param color: 方块颜色,默认为#CCCCCC,轻灰色
:return:
"""
x0 = c * cell_size
y0 = r * cell_size
x1 = c * cell_size + cell_size
y1 = r * cell_size + cell_size
canvas.create_rectangle(x0, y0, x1, y1,
fill=color, outline="white", width=2)
# 绘制面板
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)
def draw_cells(canvas, c, r, cell_list, color="#CCCCCC"):
"""
绘制指定形状指定颜色的俄罗斯方块
:param canvas: 画板
:param r: 该形状设定的原点所在的行
:param c: 该形状设定的原点所在的列
:param cell_list: 该形状各个方格相对自身所处位置
:param color: 该形状颜色
:return:
"""
for cell in cell_list:
cell_c, cell_r = cell
ci = cell_c + c
ri = cell_r + r
# 判断该位置方格在画板内部(画板外部的方格不再绘制)
if 0 <= c < C and 0 <= r < R:
draw_cell_by_cr(canvas, ci, ri, color)
win = tk.Tk()
canvas = tk.Canvas(win, width=width, height=height, )
canvas.pack()
block_list = []
for i in range(R):
i_row = ['' for j in range(C)]
block_list.append(i_row)
draw_board(canvas, block_list)
def draw_block_move(canvas, block, direction=[0, 0]):
"""
绘制向指定方向移动后的俄罗斯方块
:param canvas: 画板
:param block: 俄罗斯方块对象
:param direction: 俄罗斯方块移动方向
:return:
"""
shape_type = block['kind']
c, r = block['cr']
cell_list = block['cell_list']
# 移动前,先清除原有位置绘制的俄罗斯方块,也就是用背景色绘制原有的俄罗斯方块
draw_cells(canvas, c, r, cell_list)
dc, dr = direction
new_c, new_r = c+dc, r+dr
block['cr'] = [new_c, new_r]
# 在新位置绘制新的俄罗斯方块就好
draw_cells(canvas, new_c, new_r, cell_list, SHAPESCOLOR[shape_type])
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
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
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)
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 在对应位置记下其类型draw_cells
block_list[r][c] = shape_type
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)
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 r>=0 and 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)
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)
canvas.focus_set() # 聚焦到canvas画板对象上
canvas.bind("<KeyPress-Left>", horizontal_move_block)
canvas.bind("<KeyPress-Right>", horizontal_move_block)
canvas.bind("<KeyPress-Up>", rotate_block)
canvas.bind("<KeyPress-Down>", land)
current_block = None
win.update()
win.after(FPS, game_loop) # 在FPS 毫秒后调用 game_loop方法
win.mainloop()