欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

利用python制作俄羅斯方塊詳細(xì)圖文教程

 更新時(shí)間：2023年10月16日 08:37:28   作者：極客李華  
俄羅斯方塊是一款經(jīng)典的游戲,它可以用多種編程語(yǔ)言來(lái)實(shí)現(xiàn),這篇文章主要給大家介紹了關(guān)于利用python制作俄羅斯方塊的詳細(xì)圖文教程,文中通過(guò)代碼介紹的非常詳細(xì),需要的朋友可以參考下

簡(jiǎn)介

俄羅斯方塊》（Tetris， 俄文：Тетрис）是一款由俄羅斯人阿列克謝·帕基特諾夫于1984年6月發(fā)明的休閑游戲。

該游戲曾經(jīng)被多家公司代理過(guò)。經(jīng)過(guò)多輪訴訟后，該游戲的代理權(quán)最終被任天堂獲得。 [1] 任天堂對(duì)于俄羅斯方塊來(lái)說(shuō)意義重大，因?yàn)閷⑺cGB搭配在一起后，獲得了巨大的成功。 [1]

《俄羅斯方塊》的基本規(guī)則是移動(dòng)、旋轉(zhuǎn)和擺放游戲自動(dòng)輸出的各種方塊，使之排列成完整的一行或多行并且消除得分。

編碼

搭建基礎(chǔ)頁(yè)面

首先是創(chuàng)建一個(gè)python文件

創(chuàng)建一個(gè)窗體，用來(lái)顯示這個(gè)游戲的界面

代碼

import tkinter as tk
# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()
win.mainloop()

運(yùn)行結(jié)果

繪制格子

原理如下

畫格子,這里主要應(yīng)用的是tkinter里面Canvas功能。

代碼如下

import tkinter as tk

# 設(shè)置行數(shù)和列數(shù)
row = 20
col = 12

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = row * cell_size
width = col * cell_size

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 在畫板上繪制格子
def draw_cell(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

def draw_blank_board(canvas):
    for ri in range(row):
        for cj in range(col):
            draw_cell(canvas, cj, ri)


# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

draw_blank_board(canvas)

win.mainloop()

繪制俄羅斯方塊

現(xiàn)根據(jù)這個(gè)規(guī)則繪制一個(gè)看看情況

代碼講解

import tkinter as tk

# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
SHAPES = {
    "O": [(-1, -1), (0, -1), (-1, 0), (0, 0)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue"
}

# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
draw_blank_board(canvas)

# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])


win.mainloop()

運(yùn)行結(jié)果，通過(guò)運(yùn)行結(jié)果可以看出來(lái)沒(méi)有太大的問(wèn)題

繪制其他的樣式的格子

這里是其他的格子的各種坐標(biāo)，只需要往上面的代碼中的SHAPES和SHAPESCOLOR中放就可以了。

演示代碼

import tkinter as tk

# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}

# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
draw_blank_board(canvas)

# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])


win.mainloop()

運(yùn)行結(jié)果

通過(guò)測(cè)試這個(gè)各種的圖形格子是完成了的。

讓格子動(dòng)起來(lái)

讓這個(gè)格子使人感覺(jué)動(dòng)起來(lái)，主要的原理就是設(shè)置一個(gè)刷新時(shí)間，然后這個(gè)格子不斷的加載，然后不斷的刷新，這樣是利用的是game_loop(),draw_block_move(canvas, block, direction=[0,0])兩個(gè)函數(shù)。

代碼講解

import tkinter as tk
import time
# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}

# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
draw_blank_board(canvas)

# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
# draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
# draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
# draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
# draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
# draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
# draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
# draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])

# 設(shè)置格子的刷新頻率，單位是毫秒
FPS = 500

# 定義讓俄羅斯方塊移動(dòng)的方法
def draw_block_move(canvas, block, direction=[0,0]):
    """
    :param canvas: 面板對(duì)象
    :param block: 俄羅斯方塊
    :param direction: 移動(dòng)的方向
    :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])

# 用字典定義每個(gè)形狀的屬性
one_block = {
    'kind': 'O', # 對(duì)應(yīng)俄羅斯方塊的類型
    'cell_list': SHAPES['O'], # 對(duì)應(yīng)的每個(gè)俄羅斯方塊的坐標(biāo)
    'cr': [3, 3], # 對(duì)應(yīng)的行列坐標(biāo)
}

draw_block_move(canvas, one_block)
# 讓游戲不斷循環(huán) 通過(guò)遞歸實(shí)現(xiàn)
def game_loop():
    win.update()

    # 往下走
    down = [0, 1]
    draw_block_move(canvas, one_block, down)
    win.after(FPS, game_loop) # 注意的是這個(gè)game_loop后面不能加括號(hào)

game_loop()
win.mainloop()

運(yùn)行結(jié)果

這里生成了一個(gè)，往下掉的小俄羅斯方塊。

生成，固定，變換，移動(dòng) 生成和固定

演示代碼

import tkinter as tk
import time
# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}

# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
draw_blank_board(canvas)

# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
# draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
# draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
# draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
# draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
# draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
# draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
# draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])

# 設(shè)置格子的刷新頻率，單位是毫秒
FPS = 500

# 定義讓俄羅斯方塊移動(dòng)的方法
def draw_block_move(canvas, block, direction=[0,0]):
    """
    :param canvas: 面板對(duì)象
    :param block: 俄羅斯方塊
    :param direction: 移動(dòng)的方向
    :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])

