请使用pygame库写一个连连看游戏的代码，两个相同方块的连接路径上没有其他方块阻碍即可相消

以下是一个简单的连连看游戏代码，使用了pygame库：

import pygame
import random

# 初始化 Pygame 库
pygame.init()

# 定义颜色常量
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (128, 128, 128)

# 定义窗口大小
WINDOW_SIZE = (800, 600)

# 创建游戏窗口
screen = pygame.display.set_mode(WINDOW_SIZE)

# 设置游戏窗口标题
pygame.display.set_caption("连连看")

# 加载方块图片
block_images = []
for i in range(1, 11):
    block_images.append(pygame.image.load("block{}.png".format(i)))

# 定义方块大小
BLOCK_SIZE = 50

# 定义方块间隔大小
BLOCK_GAP = 10

# 定义游戏板大小
BOARD_WIDTH = 16
BOARD_HEIGHT = 12

# 定义游戏板位置
BOARD_X = (WINDOW_SIZE[0] - BOARD_WIDTH * (BLOCK_SIZE + BLOCK_GAP)) // 2
BOARD_Y = (WINDOW_SIZE[1] - BOARD_HEIGHT * (BLOCK_SIZE + BLOCK_GAP)) // 2

# 创建游戏板数组
board = [[None] * BOARD_WIDTH for i in range(BOARD_HEIGHT)]

# 随机填充游戏板数组
for y in range(BOARD_HEIGHT):
    for x in range(BOARD_WIDTH):
        block_index = random.randint(0, 9)
        board[y][x] = block_index

# 定义选中方块的位置
selected_block = None

# 定义方块之间的路径数组
block_paths = []

# 定义游戏结束标志
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.MOUSEBUTTONDOWN:
            # 获取鼠标点击位置
            mouse_x, mouse_y = pygame.mouse.get_pos()
            
            # 判断点击位置是否在游戏板范围内
            if mouse_x >= BOARD_X and mouse_x < BOARD_X + BOARD_WIDTH * (BLOCK_SIZE + BLOCK_GAP) and \
               mouse_y >= BOARD_Y and mouse_y < BOARD_Y + BOARD_HEIGHT * (BLOCK_SIZE + BLOCK_GAP):
                
                # 计算点击位置所在的方块位置
                block_x = (mouse_x - BOARD_X) // (BLOCK_SIZE + BLOCK_GAP)
                block_y = (mouse_y - BOARD_Y) // (BLOCK_SIZE + BLOCK_GAP)
                
                # 判断点击的方块是否已被选中
                if selected_block is not None and selected_block[0] == block_x and selected_block[1] == block_y:
                    selected_block = None
                else:
                    # 如果没有选中方块，则选中当前方块
                    if selected_block is None:
                        selected_block = (block_x, block_y)
                    # 如果已有选中方块，则尝试连接两个方块
                    else:
                        # 判断两个方块是否相同
                        if board[selected_block[1]][selected_block[0]] == board[block_y][block_x]:
                            # 判断两个方块之间是否有路径
                            has_path = False
                            for path in block_paths:
                                if path[0][0] == selected_block[0] and path[0][1] == selected_block[1] and \
                                   path[-1][0] == block_x and path[-1][1] == block_y:
                                    has_path = True
                                    break
                            # 如果有路径，则消除两个方块
                            if has_path:
                                board[selected_block[1]][selected_block[0]] = None
                                board[block_y][block_x] = None
                                selected_block = None
                            # 如果没有路径，则取消选中当前方块，重新选中另一个方块
                            else:
                                selected_block = (block_x, block_y)
                        # 如果两个方块不相同，则重新选中当前方块
                        else:
                            selected_block = (block_x, block_y)
            
    # 绘制游戏窗口
    screen.fill(BLACK)
    
    # 绘制游戏板和方块
    for y in range(BOARD_HEIGHT):
        for x in range(BOARD_WIDTH):
            if board[y][x] is not None:
                block_image = block_images[board[y][x]]
                block_rect = block_image.get_rect()
                block_rect.x = BOARD_X + x * (BLOCK_SIZE + BLOCK_GAP)
                block_rect.y = BOARD_Y + y * (BLOCK_SIZE + BLOCK_GAP)
                screen.blit(block_image, block_rect)
    
    # 绘制选中方块的框框
    if selected_block is not None:
        block_rect = pygame.Rect(BOARD_X + selected_block[0] * (BLOCK_SIZE + BLOCK_GAP), \
                                 BOARD_Y + selected_block[1] * (BLOCK_SIZE + BLOCK_GAP), BLOCK_SIZE, BLOCK_SIZE)
        pygame.draw.rect(screen, WHITE, block_rect, 3)
    
    # 绘制方块之间的路径
    for path in block_paths:
        if len(path) > 1:
            path_rects = []
            for i in range(len(path) - 1):
                x1 = BOARD_X + path[i][0] * (BLOCK_SIZE + BLOCK_GAP) + BLOCK_SIZE // 2
                y1 = BOARD_Y + path[i][1] * (BLOCK_SIZE + BLOCK_GAP) + BLOCK_SIZE // 2
                x2 = BOARD_X + path[i+1][0] * (BLOCK_SIZE + BLOCK_GAP) + BLOCK_SIZE // 2
                y2 = BOARD_Y + path[i+1][1] * (BLOCK_SIZE + BLOCK_GAP) + BLOCK_SIZE // 2
                path_rect = pygame.draw.line(screen, WHITE, (x1, y1), (x2, y2), 5)
                path_rects.append(path_rect)
            path_rects.append(pygame.Rect(path_rects[0].x, path_rects[0].y, path_rects[-1].x - path_rects[0].x + 5, 5))
            pygame.draw.rect(screen, WHITE, path_rects[-1])
    
    # 判断是否有相邻的相同方块
    for y in range(BOARD_HEIGHT):
        for x in range(BOARD_WIDTH):
            if board[y][x] is not None:
                # 向上搜索相同方块
                for i in range(y-1, -1, -1):
                    if board[i][x] == board[y][x]:
                        # 判断路径是否被其他方块阻挡
                        blocked = False
                        for j in range(i+1, y):
                            if board[j][x] is not None:
                                blocked = True
                                break
                        if not blocked:
                            block_paths.append([(x, y), (x, i)])
                        break
                # 向下搜索相同方块
                for i in range(y+1, BOARD_HEIGHT):
                    if board[i][x] == board[y][x]:
                        # 判断路径是否被其他方块阻挡
                        blocked = False
                        for j in range(y+1, i):
                            if board[j][x] is not None:
                                blocked = True
                                break
                        if not blocked:
                            block_paths.append([(x, y), (x, i)])
                        break
                # 向左搜索相同方块
                for i in range(x-1, -1, -1):
                    if board[y][i] == board[y][x]:
                        # 判断路径是否被其他方块阻挡
                        blocked = False
                        for j in range(i+1, x):
                            if board[y][j] is not None:
                                blocked = True
                                break
                        if not blocked:
                            block_paths.append([(x, y), (i, y)])
                        break
                # 向右搜索相同方块
                for i in range(x+1, BOARD_WIDTH):
                    if board[y][i] == board[y][x]:
                        # 判断路径是否被其他方块阻挡
                        blocked = False
                        for j in range(x+1, i):
                            if board[y][j] is not None:
                                blocked = True
                                break
                        if not blocked:
                            block_paths.append([(x, y), (i, y)])
                        break
    
    # 刷新游戏窗口
    pygame.display.flip()

# 退出 Pygame 库
pygame.quit()