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

好的，以下是一个简单的俄罗斯方块游戏的代码，使用Python语言实现。

import pygame
import random

# 初始化pygame
pygame.init()

# 设置游戏窗口尺寸
WINDOW_WIDTH = 400
WINDOW_HEIGHT = 600
WINDOW_SIZE = (WINDOW_WIDTH, WINDOW_HEIGHT)

# 设置游戏区域尺寸
PLAY_AREA_WIDTH = 300
PLAY_AREA_HEIGHT = 600
PLAY_AREA_SIZE = (PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT)

# 设置方块大小
BLOCK_SIZE = 30

# 设置游戏区域的左上角坐标
PLAY_AREA_X = (WINDOW_WIDTH - PLAY_AREA_WIDTH) // 2
PLAY_AREA_Y = 0

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

# 定义方块类
class Block:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color

    def draw(self, surface):
        pygame.draw.rect(surface, self.color, (self.x, self.y, BLOCK_SIZE, BLOCK_SIZE))

# 定义俄罗斯方块游戏类
class Tetris:
    def __init__(self):
        self.screen = pygame.display.set_mode(WINDOW_SIZE)
        pygame.display.set_caption("Tetris")
        self.clock = pygame.time.Clock()
        self.play_area = pygame.Surface(PLAY_AREA_SIZE)
        self.block_list = []
        self.current_block = None
        self.next_block = None
        self.score = 0
        self.game_over = False

    # 初始化游戏
    def init_game(self):
        # 清空方块列表
        self.block_list = []
        # 生成当前方块和下一个方块
        self.current_block = self.generate_block()
        self.next_block = self.generate_block()
        # 设置游戏得分为0
        self.score = 0
        # 设置游戏结束为False
        self.game_over = False

    # 生成一个随机方块
    def generate_block(self):
        x = PLAY_AREA_X + PLAY_AREA_WIDTH // 2 - BLOCK_SIZE
        y = PLAY_AREA_Y
        color = random.choice(COLORS)
        shape = random.choice(['I', 'J', 'L', 'O', 'S', 'T', 'Z'])
        if shape == 'I':
            return self.generate_i_block(x, y, color)
        elif shape == 'J':
            return self.generate_j_block(x, y, color)
        elif shape == 'L':
            return self.generate_l_block(x, y, color)
        elif shape == 'O':
            return self.generate_o_block(x, y, color)
        elif shape == 'S':
            return self.generate_s_block(x, y, color)
        elif shape == 'T':
            return self.generate_t_block(x, y, color)
        elif shape == 'Z':
            return self.generate_z_block(x, y, color)

    # 生成I型方块
    def generate_i_block(self, x, y, color):
        block1 = Block(x, y, color)
        block2 = Block(x, y + BLOCK_SIZE, color)
        block3 = Block(x, y + 2 * BLOCK_SIZE, color)
        block4 = Block(x, y + 3 * BLOCK_SIZE, color)
        return [block1, block2, block3, block4]

    # 生成J型方块
    def generate_j_block(self, x, y, color):
        block1 = Block(x, y, color)
        block2 = Block(x, y + BLOCK_SIZE, color)
        block3 = Block(x, y + 2 * BLOCK_SIZE, color)
        block4 = Block(x + BLOCK_SIZE, y + 2 * BLOCK_SIZE, color)
        return [block1, block2, block3, block4]

    # 生成L型方块
    def generate_l_block(self, x, y, color):
        block1 = Block(x + BLOCK_SIZE, y, color)
        block2 = Block(x, y + BLOCK_SIZE, color)
        block3 = Block(x, y + 2 * BLOCK_SIZE, color)
        block4 = Block(x, y + 3 * BLOCK_SIZE, color)
        return [block1, block2, block3, block4]

    # 生成O型方块
    def generate_o_block(self, x, y, color):
        block1 = Block(x, y, color)
        block2 = Block(x + BLOCK_SIZE, y, color)
        block3 = Block(x, y + BLOCK_SIZE, color)
        block4 = Block(x + BLOCK_SIZE, y + BLOCK_SIZE, color)
        return [block1, block2, block3, block4]

    # 生成S型方块
    def generate_s_block(self, x, y, color):
        block1 = Block(x + BLOCK_SIZE, y, color)
        block2 = Block(x, y + BLOCK_SIZE, color)
        block3 = Block(x + BLOCK_SIZE, y + BLOCK_SIZE, color)
        block4 = Block(x, y + 2 * BLOCK_SIZE, color)
        return [block1, block2, block3, block4]

    # 生成T型方块
    def generate_t_block(self, x, y, color):
        block1 = Block(x, y, color)
        block2 = Block(x + BLOCK_SIZE, y, color)
        block3 = Block(x + BLOCK_SIZE, y + BLOCK_SIZE, color)
        block4 = Block(x + 2 * BLOCK_SIZE, y, color)
        return [block1, block2, block3, block4]

    # 生成Z型方块
    def generate_z_block(self, x, y, color):
        block1 = Block(x, y, color)
        block2 = Block(x + BLOCK_SIZE, y, color)
        block3 = Block(x + BLOCK_SIZE, y + BLOCK_SIZE, color)
        block4 = Block(x + 2 * BLOCK_SIZE, y + BLOCK_SIZE, color)
        return [block1, block2, block3, block4]

    # 绘制游戏区域
    def draw_play_area(self):
        self.play_area.fill((0, 0, 0))
        for block in self.block_list:
            block.draw(self.play_area)
        for block in self.current_block:
            block.draw(self.play_area)
        self.screen.blit(self.play_area, (PLAY_AREA_X, PLAY_AREA_Y))

    # 移动方块
    def move_block(self, dx, dy):
        for block in self.current_block:
            block.x += dx
            block.y += dy

    # 旋转方块
    def rotate_block(self):
        x = self.current_block[0].x
        y = self.current_block[0].y
        new_block = []
        for block in self.current_block:
            new_x = x + y - block.y
            new_y = y + block.x - x
            new_block.append(Block(new_x, new_y, block.color))
        if self.check_collision(new_block):
            return
        self.current_block = new_block

    # 检查方块是否和已有方块重叠
    def check_collision(self, block):
        for b in block:
            if b.x < PLAY_AREA_X or b.x >= PLAY_AREA_X + PLAY_AREA_WIDTH:
                return True
            if b.y < PLAY_AREA_Y or b.y >= PLAY_AREA_Y + PLAY_AREA_HEIGHT:
                return True
            for bb in self.block_list:
                if b.x == bb.x and b.y == bb.y:
                    return True
        return False

    # 将当前方块加入已有方块列表中
    def add_block_to_list(self):
        for block in self.current_block:
            self.block_list.append(block)

    # 消除已有方块行
    def remove_lines(self):
        lines = {}
        for block in self.block_list:
            line = block.y // BLOCK_SIZE
            if line in lines:
                lines[line] += 1
            else:
                lines[line] = 1
        for line, count in lines.items():
            if count == PLAY_AREA_WIDTH // BLOCK_SIZE:
                self.score += 100
                for block in self.block_list:
                    if block.y // BLOCK_SIZE == line:
                        self.block_list.remove(block)
                        for b in self.block_list:
                            if b.y < block.y:
                                b.y += BLOCK_SIZE
        lines_cleared = len(lines)
        if lines_cleared > 0:
            self.score += lines_cleared * 10

    # 检查游戏是否结束
    def check_game_over(self):
        for block in self.block_list:
            if block.y <= PLAY_AREA_Y:
                self.game_over = True
                return

    # 运行游戏
    def run(self):
        # 初始化游戏
        self.init_game()

        # 设置游戏循环
        while True:
            # 处理游戏事件
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    quit()
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        self.move_block(-BLOCK_SIZE, 0)
                    elif event.key == pygame.K_RIGHT:
                        self.move_block(BLOCK_SIZE, 0)
                    elif event.key == pygame.K_DOWN:
                        self.move_block(0, BLOCK_SIZE)
                    elif event.key == pygame.K_UP:
                        self.rotate_block()

            # 更新游戏状态
            self.move_block(0, BLOCK_SIZE)
            if self.check_collision(self.current_block):
                self.move_block(0, -BLOCK_SIZE)
                self.add_block_to_list()
                self.remove_lines()
                self.check_game_over()
                self.current_block = self.next_block
                self.next_block = self.generate_block()

            # 绘制游戏界面
            self.screen.fill((0, 0, 0))
            self.draw_play_area()
            pygame.display.update()

            # 设置游戏帧率
            self.clock.tick(10)

# 创建游戏对象并运行游戏
tetris = Tetris()
tetris.run()

这只是一个简单的实现，如果需要完整的俄罗斯方块游戏，还需要添加更多的功能，比如计分、等级、音效等等。