Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· openaiHugging Face Suzhen/CodeChat

请你用python的pygame库写一个九宫格拼图游戏代码,要求拼图打乱后一定有解,且包含使用广度搜索实现自动复原的功能

  1. User

    请你用python的pygame库写一个九宫格拼图游戏代码,要求拼图打乱后一定有解,且包含使用广度搜索实现自动复原的功能

  2. Assistant

    以下是使用pygame库编写的九宫格拼图游戏代码,包含了打乱拼图和使用广度优先搜索自动复原的功能:

    import pygame
    import random
    from collections import deque
    
    # 设置窗口大小
    WINDOW_WIDTH = 400
    WINDOW_HEIGHT = 400
    # 设置拼图大小
    PUZZLE_SIZE = 3
    # 设置每个拼图块的大小
    BLOCK_SIZE = WINDOW_WIDTH // PUZZLE_SIZE
    
    # 定义颜色
    WHITE = (255, 255, 255)
    BLACK = (0, 0, 0)
    RED = (255, 0, 0)
    
    # 定义拼图数字和空白块的坐标
    puzzle_nums = [[(i, j) for i in range(PUZZLE_SIZE)] for j in range(PUZZLE_SIZE)]
    blank_block = (PUZZLE_SIZE - 1, PUZZLE_SIZE - 1)
    
    # 定义广度优先搜索的方向
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    
    # 初始化pygame
    pygame.init()
    # 创建窗口
    window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
    # 设置窗口标题
    pygame.display.set_caption("九宫格拼图游戏")
    
    
    def draw_puzzle():
        window.fill(WHITE)
        for i in range(PUZZLE_SIZE):
            for j in range(PUZZLE_SIZE):
                if puzzle_nums[i][j] != blank_block:
                    pygame.draw.rect(window, BLACK, (j * BLOCK_SIZE, i * BLOCK_SIZE,
                                                     BLOCK_SIZE, BLOCK_SIZE), 1)
                    text = pygame.font.SysFont(None, 50).render(
                        str(puzzle_nums[i][j][0] * PUZZLE_SIZE + puzzle_nums[i][j][1] + 1), True, BLACK)
                    window.blit(text, (j * BLOCK_SIZE + BLOCK_SIZE // 2 - text.get_width() // 2,
                                       i * BLOCK_SIZE + BLOCK_SIZE // 2 - text.get_height() // 2))
        pygame.display.update()
    
    
    def move_blank_block(direction):
        global blank_block
        blank_x, blank_y = blank_block
        dx, dy = direction
        new_blank_x = blank_x + dx
        new_blank_y = blank_y + dy
        if new_blank_x < 0 or new_blank_x >= PUZZLE_SIZE or new_blank_y < 0 or new_blank_y >= PUZZLE_SIZE:
            return
        puzzle_nums[blank_x][blank_y] = puzzle_nums[new_blank_x][new_blank_y]
        puzzle_nums[new_blank_x][new_blank_y] = blank_block
        blank_block = (new_blank_x, new_blank_y)
        draw_puzzle()
    
    
    def shuffle_puzzle():
        global blank_block
        for _ in range(1000):
            valid_moves = []
            for direction in directions:
                dx, dy = direction
                new_blank_x = blank_block[0] + dx
                new_blank_y = blank_block[1] + dy
                if new_blank_x >= 0 and new_blank_x < PUZZLE_SIZE and new_blank_y >= 0 and new_blank_y < PUZZLE_SIZE:
                    valid_moves.append(direction)
            move_blank_block(random.choice(valid_moves))
    
    
    def is_solved():
        num = 1
        for i in range(PUZZLE_SIZE):
            for j in range(PUZZLE_SIZE):
                if puzzle_nums[i][j] != (i, j):
                    if i == PUZZLE_SIZE - 1 and j == PUZZLE_SIZE - 1:
                        return True
                    else:
                        return False
                num += 1
        return True
    
    
    def solve_puzzle():
        visited = set()
        queue = deque()
        queue.append((puzzle_nums, blank_block, ""))
        while queue:
            current_puzzle, current_blank, current_path = queue.popleft()
            visited.add(str(current_puzzle))
            if is_solved():
                return current_path
            for direction in directions:
                dx, dy = direction
                new_blank_x = current_blank[0] + dx
                new_blank_y = current_blank[1] + dy
                if new_blank_x >= 0 and new_blank_x < PUZZLE_SIZE and new_blank_y >= 0 and new_blank_y < PUZZLE_SIZE:
                    new_puzzle = [row[:] for row in current_puzzle]
                    new_puzzle[current_blank[0]][current_blank[1]] = new_puzzle[new_blank_x][new_blank_y]
                    new_puzzle[new_blank_x][new_blank_y] = blank_block
                    if str(new_puzzle) not in visited:
                        queue.append((new_puzzle, (new_blank_x, new_blank_y), current_path + str(direction)))
    
        return "No solution found."
    
    
    # 打乱拼图
    shuffle_puzzle()
    # 绘制初始拼图
    draw_puzzle()
    
    # 游戏主循环
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_UP:
                    move_blank_block((0, -1))
                elif event.key == pygame.K_DOWN:
                    move_blank_block((0, 1))
                elif event.key == pygame.K_LEFT:
                    move_blank_block((-1, 0))
                elif event.key == pygame.K_RIGHT:
                    move_blank_block((1, 0))
                elif event.key == pygame.K_SPACE:
                    solution = solve_puzzle()
                    if solution != "No solution found.":
                        print("Solution path:", solution)
                        for direction in solution:
                            if direction == "(-1, 0)":
                                move_blank_block((-1, 0))
                            elif direction == "(1, 0)":
                                move_blank_block((1, 0))
                            elif direction == "(0, -1)":
                                move_blank_block((0, -1))
                            elif direction == "(0, 1)":
                                move_blank_block((0, 1))
                    else:
                        print("No solution found.")
    

    希望对你有所帮助!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.