# 用字典定義每個(gè)形狀的屬性
one_block = {
    'kind': 'O', # 對(duì)應(yīng)俄羅斯方塊的類型
    'cell_list': SHAPES['O'], # 對(duì)應(yīng)的每個(gè)俄羅斯方塊的坐標(biāo)
    'cr': [3, 3], # 對(duì)應(yīng)的行列坐標(biāo)
}

draw_block_move(canvas, one_block)
# 讓游戲不斷循環(huán) 通過(guò)遞歸實(shí)現(xiàn)
def game_loop():
    win.update()

    # 往下走
    down = [0, 1]
    draw_block_move(canvas, one_block, down)
    win.after(FPS, game_loop) # 注意的是這個(gè)game_loop后面不能加括號(hào)

game_loop()
win.mainloop()

在這這里我們實(shí)現(xiàn)了這個(gè)俄羅斯方塊的不斷的生成，和俄羅斯方塊的不斷的疊加，基本實(shí)現(xiàn)了俄羅斯方塊的生產(chǎn)功能。

運(yùn)行結(jié)果

移動(dòng)

運(yùn)行結(jié)果

這個(gè)效果就是可以左右移動(dòng)，具體代碼看下面,主要依靠的是horizontal_move_block(event)這個(gè)函數(shù)的實(shí)現(xiàn)。

完整代碼

import tkinter as tk
import random

# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置格子的刷新頻率，單位是毫秒
FPS = 50

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
SHAPES = {
    "Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
    "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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}

# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

# 繪制板塊
def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

# 繪制單元格
def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
draw_blank_board(canvas)

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


# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
# draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
# draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
# draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
# draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
# draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
# draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
# draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])


# 定義讓俄羅斯方塊移動(dòng)的方法
def draw_block_move(canvas, block, direction=[0,0]):
    """
    :param canvas: 面板對(duì)象
    :param block: 俄羅斯方塊
    :param direction: 移動(dòng)的方向
    :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])

# 用字典定義每個(gè)形狀的屬性
one_block = {
    'kind': 'O', # 對(duì)應(yīng)俄羅斯方塊的類型
    'cell_list': SHAPES['O'], # 對(duì)應(yīng)的每個(gè)俄羅斯方塊的坐標(biāo)
    'cr': [3, 3], # 對(duì)應(yīng)的行列坐標(biāo)
}

# 測(cè)試代碼
# draw_block_move(canvas, one_block)

def product_new_block():
    # 隨機(jī)生成新的俄羅斯方塊
    kind = random.choice(list(SHAPES.keys()))

    cr = [Col // 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: 移動(dòng)方向
    :return: boolean 是否可以朝著指定的方向移動(dòng)
    """
    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 >= Col or r >= Row:
            return False
        # r >= 0是防止格子下不來(lái)的情況
        if r >= 0 and block_list[r][c]:
            return False
    return True

# 保存當(dāng)前的俄羅斯方塊到列表里面
def save_to_block_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[r][c] = shape_type


def horizontal_move_block(event):
    """
    左右水平移動(dòng)俄羅斯方塊
    event:鍵盤的監(jiān)聽(tīng)事件
    """
    # 這里只設(shè)置了左右兩個(gè)方向
    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)


