一个由tkinter按钮指令控制的封装成函数的pygame俄罗斯方块小游戏

### 回答1：
以下是一个使用 tkinter 控制的封装成函数的 pygame 俄罗斯方块小游戏示例：

import pygame
import tkinter as tk
from tkinter import messagebox

# 初始化 tkinter
root = tk.Tk()
root.withdraw()

# 初始化 pygame
pygame.init()

# 游戏区域大小
WIDTH, HEIGHT = 300, 600

# 方块大小
BLOCK_SIZE = 30

# 方块颜色
COLORS = [(0, 0, 0), (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255), (255, 255, 255)]

# 方块形状
SHAPES = [
    [[1, 1, 1],
     [0, 1, 0]],
    [[0, 2, 2],
     [2, 2, 0]],
    [[3, 3, 0],
     [0, 3, 3]],
    [[4, 0, 0],
     [4, 4, 4]],
    [[0, 0, 5],
     [5, 5, 5]],
    [[6, 6, 6, 6]],
    [[7, 7],
     [7, 7]]
]


class Block(object):
    def __init__(self, x, y, shape):
        self.x = x
        self.y = y
        self.shape = shape
        self.color = COLORS[shape[0][0]]
        self.rotation = 0


class Tetris(object):
    def __init__(self):
        self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
        pygame.display.set_caption("Tetris")
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, 30)
        self.init_game()

    def init_game(self):
        self.score = 0
        self.grid = [[0 for _ in range(10)] for _ in range(20)]
        self.current_block = Block(4, 0, SHAPES[0])
        self.next_block = Block(4, 0, SHAPES[0])
        self.game_over = False

    def check_collision(self, block):
        for i in range(4):
            for j in range(4):
                if i * 4 + j in block.shape[block.rotation]:
                    x, y = j + block.x, i + block.y
                    if x < 0 or x >= 10 or y < 0 or y >= 20 or self.grid[y][x]:
                        return True
        return False

    def merge_block(self, block):
        for i in range(4):
            for j in range(4):
                if i * 4 + j in block.shape[block.rotation]:
                    x, y = j + block.x, i + block.y
                    self.grid[y][x] = block.color

    def rotate_block(self, block):
        block.rotation = (block.rotation + 1) % 4

    def remove_row(self, row):
        del self.grid[row]
        self.grid.insert(0, [0 for _ in range(10)])

    def remove_rows(self):
        rows = 0
        for i in range(19, -1, -1):
            if all(self.grid[i]):
                self.remove_row(i)
                rows += 1
        self.score += rows ** 2

    def handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    self.current_block.x -= 1
                    if self.check_collision(self.current_block):
                        self.current_block.x += 1
                elif event.key == pygame.K_RIGHT:
                    self.current_block.x += 1
                    if self.check_collision(self.current_block):
                        self.current_block.x -= 1
                elif event.key == pygame.K_DOWN:
                    self.current_block.y += 1
                    if self.check_collision(self.current_block):
                        self.current_block.y -= 1
                elif event.key == pygame.K_UP:
                    self.rotate_block(self.current_block)
                    if self.check_collision(self.current_block):
                        self.rotate_block(self.current_block)

    def draw_block(self, x, y, color):
        pygame.draw.rect(self.screen, color, pygame.Rect(x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))

    def draw_grid(self):
        for i in range(20):
            for j in range(10):
                self.draw_block(j, i, COLORS[self.grid[i][j]])

    def draw_text(self, text, x, y):
        surface = self.font.render(text, True, (255, 255, 255))
        self.screen.blit(surface, (x, y))

    def draw_current_block(self):
        for i in range(4):
            for j in range(4):
                if i * 4 + j in self.current_block.shape[self.current_block.rotation]:
                    self.draw_block(self.current_block.x + j, self.current_block.y + i, self.current_block.color)

    def draw_next_block(self):
        surface = self.font.render("Next block:", True, (255, 255, 255))
        self.screen.blit(surface, (WIDTH + BLOCK_SIZE, HEIGHT // 2 - BLOCK_SIZE))
        for i in range(4):
            for j in range(4):
                if i * 4 + j in self.next_block.shape[0]:
                    self.draw_block(WIDTH // 2 / BLOCK_SIZE + j, HEIGHT // 2 / BLOCK_SIZE + i, self.next_block.color)

    def draw_score(self):
        self.draw_text("Score: {}".format(self.score), WIDTH + BLOCK_SIZE, HEIGHT // 2)

    def draw_game_over(self):
        surface = self.font.render("Game Over!", True, (255, 0, 0))
        self.screen.blit(surface, (WIDTH // 2 - BLOCK_SIZE, HEIGHT // 2 - BLOCK_SIZE))

    def update(self):
        self.screen.fill((0, 0, 0))
        self.draw_grid()
        self.draw_current_block()
        self.draw_next_block()
        self.draw_score()
        if self.game_over:
            self.draw_game_over()
        pygame.display.update()

    def run(self):
        while True:
            self.clock.tick(10)
            self.handle_input()
            self.current_block.y += 1
            if self.check_collision(self.current_block):
                self.current_block.y -= 1
                self.merge_block(self.current_block)
                self.remove_rows()
                self.current_block = self.next_block
                self.next_block = Block(4, 0, SHAPES[random.randint(0, len(SHAPES) - 1)])
                if self.check_collision(self.current_block):
                    self.game_over = True
                    messagebox.showinfo("Game Over", "Your score is {}".format(self.score))
                    self.init_game()
            self.update()


if __name__ == '__main__':
    tetris = Tetris()
    tetris.run()

在 tkinter 中添加按钮，可以通过按钮来控制游戏的开始、暂停、结束等操作。

### 回答2：
俄罗斯方块是一款经典的游戏，这款封装成函数的pygame版本，使用tkinter按钮指令控制游戏的进行。

首先，我们需要导入所需的模块。在这里，我们导入了pygame和tkinter模块：

import pygame
import tkinter as tk

接下来，我们需要定义一些必要的变量和函数。例如，定义方块的形状、颜色、游戏区域的大小等：

# 定义方块的形状和颜色
shapes = [
    [[1, 1, 1, 1]],
    [[1, 1], [1, 1]],
    [[1, 1, 0], [0, 1, 1]],
    [[0, 1, 1], [1, 1, 0]],
    [[1, 1, 1], [0, 1, 0]],
    [[1, 1, 1], [1, 0, 0]]
]

colors = [
    (0, 0, 0),
    (255, 0, 0),
    (0, 255, 0),
    (0, 0, 255),
    (255, 255, 0),
    (255, 0, 255)
]

# 定义游戏区域的大小
cell_size = 30
cols, rows = 10, 20
width, height = cols * cell_size, rows * cell_size

# 初始化游戏区域
grid = [[0] * cols for _ in range(rows)]

然后，我们定义一些游戏所需的函数，如创建新方块、移动方块、旋转方块等：

# 创建新方块
def new_shape():
    shape = random.choice(shapes)
    x = cols // 2 - len(shape[0]) // 2
    y = 0
    return shape, x, y

# 绘制方块
def draw_shape(shape, x, y):
    for row in range(len(shape)):
        for col in range(len(shape[row])):
            if shape[row][col]:
                pygame.draw.rect(screen, colors[shape[row][col]], (x + col, y + row, 1, 1))

# 移动方块
def move_shape(dx, dy):
    new_x, new_y = shape_x + dx, shape_y + dy
    if is_valid_position(current_shape, new_x, new_y):
        shape_x, shape_y = new_x, new_y
    else:
        if dy > 0:
            freeze_shape()
            remove_completed_lines()
        if not is_game_over():
            current_shape, shape_x, shape_y = new_shape()

最后，我们需要创建一个按钮控制的函数，用于监听按钮的点击事件，并执行相应的操作：

def button_command(command):
    if command == 'left':
        move_shape(-1, 0)
    elif command == 'right':
        move_shape(1, 0)
    elif command == 'down':
        move_shape(0, 1)
    elif command == 'rotate':
        rotate_shape()

通过以上步骤，我们就可以实现一个由tkinter按钮指令控制的封装成函数的pygame俄罗斯方块小游戏。玩家可以通过点击控制按钮来移动和旋转方块，使其填满每一行并消去。当方块堆叠到顶部时，游戏结束。这个小游戏可以带给玩家无尽的乐趣和挑战。