import pygame
import sys
import random
import time
from collections import deque

# 初始化pygame
pygame.init()

# 游戏窗口设置
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("迷宫游戏 - 修复版")
clock = pygame.time.Clock()
FPS = 60

# 颜色定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
WALL = (50, 50, 100)
PATH = (240, 240, 240)
START = (0, 255, 0)
END = (255, 0, 0)
PLAYER = (255, 200, 0)
SOLUTION = (255, 105, 180)
BUTTON = (70, 130, 180)
BUTTON_HOVER = (100, 160, 210)

# 安全的字体加载函数


def load_font(size):
    """安全地加载字体，避免系统字体问题"""
    try:
        # 首先尝试使用默认字体
        return pygame.font.Font(None, size)
    except:
        # 如果失败，尝试创建最小的字体对象
        print(f"注意：使用基本字体，大小{size}")
        return pygame.font.Font(None, size)


# 加载字体
font = load_font(24)
font_large = load_font(36)

# 迷宫类


class Maze:
    def __init__(self, width=15, height=15):
        self.width = width
        self.height = height
        self.cell_size = 30
        self.grid = []
        self.start = (1, 1)
        self.end = (width-2, height-2)
        self.generate()

    def generate(self):
        # 创建网格
        self.grid = [[1 for _ in range(self.width)]
                     for _ in range(self.height)]

        # 使用递归回溯算法
        stack = [self.start]
        visited = set([self.start])
        self.grid[self.start[1]][self.start[0]] = 0
        self.grid[self.end[1]][self.end[0]] = 0

        while stack:
            x, y = stack[-1]
            neighbors = []

            # 检查四个方向的邻居
            directions = [(0, -2), (0, 2), (-2, 0), (2, 0)]
            for dx, dy in directions:
                nx, ny = x + dx, y + dy
                if 0 < nx < self.width-1 and 0 < ny < self.height-1:
                    if (nx, ny) not in visited:
                        neighbors.append((nx, ny, dx//2, dy//2))

            if neighbors:
                nx, ny, dx, dy = random.choice(neighbors)
                # 打通墙壁
                self.grid[y + dy][x + dx] = 0
                self.grid[ny][nx] = 0
                visited.add((nx, ny))
                stack.append((nx, ny))
            else:
                stack.pop()

    def draw(self, surface, offset_x, offset_y):
        for y in range(self.height):
            for x in range(self.width):
                rect = pygame.Rect(
                    offset_x + x * self.cell_size,
                    offset_y + y * self.cell_size,
                    self.cell_size, self.cell_size
                )

                if (x, y) == self.start:
                    pygame.draw.rect(surface, START, rect)
                elif (x, y) == self.end:
                    pygame.draw.rect(surface, END, rect)
                elif self.grid[y][x] == 1:
                    pygame.draw.rect(surface, WALL, rect)
                else:
                    pygame.draw.rect(surface, PATH, rect)

                # 绘制边框
                pygame.draw.rect(surface, BLACK, rect, 1)

# 玩家类


class Player:
    def __init__(self, maze, offset_x, offset_y):
        self.x, self.y = maze.start
        self.maze = maze
        self.offset_x = offset_x
        self.offset_y = offset_y
        self.radius = maze.cell_size // 2 - 2
        self.moves = 0

    def move(self, dx, dy):
        new_x, new_y = self.x + dx, self.y + dy

        if 0 <= new_x < self.maze.width and 0 <= new_y < self.maze.height:
            if self.maze.grid[new_y][new_x] == 0:
                self.x, self.y = new_x, new_y
                self.moves += 1
                return True
        return False

    def draw(self, surface):
        x = self.offset_x + self.x * self.maze.cell_size + self.maze.cell_size // 2
        y = self.offset_y + self.y * self.maze.cell_size + self.maze.cell_size // 2

        pygame.draw.circle(surface, PLAYER, (x, y), self.radius)

        # 简单的眼睛
        eye_radius = self.radius // 3
        pygame.draw.circle(surface, WHITE, (x - eye_radius,
                           y - eye_radius), eye_radius)
        pygame.draw.circle(surface, WHITE, (x + eye_radius,
                           y - eye_radius), eye_radius)

    def is_at_end(self):
        return (self.x, self.y) == self.maze.end

# 主游戏函数


def main():
    maze = Maze(15, 15)
    offset_x = (WIDTH - maze.width * maze.cell_size) // 2
    offset_y = (HEIGHT - maze.height * maze.cell_size) // 2

    player = Player(maze, offset_x, offset_y)
    start_time = time.time()

    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_ESCAPE:
                    running = False
                elif event.key in [pygame.K_UP, pygame.K_w]:
                    player.move(0, -1)
                elif event.key in [pygame.K_DOWN, pygame.K_s]:
                    player.move(0, 1)
                elif event.key in [pygame.K_LEFT, pygame.K_a]:
                    player.move(-1, 0)
                elif event.key in [pygame.K_RIGHT, pygame.K_d]:
                    player.move(1, 0)
                elif event.key == pygame.K_r:  # 重新开始
                    maze = Maze(15, 15)
                    player = Player(maze, offset_x, offset_y)
                    start_time = time.time()

        # 检查是否完成
        if player.is_at_end():
            elapsed = int(time.time() - start_time)

            # 绘制完成画面
            screen.fill(BLACK)
            complete_text = font_large.render("恭喜通关！", True, (255, 215, 0))
            stats_text = font.render(
                f"移动: {player.moves}步, 时间: {elapsed}秒", True, WHITE)

            screen.blit(complete_text, (WIDTH//2 -
                        complete_text.get_width()//2, 200))
            screen.blit(
                stats_text, (WIDTH//2 - stats_text.get_width()//2, 260))

            restart_text = font.render("按R重新开始，按ESC退出", True, WHITE)
            screen.blit(restart_text, (WIDTH//2 -
                        restart_text.get_width()//2, 320))

            pygame.display.flip()
            continue

        # 绘制游戏
        screen.fill((20, 20, 40))

        # 绘制迷宫
        maze.draw(screen, offset_x, offset_y)

        # 绘制玩家
        player.draw(screen)

        # 绘制信息
        elapsed = int(time.time() - start_time)
        info_text = font.render(
            f"移动: {player.moves}  时间: {elapsed}秒", True, WHITE)
        screen.blit(info_text, (20, 20))

        help_text = font.render("方向键/WASD移动 | R重新开始 | ESC退出", True, WHITE)
        screen.blit(
            help_text, (WIDTH//2 - help_text.get_width()//2, HEIGHT - 40))

        pygame.display.flip()
        clock.tick(FPS)

    pygame.quit()
    sys.exit()


if __name__ == "__main__":
    main()