# 讓游戲不斷循環(huán) 通過(guò)遞歸實(shí)現(xiàn)
def game_loop():
    win.update()

    global current_block
    # 如果當(dāng)前沒(méi)有俄羅斯方塊 產(chǎn)生一個(gè)新的
    if current_block is None:
        # 生成新的俄羅斯方塊
        new_block = product_new_block()
        draw_block_move(canvas, new_block)
        current_block = new_block
    # 如果當(dāng)前有了就往下走
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            # 保存當(dāng)前的俄羅斯方塊
            save_to_block_list(current_block)
            current_block = None
    win.after(FPS, game_loop) # 注意的是這個(gè)game_loop后面不能加括號(hào)

# 當(dāng)前的俄羅斯方塊
current_block = None

# 畫布聚焦
canvas.focus_set()
# 添加左右移動(dòng)的事件
canvas.bind("<KeyPress-Left>", horizontal_move_block)
canvas.bind("<KeyPress-Right>", horizontal_move_block)


game_loop()
win.mainloop()

變換

這個(gè)是讓這個(gè)俄羅斯方塊的角度可以發(fā)生變換，主要的是利用這個(gè)函數(shù)，這個(gè)rotate_block是角度的旋轉(zhuǎn)，這個(gè)land是馬上下去的功能。

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'],  # 對(duì)應(yīng)俄羅斯方塊的類型
        '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)

完整的代碼

import tkinter as tk
import random

# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置格子的刷新頻率，單位是毫秒
FPS = 250

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
SHAPES = {
    "Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
    "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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}

# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

# 繪制板塊
def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

# 繪制單元格
def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
draw_blank_board(canvas)

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


# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
# draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
# draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
# draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
# draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
# draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
# draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
# draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])


# 定義讓俄羅斯方塊移動(dòng)的方法
def draw_block_move(canvas, block, direction=[0,0]):
    """
    :param canvas: 面板對(duì)象
    :param block: 俄羅斯方塊
    :param direction: 移動(dòng)的方向
    :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])

# 用字典定義每個(gè)形狀的屬性
one_block = {
    'kind': 'O', # 對(duì)應(yīng)俄羅斯方塊的類型
    'cell_list': SHAPES['O'], # 對(duì)應(yīng)的每個(gè)俄羅斯方塊的坐標(biāo)
    'cr': [3, 3], # 對(duì)應(yīng)的行列坐標(biāo)
}

# 測(cè)試代碼
# draw_block_move(canvas, one_block)

def product_new_block():
    # 隨機(jī)生成新的俄羅斯方塊
    kind = random.choice(list(SHAPES.keys()))

    cr = [Col // 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: 移動(dòng)方向
    :return: boolean 是否可以朝著指定的方向移動(dòng)
    """
    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 >= Col or r >= Row:
            return False
        # r >= 0是防止格子下不來(lái)的情況
        if r >= 0 and block_list[r][c]:
            return False
    return True

# 保存當(dāng)前的俄羅斯方塊到列表里面
def save_to_block_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[r][c] = shape_type


def horizontal_move_block(event):
    """
    左右水平移動(dòng)俄羅斯方塊
    event:鍵盤的監(jiān)聽(tīng)事件
    """
    # 這里只設(shè)置了左右兩個(gè)方向
    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'],  # 對(duì)應(yīng)俄羅斯方塊的類型
        '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 = Row
    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, Row):
            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)


