用Python写一个俄罗斯方块游戏代码

好的，下面是Python实现俄罗斯方块游戏的代码：

import pygame
import random

pygame.init()

# 颜色定义
WHITE = (255, 255, 255)  # 白色
BLACK = (0, 0, 0)  # 黑色
RED = (255, 0, 0)  # 红色
GREEN = (0, 255, 0)  # 绿色
BLUE = (0, 0, 255)  # 蓝色

# 方块大小
BLOCK_SIZE = 30

# 游戏窗口大小
WINDOW_WIDTH = 10 * BLOCK_SIZE
WINDOW_HEIGHT = 20 * BLOCK_SIZE

# 游戏区域大小
AREA_WIDTH = 10 * BLOCK_SIZE
AREA_HEIGHT = 20 * BLOCK_SIZE

# 游戏区域位置
AREA_POS_X = (WINDOW_WIDTH - AREA_WIDTH) // 2
AREA_POS_Y = WINDOW_HEIGHT - AREA_HEIGHT

# 方块类型及形状数据
BLOCK_DATA = [
    [
        [0, 1, 0],
        [0, 1, 0],
        [0, 1, 0],
        [0, 1, 0]
    ],  # I
    [
        [1, 1, 0],
        [0, 1, 1],
        [0, 0, 0]
    ],  # Z
    [
        [0, 1, 1],
        [1, 1, 0],
        [0, 0, 0]
    ],  # S
    [
        [1, 1],
        [1, 1]
    ],  # O
    [
        [1, 0, 0],
        [1, 1, 1],
        [0, 0, 0]
    ],  # J
    [
        [0, 0, 1],
        [1, 1, 1],
        [0, 0, 0]
    ],  # L
    [
        [0, 1, 0],
        [1, 1, 1],
        [0, 0, 0]
    ],  # T
]

# 方块颜色
BLOCK_COLOR = [
    GREEN,  # I
    RED,  # Z
    BLUE,  # S
    YELLOW,  # O
    PURPLE,  # J
    CYAN,  # L
    ORANGE  # T
]

# 随机生成一个方块
def new_block():
    block_type = random.randint(0, len(BLOCK_DATA) - 1)
    block_data = BLOCK_DATA[block_type]
    block_color = BLOCK_COLOR[block_type]
    return block_data, block_color

# 方块类
class Block:
    def __init__(self, block_data, block_color):
        self.block_data = block_data
        self.block_color = block_color
        self.x = 3
        self.y = 0

    # 顺时针旋转方块
    def rotate(self):
        self.block_data = list(zip(*self.block_data[::-1]))

    # 逆时针旋转方块
    def rotate_inverse(self):
        self.block_data = list(zip(*self.block_data))[::-1]

    # 移动方块
    def move(self, dx, dy):
        self.x += dx
        self.y += dy

    # 获取方块碰撞检测数据
    def get_collision_data(self):
        collision_data = []
        for i in range(len(self.block_data)):
            for j in range(len(self.block_data[i])):
                if self.block_data[i][j]:
                    collision_data.append((self.x + j, self.y + i))
        return collision_data

# 方块操作类
class BlockOperator:
    def __init__(self):
        self.block = Block(*new_block())

    # 获取方块碰撞检测数据
    def get_collision_data(self):
        return self.block.get_collision_data()

    # 移动方块
    def move(self, dx, dy):
        self.block.move(dx, dy)
        if self.check_collision():
            self.block.move(-dx, -dy)
            return False
        return True

    # 顺时针旋转方块
    def rotate(self):
        self.block.rotate()
        if self.check_collision():
            self.block.rotate_inverse()

    # 逆时针旋转方块
    def rotate_inverse(self):
        self.block.rotate_inverse()
        if self.check_collision():
            self.block.rotate()

    # 检测碰撞
    def check_collision(self):
        for x, y in self.get_collision_data():
            if x < 0 or x >= 10 or y >= 20:
                return True
            if y >= 0 and board[y][x]:
                return True
        return False

    # 将方块加入游戏区域并生成新的方块
    def add_to_board(self):
        for x, y in self.get_collision_data():
            board[y][x] = self.block.block_color
        self.block = Block(*new_block())

# 绘制游戏区域
def draw_board(screen):
    for y in range(20):
        for x in range(10):
            pygame.draw.rect(screen, board[y][x], (
                AREA_POS_X + x * BLOCK_SIZE,
                AREA_POS_Y + y * BLOCK_SIZE,
                BLOCK_SIZE, BLOCK_SIZE
            ))

# 绘制方块
def draw_block(screen, block):
    for y in range(len(block.block_data)):
        for x in range(len(block.block_data[y])):
            if block.block_data[y][x]:
                pygame.draw.rect(screen, block.block_color, (
                    AREA_POS_X + (block.x + x) * BLOCK_SIZE,
                    AREA_POS_Y + (block.y + y) * BLOCK_SIZE,
                    BLOCK_SIZE, BLOCK_SIZE
                ))

# 生成游戏区域
board = []
for y in range(20):
    board.append([BLACK for _ in range(10)])

# 游戏循环
screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
clock = pygame.time.Clock()
block_operator = BlockOperator()
game_over = False
while not game_over:
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over = True
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                block_operator.move(-1, 0)
            elif event.key == pygame.K_RIGHT:
                block_operator.move(1, 0)
            elif event.key == pygame.K_UP:
                block_operator.rotate()
            elif event.key == pygame.K_DOWN:
                block_operator.rotate_inverse()

    # 移动方块并检查是否碰撞
    if not block_operator.move(0, 1):
        block_operator.add_to_board()

    # 绘制游戏区域和方块
    screen.fill(WHITE)
    draw_board(screen)
    draw_block(screen, block_operator.block)

    # 刷新屏幕
    pygame.display.flip()

    # 控制帧率
    clock.tick(10)

# 退出游戏
pygame.quit()

希望能够帮到你！