import tkinter as tk
import random
import time
import math
from PIL import Image, ImageTk
import os
import sys

class ParkourGame:
    def __init__(self, root):
        self.root = root
        self.root.title("跑酷大冒险")
        self.root.geometry("1000x600")
        self.root.resizable(False, False)
        
        # 游戏状态
        self.game_running = False
        self.score = 0
        self.high_score = 0
        self.level = 1
        self.lives = 3
        self.game_speed = 8
        self.jump_force = 18
        self.gravity = 0.8
        
        # 玩家属性
        self.player_x = 150
        self.player_y = 350
        self.player_width = 40
        self.player_height = 60
        self.player_velocity_y = 0
        self.player_jumping = False
        self.player_ducking = False
        self.player_invincible = False
        self.invincible_timer = 0
        
        # 游戏元素
        self.platforms = []
        self.obstacles = []
        self.coins = []
        self.powerups = []
        self.projectiles = []
        
        # 按键状态
        self.keys_pressed = {'Left': False, 'Right': False, 'Up': False, 'Down': False}
        
        # 游戏控制
        self.last_time = time.time()
        self.game_start_time = 0
        
        # 创建游戏目录
        self.create_game_directories()
        
        # 加载资源
        self.load_resources()
        
        # 初始化游戏界面
        self.setup_ui()
        
        # 绑定按键事件
        self.bind_events()
        
        # 加载最高分
        self.load_high_score()
        
        # 显示开始菜单
        self.show_start_menu()
    
    def create_game_directories(self):
        """创建游戏资源目录"""
        if not os.path.exists("game_assets"):
            os.makedirs("game_assets")
    
    def load_resources(self):
        """加载游戏资源（如果图片不存在则创建颜色块）"""
        try:
            # 尝试加载玩家图片
            self.create_player_image()
        except:
            # 如果图片加载失败，使用颜色
            self.player_color = "#FF6B6B"
        
        # 障碍物颜色
        self.obstacle_colors = ["#FF5252", "#FF4081", "#E040FB", "#7C4DFF", 
                               "#536DFE", "#448AFF", "#40C4FF", "#18FFFF"]
        
        # 平台颜色
        self.platform_color = "#8BC34A"
        
        # 金币颜色
        self.coin_color = "#FFD700"
        
        # 道具颜色
        self.powerup_colors = {
            "speed": "#4CAF50",
            "jump": "#2196F3", 
            "shield": "#FF9800",
            "coin_magnet": "#9C27B0"
        }
    
    def create_player_image(self):
        """创建玩家图片（如果文件不存在）"""
        player_img_path = "game_assets/player.png"
        
        # 如果没有图片文件，创建一个简单的玩家图形
        if not os.path.exists(player_img_path):
            from PIL import Image, ImageDraw
            
            img = Image.new('RGBA', (60, 80), (255, 255, 255, 0))
            draw = ImageDraw.Draw(img)
            
            # 身体
            draw.rectangle([10, 20, 50, 60], fill=(255, 107, 107, 255))
            
            # 头
            draw.ellipse([20, 0, 40, 20], fill=(255, 224, 178, 255))
            
            # 眼睛
            draw.ellipse([25, 7, 28, 10], fill=(0, 0, 0, 255))
            draw.ellipse([32, 7, 35, 10], fill=(0, 0, 0, 255))
            
            # 手臂
            draw.rectangle([5, 25, 10, 40], fill=(255, 107, 107, 255))
            draw.rectangle([50, 25, 55, 40], fill=(255, 107, 107, 255))
            
            # 腿
            draw.rectangle([20, 60, 30, 75], fill=(30, 30, 30, 255))
            draw.rectangle([30, 60, 40, 75], fill=(30, 30, 30, 255))
            
            img.save(player_img_path)
        
        # 加载图片
        self.player_img = ImageTk.PhotoImage(Image.open(player_img_path).resize((40, 60)))
    
    def setup_ui(self):
        """设置游戏界面"""
        # 主画布
        self.canvas = tk.Canvas(
            self.root, 
            width=1000, 
            height=600,
            bg='#87CEEB',
            highlightthickness=0
        )
        self.canvas.pack()
        
        # 绘制背景
        self.draw_background()
        
        # 游戏信息显示
        self.score_text = self.canvas.create_text(
            50, 20,
            text=f"分数: {self.score}",
            font=("Arial", 16, "bold"),
            fill="white",
            anchor="w"
        )
        
        self.high_score_text = self.canvas.create_text(
            250, 20,
            text=f"最高分: {self.high_score}",
            font=("Arial", 16, "bold"),
            fill="#FFD700",
            anchor="w"
        )
        
        self.level_text = self.canvas.create_text(
            450, 20,
            text=f"关卡: {self.level}",
            font=("Arial", 16, "bold"),
            fill="#4CAF50",
            anchor="w"
        )
        
        self.lives_text = self.canvas.create_text(
            550, 20,
            text=f"生命: {self.lives}",
            font=("Arial", 16, "bold"),
            fill="#FF5252",
            anchor="w"
        )
        
        self.speed_text = self.canvas.create_text(
            650, 20,
            text=f"速度: {self.game_speed}",
            font=("Arial", 16, "bold"),
            fill="#2196F3",
            anchor="w"
        )
        
        # 游戏控制说明
        self.controls_text = self.canvas.create_text(
            850, 20,
            text="控制: ↑↓←→ 空格",
            font=("Arial", 12),
            fill="white",
            anchor="w"
        )
        
        # 玩家角色
        self.player = self.canvas.create_rectangle(
            self.player_x, self.player_y,
            self.player_x + self.player_width, 
            self.player_y + self.player_height,
            fill="#FF6B6B",
            outline="black",
            width=2
        )
        
        # 添加眼睛（让玩家更有生气）
        self.player_eye_left = self.canvas.create_oval(
            self.player_x + 10, self.player_y + 15,
            self.player_x + 15, self.player_y + 20,
            fill="white"
        )
        
        self.player_eye_right = self.canvas.create_oval(
            self.player_x + 25, self.player_y + 15,
            self.player_x + 30, self.player_y + 20,
            fill="white"
        )
        
        # 游戏消息显示
        self.message_text = self.canvas.create_text(
            500, 300,
            text="",
            font=("Arial", 24, "bold"),
            fill="white",
            anchor="center"
        )
    
    def draw_background(self):
        """绘制游戏背景"""
        # 天空
        self.canvas.create_rectangle(0, 0, 1000, 400, fill='#87CEEB', outline='')
        
        # 地面
        self.canvas.create_rectangle(0, 400, 1000, 600, fill='#8BC34A', outline='')
        
        # 云朵
        for i in range(5):
            x = (i * 200 + 50) % 1000
            y = 100 + (i * 20) % 100
            self.canvas.create_oval(x, y, x + 80, y + 40, fill='white', outline='')
            self.canvas.create_oval(x + 30, y - 10, x + 110, y + 30, fill='white', outline='')
            self.canvas.create_oval(x + 60, y, x + 140, y + 40, fill='white', outline='')
        
        # 远处山脉
        for i in range(3):
            x = i * 350
            points = [
                x, 400,
                x + 100, 300,
                x + 200, 350,
                x + 300, 400
            ]
            self.canvas.create_polygon(points, fill='#78909C', outline='#546E7A', width=2)
        
        # 太阳
        self.canvas.create_oval(800, 50, 900, 150, fill='#FFEB3B', outline='')
    
    def show_start_menu(self):
        """显示开始菜单"""
        self.game_running = False
        
        # 清空画布
        self.canvas.delete("all")
        self.draw_background()
        
        # 游戏标题
        self.canvas.create_text(
            500, 150,
            text="跑酷大冒险",
            font=("Arial", 48, "bold"),
            fill="white",
            anchor="center"
        )
        
        # 游戏说明
        instructions = [
            "游戏控制:",
            "← → : 左右移动",
            "↑ 或 空格 : 跳跃",
            "↓ : 下蹲/滑行",
            "R : 重新开始",
            "P : 暂停/继续",
            "ESC : 退出游戏"
        ]
        
        for i, text in enumerate(instructions):
            self.canvas.create_text(
                500, 220 + i * 30,
                text=text,
                font=("Arial", 16),
                fill="white",
                anchor="center"
            )
        
        # 难度选择
        self.canvas.create_text(
            500, 400,
            text="选择难度:",
            font=("Arial", 20, "bold"),
            fill="white",
            anchor="center"
        )
        
        # 难度按钮
        button_y = 440
        difficulties = [
            ("简单", "#4CAF50", 5),
            ("中等", "#FF9800", 8),
            ("困难", "#F44336", 12)
        ]
        
        for i, (text, color, speed) in enumerate(difficulties):
            btn = tk.Button(
                self.root,
                text=text,
                font=("Arial", 16, "bold"),
                bg=color,
                fg="white",
                width=10,
                command=lambda s=speed: self.start_game(s)
            )
            self.canvas.create_window(350 + i * 150, button_y, window=btn)
        
        # 显示最高分
        self.canvas.create_text(
            500, 500,
            text=f"最高分: {self.high_score}",
            font=("Arial", 20, "bold"),
            fill="#FFD700",
            anchor="center"
        )
    
    def start_game(self, speed):
        """开始游戏"""
        self.game_running = True
        self.game_speed = speed
        self.score = 0
        self.level = 1
        self.lives = 3
        self.player_x = 150
        self.player_y = 350
        self.player_velocity_y = 0
        self.player_jumping = False
        self.player_ducking = False
        
        # 清空游戏元素
        self.platforms.clear()
        self.obstacles.clear()
        self.coins.clear()
        self.powerups.clear()
        self.projectiles.clear()
        
        # 生成初始平台
        self.generate_initial_platforms()
        
        # 重置画布
        self.canvas.delete("all")
        self.draw_background()
        
        # 重绘UI元素
        self.score_text = self.canvas.create_text(
            50, 20,
            text=f"分数: {self.score}",
            font=("Arial", 16, "bold"),
            fill="white",
            anchor="w"
        )
        
        self.high_score_text = self.canvas.create_text(
            250, 20,
            text=f"最高分: {self.high_score}",
            font=("Arial", 16, "bold"),
            fill="#FFD700",
            anchor="w"
        )
        
        self.level_text = self.canvas.create_text(
            450, 20,
            text=f"关卡: {self.level}",
            font=("Arial", 16, "bold"),
            fill="#4CAF50",
            anchor="w"
        )
        
        self.lives_text = self.canvas.create_text(
            550, 20,
            text=f"生命: {self.lives}",
            font=("Arial", 16, "bold"),
            fill="#FF5252",
            anchor="w"
        )
        
        self.speed_text = self.canvas.create_text(
            650, 20,
            text=f"速度: {self.game_speed}",
            font=("Arial", 16, "bold"),
            fill="#2196F3",
            anchor="w"
        )
        
        self.controls_text = self.canvas.create_text(
            850, 20,
            text="控制: ↑↓←→ 空格",
            font=("Arial", 12),
            fill="white",
            anchor="w"
        )
        
        # 重绘玩家
        self.player = self.canvas.create_rectangle(
            self.player_x, self.player_y,
            self.player_x + self.player_width, 
            self.player_y + self.player_height,
            fill="#FF6B6B",
            outline="black",
            width=2
        )
        
        self.player_eye_left = self.canvas.create_oval(
            self.player_x + 10, self.player_y + 15,
            self.player_x + 15, self.player_y + 20,
            fill="white"
        )
        
        self.player_eye_right = self.canvas.create_oval(
            self.player_x + 25, self.player_y + 15,
            self.player_x + 30, self.player_y + 20,
            fill="white"
        )
        
        self.message_text = self.canvas.create_text(
            500, 300,
            text="",
            font=("Arial", 24, "bold"),
            fill="white",
            anchor="center"
        )
        
        # 显示关卡开始信息
        self.show_message(f"第 {self.level} 关", 1000)
        
        # 开始游戏循环
        self.game_loop()
    
    def generate_initial_platforms(self):
        """生成初始平台"""
        # 起始平台
        self.platforms.append({
            'x': 0,
            'y': 450,
            'width': 200,
            'height': 20
        })
        
        # 生成一些连续的平台
        last_x = 200
        for i in range(10):
            platform_width = random.randint(100, 200)
            platform_y = 450 - random.randint(0, 100)
            
            self.platforms.append({
                'x': last_x + random.randint(50, 100),
                'y': platform_y,
                'width': platform_width,
                'height': 20
            })
            
            last_x += platform_width + random.randint(50, 100)
    
    def bind_events(self):
        """绑定键盘事件"""
        self.root.bind('<KeyPress>', self.key_press)
        self.root.bind('<KeyRelease>', self.key_release)
        self.root.bind('<Escape>', lambda e: self.root.quit())
        self.root.bind('<p>', lambda e: self.toggle_pause())
        self.root.bind('<r>', lambda e: self.restart_game())
        self.root.bind('<space>', lambda e: self.jump())
    
    def key_press(self, event):
        """按键按下事件"""
        if event.keysym in self.keys_pressed:
            self.keys_pressed[event.keysym] = True
    
    def key_release(self, event):
        """按键释放事件"""
        if event.keysym in self.keys_pressed:
            self.keys_pressed[event.keysym] = False
            
            # 处理下蹲结束
            if event.keysym == 'Down':
                self.player_ducking = False
                self.player_height = 60
                self.canvas.coords(self.player, 
                    self.player_x, self.player_y,
                    self.player_x + self.player_width, 
                    self.player_y + self.player_height
                )
    
    def jump(self):
        """跳跃"""
        if not self.player_jumping and self.game_running:
            self.player_velocity_y = -self.jump_force
            self.player_jumping = True
    
    def toggle_pause(self):
        """暂停/继续游戏"""
        if self.game_running:
            self.game_running = False
            self.show_message("游戏暂停", 0)
        else:
            self.game_running = True
            self.canvas.itemconfig(self.message_text, text="")
            self.game_loop()
    
    def restart_game(self):
        """重新开始游戏"""
        self.show_start_menu()
    
    def game_loop(self):
        """游戏主循环"""
        if not self.game_running:
            return
        
        current_time = time.time()
        delta_time = current_time - self.last_time
        self.last_time = current_time
        
        # 处理玩家输入
        self.handle_input(delta_time)
        
        # 更新游戏状态
        self.update_physics(delta_time)
        
        # 生成游戏元素
        self.generate_elements()
        
        # 更新游戏元素
        self.update_elements(delta_time)
        
        # 检测碰撞
        self.check_collisions()
        
        # 更新显示
        self.update_display()
        
        # 检查游戏结束
        if self.lives <= 0:
            self.game_over()
            return
        
        # 检查关卡完成
        if self.score >= self.level * 1000:
            self.level_up()
        
        # 继续游戏循环
        self.root.after(16, self.game_loop)  # 约60FPS
    
    def handle_input(self, delta_time):
        """处理玩家输入"""
        move_speed = 5
        
        if self.keys_pressed['Left']:
            self.player_x = max(0, self.player_x - move_speed)
        
        if self.keys_pressed['Right']:
            self.player_x = min(1000 - self.player_width, self.player_x + move_speed)
        
        if self.keys_pressed['Up']:
            self.jump()
        
        if self.keys_pressed['Down'] and not self.player_jumping:
            self.player_ducking = True
            self.player_height = 30
            self.canvas.coords(self.player, 
                self.player_x, self.player_y + 30,
                self.player_x + self.player_width, 
                self.player_y + 30 + self.player_height
            )
    
    def update_physics(self, delta_time):
        """更新物理"""
        # 应用重力
        self.player_velocity_y += self.gravity
        self.player_y += self.player_velocity_y
        
        # 地面碰撞检测
        if self.player_y > 400 - self.player_height:
            self.player_y = 400 - self.player_height
            self.player_velocity_y = 0
            self.player_jumping = False
        
        # 平台碰撞检测
        for platform in self.platforms:
            if (self.player_x < platform['x'] + platform['width'] and
                self.player_x + self.player_width > platform['x'] and
                self.player_y + self.player_height > platform['y'] and
                self.player_y + self.player_height < platform['y'] + 20 and
                self.player_velocity_y > 0):
                
                self.player_y = platform['y'] - self.player_height
                self.player_velocity_y = 0
                self.player_jumping = False
        
        # 屏幕边界检查
        if self.player_y > 600:
            self.player_y = 350
            self.player_x = 150
            self.lose_life()
    
    def generate_elements(self):
        """生成游戏元素"""
        # 生成平台
        if len(self.platforms) < 15:
            last_platform = self.platforms[-1]
            if last_platform['x'] + last_platform['width'] < 1200:
                platform_width = random.randint(100, 200)
                platform_y = 450 - random.randint(0, 150)
                
                self.platforms.append({
                    'x': last_platform['x'] + last_platform['width'] + random.randint(50, 150),
                    'y': platform_y,
                    'width': platform_width,
                    'height': 20
                })
        
        # 生成障碍物
        if random.random() < 0.02:  # 2%的几率每帧
            obstacle_types = ['spike', 'block', 'moving']
            obstacle_type = random.choice(obstacle_types)
            
            obstacle_x = 1000
            obstacle_y = 400 - random.randint(20, 60)
            obstacle_width = random.randint(30, 60)
            obstacle_height = random.randint(40, 80)
            
            if obstacle_type == 'spike':
                obstacle_height = 40
                obstacle_width = 20
            
            obstacle = {
                'x': obstacle_x,
                'y': obstacle_y,
                'width': obstacle_width,
                'height': obstacle_height,
                'type': obstacle_type,
                'color': random.choice(self.obstacle_colors),
                'velocity_x': -self.game_speed - random.randint(0, 3)
            }
            
            if obstacle_type == 'moving':
                obstacle['velocity_y'] = random.choice([-2, 2])
            
            self.obstacles.append(obstacle)
        
        # 生成金币
        if random.random() < 0.03:  # 3%的几率每帧
            self.coins.append({
                'x': 1000,
                'y': random.randint(200, 350),
                'radius': 10,
                'value': 10
            })
        
        # 生成道具
        if random.random() < 0.005:  # 0.5%的几率每帧
            powerup_types = ['speed', 'jump', 'shield', 'coin_magnet']
            powerup_type = random.choice(powerup_types)
            
            self.powerups.append({
                'x': 1000,
                'y': random.randint(200, 350),
                'radius': 15,
                'type': powerup_type,
                'color': self.powerup_colors[powerup_type]
            })
    
    def update_elements(self, delta_time):
        """更新游戏元素"""
        # 移除屏幕外的元素
        self.platforms = [p for p in self.platforms if p['x'] + p['width'] > -100]
        self.obstacles = [o for o in self.obstacles if o['x'] + o['width'] > -100]
        self.coins = [c for c in self.coins if c['x'] + c['radius'] > -100]
        self.powerups = [p for p in self.powerups if p['x'] + p['radius'] > -100]
        
        # 更新障碍物位置
        for obstacle in self.obstacles:
            obstacle['x'] += obstacle['velocity_x']
            
            if obstacle['type'] == 'moving':
                obstacle['y'] += obstacle.get('velocity_y', 0)
                
                # 边界检查
                if obstacle['y'] < 200:
                    obstacle['y'] = 200
                    obstacle['velocity_y'] *= -1
                elif obstacle['y'] > 380:
                    obstacle['y'] = 380
                    obstacle['velocity_y'] *= -1
        
        # 更新金币位置
        for coin in self.coins:
            coin['x'] -= self.game_speed
        
        # 更新道具位置
        for powerup in self.powerups:
            powerup['x'] -= self.game_speed
    
    def check_collisions(self):
        """检测碰撞"""
        # 检测障碍物碰撞
        for obstacle in self.obstacles[:]:
            if (self.player_x < obstacle['x'] + obstacle['width'] and
                self.player_x + self.player_width > obstacle['x'] and
                self.player_y < obstacle['y'] + obstacle['height'] and
                self.player_y + self.player_height > obstacle['y']):
                
                if not self.player_invincible:
                    self.lose_life()
                    self.player_invincible = True
                    self.invincible_timer = 60  # 1秒无敌时间
                    
                    # 击退效果
                    self.player_velocity_y = -5
                    self.player_x -= 50
                
                break
        
        # 检测金币碰撞
        for coin in self.coins[:]:
            dx = (self.player_x + self.player_width/2) - coin['x']
            dy = (self.player_y + self.player_height/2) - coin['y']
            distance = math.sqrt(dx*dx + dy*dy)
            
            if distance < self.player_width/2 + coin['radius']:
                self.score += coin['value']
                self.coins.remove(coin)
                self.show_message(f"+{coin['value']}", 30, coin['x'], coin['y'])
        
        # 检测道具碰撞
        for powerup in self.powerups[:]:
            dx = (self.player_x + self.player_width/2) - powerup['x']
            dy = (self.player_y + self.player_height/2) - powerup['y']
            distance = math.sqrt(dx*dx + dy*dy)
            
            if distance < self.player_width/2 + powerup['radius']:
                self.apply_powerup(powerup['type'])
                self.powerups.remove(powerup)
                self.show_message(f"获得: {powerup['type']}", 60, powerup['x'], powerup['y'])
        
        # 更新无敌时间
        if self.player_invincible:
            self.invincible_timer -= 1
            if self.invincible_timer <= 0:
                self.player_invincible = False
    
    def apply_powerup(self, powerup_type):
        """应用道具效果"""
        if powerup_type == 'speed':
            self.game_speed += 2
            self.show_message("速度提升!", 60)
        elif powerup_type == 'jump':
            self.jump_force += 3
            self.show_message("跳跃力提升!", 60)
        elif powerup_type == 'shield':
            self.player_invincible = True
            self.invincible_timer = 180  # 3秒无敌
            self.show_message("无敌护盾!", 60)
        elif powerup_type == 'coin_magnet':
            # 自动吸引附近金币
            for coin in self.coins[:]:
                if abs(coin['x'] - self.player_x) < 200:
                    coin['x'] -= 10  # 向玩家移动
    
    def lose_life(self):
        """失去生命"""
        self.lives -= 1
        self.show_message(f"生命值: {self.lives}", 60)
        
        if self.lives > 0:
            # 重生保护
            self.player_invincible = True
            self.invincible_timer = 120  # 2秒无敌
    
    def level_up(self):
        """升级关卡"""
        self.level += 1
        self.game_speed += 1
        
        # 重置玩家位置
        self.player_x = 150
        self.player_y = 350
        
        # 清空大部分元素
        self.obstacles.clear()
        self.coins.clear()
        self.powerups.clear()
        
        # 生成新平台
        self.generate_initial_platforms()
        
        self.show_message(f"第 {self.level} 关!", 120)
    
    def update_display(self):
        """更新显示"""
        # 更新UI文本
        self.canvas.itemconfig(self.score_text, text=f"分数: {self.score}")
        self.canvas.itemconfig(self.level_text, text=f"关卡: {self.level}")
        self.canvas.itemconfig(self.lives_text, text=f"生命: {self.lives}")
        self.canvas.itemconfig(self.speed_text, text=f"速度: {self.game_speed}")
        
        # 更新玩家位置
        player_color = "#FF6B6B" if not self.player_invincible or time.time() % 0.2 < 0.1 else "#FFFFFF"
        self.canvas.itemconfig(self.player, fill=player_color)
        
        self.canvas.coords(self.player, 
            self.player_x, self.player_y,
            self.player_x + self.player_width, 
            self.player_y + self.player_height
        )
        
        # 更新玩家眼睛
        self.canvas.coords(self.player_eye_left,
            self.player_x + 10, self.player_y + 15,
            self.player_x + 15, self.player_y + 20
        )
        
        self.canvas.coords(self.player_eye_right,
            self.player_x + 25, self.player_y + 15,
            self.player_x + 30, self.player_y + 20
        )
        
        # 清空并重绘所有元素
        self.canvas.delete("platform")
        self.canvas.delete("obstacle")
        self.canvas.delete("coin")
        self.canvas.delete("powerup")
        
        # 绘制平台
        for platform in self.platforms:
            self.canvas.create_rectangle(
                platform['x'], platform['y'],
                platform['x'] + platform['width'], 
                platform['y'] + platform['height'],
                fill=self.platform_color,
                outline="#689F38",
                width=2,
                tags="platform"
            )
        
        # 绘制障碍物
        for obstacle in self.obstacles:
            if obstacle['type'] == 'spike':
                # 绘制尖刺
                points = [
                    obstacle['x'], obstacle['y'] + obstacle['height'],
                    obstacle['x'] + obstacle['width']/2, obstacle['y'],
                    obstacle['x'] + obstacle['width'], obstacle['y'] + obstacle['height']
                ]
                self.canvas.create_polygon(
                    points,
                    fill=obstacle['color'],
                    outline="black",
                    width=2,
                    tags="obstacle"
                )
            else:
                # 绘制方块
                self.canvas.create_rectangle(
                    obstacle['x'], obstacle['y'],
                    obstacle['x'] + obstacle['width'], 
                    obstacle['y'] + obstacle['height'],
                    fill=obstacle['color'],
                    outline="black",
                    width=2,
                    tags="obstacle"
                )
                
                # 添加纹理
                if obstacle['type'] == 'moving':
                    self.canvas.create_rectangle(
                        obstacle['x'] + 5, obstacle['y'] + 5,
                        obstacle['x'] + obstacle['width'] - 5,
                        obstacle['y'] + obstacle['height'] - 5,
                        fill="",
                        outline="white",
                        width=1,
                        tags="obstacle"
                    )
        
        # 绘制金币
        for coin in self.coins:
            self.canvas.create_oval(
                coin['x'] - coin['radius'], coin['y'] - coin['radius'],
                coin['x'] + coin['radius'], coin['y'] + coin['radius'],
                fill=self.coin_color,
                outline="#FFA000",
                width=2,
                tags="coin"
            )
            
            # 金币内部细节
            self.canvas.create_oval(
                coin['x'] - coin['radius']/2, coin['y'] - coin['radius']/2,
                coin['x'] + coin['radius']/2, coin['y'] + coin['radius']/2,
                fill="#FFECB3",
                outline="",
                tags="coin"
            )
        
        # 绘制道具
        for powerup in self.powerups:
            self.canvas.create_oval(
                powerup['x'] - powerup['radius'], powerup['y'] - powerup['radius'],
                powerup['x'] + powerup['radius'], powerup['y'] + powerup['radius'],
                fill=powerup['color'],
                outline="white",
                width=2,
                tags="powerup"
            )
            
            # 道具图标
            if powerup['type'] == 'speed':
                self.canvas.create_text(
                    powerup['x'], powerup['y'],
                    text="⚡",
                    font=("Arial", 20),
                    tags="powerup"
                )
            elif powerup['type'] == 'jump':
                self.canvas.create_text(
                    powerup['x'], powerup['y'],
                    text="↑",
                    font=("Arial", 20, "bold"),
                    tags="powerup"
                )
            elif powerup['type'] == 'shield':
                self.canvas.create_text(
                    powerup['x'], powerup['y'],
                    text="⛨",
                    font=("Arial", 20),
                    tags="powerup"
                )
            elif powerup['type'] == 'coin_magnet':
                self.canvas.create_text(
                    powerup['x'], powerup['y'],
                    text="◎",
                    font=("Arial", 20),
                    tags="powerup"
                )
    
    def show_message(self, text, duration=60, x=None, y=None):
        """显示消息"""
        if x is None or y is None:
            x, y = 500, 300
        
        self.canvas.itemconfig(self.message_text, text=text)
        self.canvas.coords(self.message_text, x, y)
        
        if duration > 0:
            self.root.after(duration, lambda: self.canvas.itemconfig(self.message_text, text=""))
    
    def game_over(self):
        """游戏结束"""
        self.game_running = False
        
        # 更新最高分
        if self.score > self.high_score:
            self.high_score = self.score
            self.save_high_score()
        
        # 显示游戏结束画面
        self.canvas.create_rectangle(200, 200, 800, 400, fill="black", stipple="gray50", outline="white", width=3)
        self.canvas.create_text(500, 240, text="游戏结束", font=("Arial", 36, "bold"), fill="white")
        self.canvas.create_text(500, 290, text=f"最终分数: {self.score}", font=("Arial", 24), fill="white")
        self.canvas.create_text(500, 320, text=f"最高分: {self.high_score}", font=("Arial", 24), fill="#FFD700")
        self.canvas.create_text(500, 360, text="按R键重新开始", font=("Arial", 18), fill="white")
    
    def load_high_score(self):
        """加载最高分"""
        try:
            if os.path.exists("game_assets/high_score.txt"):
                with open("game_assets/high_score.txt", "r") as f:
                    self.high_score = int(f.read())
        except:
            self.high_score = 0
    
    def save_high_score(self):
        """保存最高分"""
        try:
            with open("game_assets/high_score.txt", "w") as f:
                f.write(str(self.high_score))
        except:
            pass

def main():
    root = tk.Tk()
    
    # 设置窗口图标
    try:
        root.iconbitmap('game_assets/icon.ico')
    except:
        pass
    
    game = ParkourGame(root)
    
    # 设置窗口居中
    root.update_idletasks()
    width = root.winfo_width()
    height = root.winfo_height()
    x = (root.winfo_screenwidth() // 2) - (width // 2)
    y = (root.winfo_screenheight() // 2) - (height // 2)
    root.geometry(f'1000x600+{x}+{y}')
    
    root.mainloop()

if __name__ == "__main__":
    # 检查PIL库
    try:
        from PIL import Image, ImageTk
    except ImportError:
        print("需要安装PIL库: pip install pillow")
        try:
            import subprocess
            subprocess.check_call([sys.executable, "-m", "pip", "install", "pillow"])
            from PIL import Image, ImageTk
            print("PIL库安装成功，重新运行程序")
        except:
            print("无法自动安装PIL库，请手动安装: pip install pillow")
        sys.exit(1)
    
    main()