# 讓游戲不斷循環(huán) 通過(guò)遞歸實(shí)現(xiàn)
def game_loop():
    win.update()

    global current_block
    # 如果當(dāng)前沒(méi)有俄羅斯方塊 產(chǎn)生一個(gè)新的
    if current_block is None:
        # 生成新的俄羅斯方塊
        new_block = product_new_block()
        draw_block_move(canvas, new_block)
        current_block = new_block
    # 如果當(dāng)前有了就往下走
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            # 保存當(dāng)前的俄羅斯方塊
            save_to_block_list(current_block)
            current_block = None
    win.after(FPS, game_loop) # 注意的是這個(gè)game_loop后面不能加括號(hào)

# 當(dāng)前的俄羅斯方塊
current_block = None

# 畫布聚焦
canvas.focus_set()
# 添加左右移動(dòng)的事件
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)


game_loop()
win.mainloop()

運(yùn)行結(jié)果

現(xiàn)在這個(gè)俄羅斯方塊可以上下角度變化了。

清除與得分

在這版本中，實(shí)現(xiàn)了清除與得分的功能，每次清除這個(gè)俄羅斯方塊，都可以+10的獎(jiǎng)勵(lì)，最后當(dāng)不可以繼續(xù)下去了，這個(gè)游戲就結(jié)束了，然后就退出了。

import tkinter as tk
from tkinter import messagebox
import random

# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置格子的刷新頻率，單位是毫秒
FPS = 150

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
SHAPES = {
    "Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
    "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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}
# 繪制面板，將draw_blank_board方法修改成如下方法
def draw_board(canvas, block_list):
    for ri in range(Row):
        for ci in range(Col):
            cell_type = block_list[ri][ci]
            if cell_type:
                draw_cell_background(canvas, ci, ri, SHAPESCOLOR[cell_type])
            else:
                draw_cell_background(canvas, ci, ri)
# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

# 繪制板塊
def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

# 繪制單元格
def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
block_list = []
for i in range(Row):
    i_row = ['' for j in range(Col)]
    block_list.append(i_row)

draw_board(canvas, block_list)


# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
# draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
# draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
# draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
# draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
# draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
# draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
# draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])


# 定義讓俄羅斯方塊移動(dòng)的方法
def draw_block_move(canvas, block, direction=[0,0]):
    """
    :param canvas: 面板對(duì)象
    :param block: 俄羅斯方塊
    :param direction: 移動(dòng)的方向
    :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])

# 用字典定義每個(gè)形狀的屬性
one_block = {
    'kind': 'O', # 對(duì)應(yīng)俄羅斯方塊的類型
    'cell_list': SHAPES['O'], # 對(duì)應(yīng)的每個(gè)俄羅斯方塊的坐標(biāo)
    'cr': [3, 3], # 對(duì)應(yīng)的行列坐標(biāo)
}

# 測(cè)試代碼
# draw_block_move(canvas, one_block)

def product_new_block():
    # 隨機(jī)生成新的俄羅斯方塊
    kind = random.choice(list(SHAPES.keys()))

    cr = [Col // 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: 移動(dòng)方向
    :return: boolean 是否可以朝著指定的方向移動(dòng)
    """
    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 >= Col or r >= Row:
            return False
        # r >= 0是防止格子下不來(lái)的情況
        if r >= 0 and block_list[r][c]:
            return False
    return True

# 保存當(dāng)前的俄羅斯方塊到列表里面
def save_to_block_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[r][c] = shape_type


def horizontal_move_block(event):
    """
    左右水平移動(dòng)俄羅斯方塊
    event:鍵盤的監(jiān)聽(tīng)事件
    """
    # 這里只設(shè)置了左右兩個(gè)方向
    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'],  # 對(duì)應(yīng)俄羅斯方塊的類型
        '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 = Row
    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, Row):
            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)



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

    return True


score = 0
win.title("SCORES: %s" % score)  # 標(biāo)題中展示分?jǐn)?shù)


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
            # 當(dāng)前行可消除
            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(Col)]
            else:
                block_list[ri] = ['' for j in range(Col)]
            global score
            # 每消除一次 加10分
            score += 10


    if has_complete_row:
        draw_board(canvas, block_list)
        # 重新繪制
        win.title("SCORES: %s" % score)


# 讓游戲不斷循環(huán) 通過(guò)遞歸實(shí)現(xiàn)
def game_loop():
    win.update()

    global current_block
    # 如果當(dāng)前沒(méi)有俄羅斯方塊 產(chǎn)生一個(gè)新的
    if current_block is None:
        # 生成新的俄羅斯方塊
        new_block = product_new_block()
        draw_block_move(canvas, new_block)
        current_block = new_block

        # 游戲結(jié)束
        if not check_move(current_block, [0, 0]):
            messagebox.showinfo("Game Over!", "Your Score is %s" % score)
            win.destroy()
            return

    # 如果當(dāng)前有了就往下走
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            # 保存當(dāng)前的俄羅斯方塊
            save_to_block_list(current_block)
            current_block = None
    # 游戲結(jié)束
    check_and_clear()
    win.after(FPS, game_loop) # 注意的是這個(gè)game_loop后面不能加括號(hào)

# 當(dāng)前的俄羅斯方塊
current_block = None

# 畫布聚焦
canvas.focus_set()
# 添加左右移動(dòng)的事件
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)


game_loop()
win.mainloop()

運(yùn)行結(jié)果

這個(gè)是游戲最后的樣子，其實(shí)可以后面再加一個(gè)數(shù)據(jù)庫(kù)的功能，記錄每一次的得分結(jié)果。

完整代碼

import tkinter as tk
from tkinter import messagebox
import random

# 設(shè)置行數(shù)和列數(shù)
Row = 20
Col = 12

# 設(shè)置格子的刷新頻率，單位是毫秒
FPS = 150

# 設(shè)置每個(gè)格子的大小
cell_size = 30

# 設(shè)置窗口的高和寬
height = Row * cell_size
width = Col * cell_size

# 設(shè)置不同形狀的格子
SHAPES = {
    "Z": [(-1, -1), (0, -1), (0, 0), (1, 0)],
    "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)]
}

# 設(shè)置格子的顏色
SHAPESCOLOR = {
    "O":"blue",
    "S":"red",
    "T":"yellow",
    "I":"green",
    "L":"purple",
    "J":"orange",
    "Z":"Cyan",
}
# 繪制面板，將draw_blank_board方法修改成如下方法
def draw_board(canvas, block_list):
    for ri in range(Row):
        for ci in range(Col):
            cell_type = block_list[ri][ci]
            if cell_type:
                draw_cell_background(canvas, ci, ri, SHAPESCOLOR[cell_type])
            else:
                draw_cell_background(canvas, ci, ri)
# 在畫板上繪制格子
def draw_cell_background(canvas, col, row, color="#CCCCCC"):
    x0 = col * cell_size
    y0 = row * cell_size

    x1 = col * cell_size + cell_size
    y1 = row * cell_size + cell_size

    # 創(chuàng)建矩形
    canvas.create_rectangle(x0, y0, x1, y1, fill=color, outline="white", width=2)

# 繪制板塊
def draw_blank_board(canvas):
    for ri in range(Row):
        for cj in range(Col):
            draw_cell_background(canvas, cj, ri)

# 繪制單元格
def draw_cells(canvas, col, row, cell_list, color="#CCCCCC"):
    """
    :param canvas: 畫板對(duì)象
    :param col: 這個(gè)形狀的的原點(diǎn)所在的列
    :param row: 這個(gè)形狀所的原點(diǎn)所在的行
    :param cell_list: 這個(gè)形狀各個(gè)格子相對(duì)于自身的原點(diǎn)所處的位置坐標(biāo)
    :param color: 這個(gè)形狀的顏色
    :return:
    """
    for cell in cell_list:
        cell_col, cell_row = cell
        ci = cell_col + col
        ri = cell_row + row
        # 判斷是否越界
        if 0 <= col < Col and 0 <= row < Row:
            draw_cell_background(canvas, ci, ri, color)

# 首先創(chuàng)建一個(gè)窗體
win = tk.Tk()

# 繪制畫布的長(zhǎng)寬
canvas = tk.Canvas(win, width=width, height=height)

# 打包放置組件對(duì)象
canvas.pack()

# 畫背景
block_list = []
for i in range(Row):
    i_row = ['' for j in range(Col)]
    block_list.append(i_row)

draw_board(canvas, block_list)


# 開(kāi)始畫圖形了， 這里是先測(cè)試一下
# draw_cells(canvas, 3, 3, SHAPES['O'], SHAPESCOLOR['O'])
# draw_cells(canvas, 3, 8, SHAPES['S'], SHAPESCOLOR['S'])
# draw_cells(canvas, 3, 13, SHAPES['T'], SHAPESCOLOR['T'])
# draw_cells(canvas, 8, 3, SHAPES['I'], SHAPESCOLOR['I'])
# draw_cells(canvas, 8, 8, SHAPES['L'], SHAPESCOLOR['L'])
# draw_cells(canvas, 8, 13, SHAPES['J'], SHAPESCOLOR['J'])
# draw_cells(canvas, 5, 18, SHAPES['Z'], SHAPESCOLOR['Z'])


# 定義讓俄羅斯方塊移動(dòng)的方法
def draw_block_move(canvas, block, direction=[0,0]):
    """
    :param canvas: 面板對(duì)象
    :param block: 俄羅斯方塊
    :param direction: 移動(dòng)的方向
    :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])

# 用字典定義每個(gè)形狀的屬性
one_block = {
    'kind': 'O', # 對(duì)應(yīng)俄羅斯方塊的類型
    'cell_list': SHAPES['O'], # 對(duì)應(yīng)的每個(gè)俄羅斯方塊的坐標(biāo)
    'cr': [3, 3], # 對(duì)應(yīng)的行列坐標(biāo)
}

# 測(cè)試代碼
# draw_block_move(canvas, one_block)

def product_new_block():
    # 隨機(jī)生成新的俄羅斯方塊
    kind = random.choice(list(SHAPES.keys()))

    cr = [Col // 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: 移動(dòng)方向
    :return: boolean 是否可以朝著指定的方向移動(dòng)
    """
    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 >= Col or r >= Row:
            return False
        # r >= 0是防止格子下不來(lái)的情況
        if r >= 0 and block_list[r][c]:
            return False
    return True

# 保存當(dāng)前的俄羅斯方塊到列表里面
def save_to_block_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[r][c] = shape_type


def horizontal_move_block(event):
    """
    左右水平移動(dòng)俄羅斯方塊
    event:鍵盤的監(jiān)聽(tīng)事件
    """
    # 這里只設(shè)置了左右兩個(gè)方向
    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'],  # 對(duì)應(yīng)俄羅斯方塊的類型
        '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 = Row
    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, Row):
            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)



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

    return True


score = 0
win.title("SCORES: %s" % score)  # 標(biāo)題中展示分?jǐn)?shù)


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
            # 當(dāng)前行可消除
            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(Col)]
            else:
                block_list[ri] = ['' for j in range(Col)]
            global score
            # 每消除一次 加10分
            score += 10


    if has_complete_row:
        draw_board(canvas, block_list)
        # 重新繪制
        win.title("SCORES: %s" % score)


# 讓游戲不斷循環(huán) 通過(guò)遞歸實(shí)現(xiàn)
def game_loop():
    win.update()

    global current_block
    # 如果當(dāng)前沒(méi)有俄羅斯方塊 產(chǎn)生一個(gè)新的
    if current_block is None:
        # 生成新的俄羅斯方塊
        new_block = product_new_block()
        draw_block_move(canvas, new_block)
        current_block = new_block

        # 游戲結(jié)束
        if not check_move(current_block, [0, 0]):
            messagebox.showinfo("Game Over!", "Your Score is %s" % score)
            win.destroy()
            return

    # 如果當(dāng)前有了就往下走
    else:
        if check_move(current_block, [0, 1]):
            draw_block_move(canvas, current_block, [0, 1])
        else:
            # 保存當(dāng)前的俄羅斯方塊
            save_to_block_list(current_block)
            current_block = None
    # 游戲結(jié)束
    check_and_clear()
    win.after(FPS, game_loop) # 注意的是這個(gè)game_loop后面不能加括號(hào)

# 當(dāng)前的俄羅斯方塊
current_block = None

# 畫布聚焦
canvas.focus_set()
# 添加左右移動(dòng)的事件
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)


game_loop()
win.mainloop()

總結(jié)

到此這篇關(guān)于利用python制作俄羅斯方塊的文章就介紹到這了,更多相關(guān)python制作俄羅斯方塊內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

  • Python實(shí)現(xiàn)批量生成,重命名和刪除word文件

    Python實(shí)現(xiàn)批量生成,重命名和刪除word文件

    這篇文章主要為大家詳細(xì)介紹了Python如何利用第三方庫(kù)實(shí)現(xiàn)批量生成、重命名和刪除word文件的功能，文中的示例代碼講解詳細(xì)，需要的可以參考一下
    2023-03-03
  • Django token 生成與驗(yàn)證的實(shí)現(xiàn)

    Django token 生成與驗(yàn)證的實(shí)現(xiàn)

    本文主要介紹了Django token 生成與驗(yàn)證的實(shí)現(xiàn),文中通過(guò)示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧
    2025-04-04
  • Python使用POP3和SMTP協(xié)議收發(fā)郵件的示例代碼

    Python使用POP3和SMTP協(xié)議收發(fā)郵件的示例代碼

    這篇文章主要介紹了Python使用POP3和SMTP協(xié)議收發(fā)郵件的示例代碼，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧
    2019-04-04
  • Pygame實(shí)戰(zhàn)練習(xí)之炸彈人學(xué)院游戲

    Pygame實(shí)戰(zhàn)練習(xí)之炸彈人學(xué)院游戲

    炸彈人學(xué)院想必是很多人童年時(shí)期的經(jīng)典游戲,我們依舊能記得抱個(gè)老人機(jī)娛樂(lè)的場(chǎng)景,下面這篇文章主要給大家介紹了關(guān)于如何利用python寫一個(gè)簡(jiǎn)單的炸彈人學(xué)院小游戲的相關(guān)資料,需要的朋友可以參考下
    2021-09-09
  • Python+Selenium實(shí)現(xiàn)在Geoserver批量發(fā)布Mongo矢量數(shù)據(jù)

    Python+Selenium實(shí)現(xiàn)在Geoserver批量發(fā)布Mongo矢量數(shù)據(jù)

    這篇文章主要為大家詳細(xì)介紹了如何利用Python+Selenium實(shí)現(xiàn)在 Geoserver批量發(fā)布來(lái)自Mongo中的矢量數(shù)據(jù)，文中的示例代碼講解詳細(xì)，感興趣的小伙伴可以了解一下
    2022-07-07
  • Python中的struct.unpack示例詳解

    Python中的struct.unpack示例詳解

    在Python中,struct.unpack是一個(gè)函數(shù),用于將字節(jié)串轉(zhuǎn)換為元組,這個(gè)函數(shù)在處理二進(jìn)制數(shù)據(jù)時(shí)非常有用,這篇文章主要介紹了Python中的struct.unpack示例詳解,需要的朋友可以參考下
    2023-12-12
  • Python3.8如何解決No module named 'numpy'報(bào)錯(cuò)問(wèn)題

    Python3.8如何解決No module named 'numpy&apos

    這篇文章主要介紹了Python3.8如何解決No module named 'numpy'報(bào)錯(cuò)問(wèn)題，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教
    2023-06-06
  • Python利用txt文件對(duì)Mysql進(jìn)行增刪改查移

    Python利用txt文件對(duì)Mysql進(jìn)行增刪改查移

    這篇文章主要介紹了如何在Python中利用TXT文件對(duì)Mysql中的記錄進(jìn)行增刪改查移，文中的示例代碼講解詳細(xì)，感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)學(xué)習(xí)
    2021-12-12
  • python中uuid模塊實(shí)例淺析

    python中uuid模塊實(shí)例淺析

    在本篇文章里小編給大家整理了一篇關(guān)于python中uuid模塊實(shí)例淺析內(nèi)容，有需要的朋友們可以學(xué)習(xí)下。
    2020-12-12
  • python 高效去重復(fù) 支持GB級(jí)別大文件的示例代碼

    python 高效去重復(fù) 支持GB級(jí)別大文件的示例代碼

    今天小編就為大家分享一篇python 高效去重復(fù) 支持GB級(jí)別大文件的示例代碼，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧
    2018-11-11

最新評(píng)論