import tkinter as tk
import random
import math
import time
from enum import Enum
from typing import List, Tuple, Dict
import json
import os

class GameMode(Enum):
    """游戏模式"""
    CLASSIC = "经典模式"      # 无尽生存
    TIMED = "限时挑战"        # 时间挑战
    BOSS_RUSH = "BOSS挑战"   # 连续BOSS战
    WAVE = "波次模式"         # 波次生存

class EnemyType(Enum):
    """敌人类型"""
    BASIC = 1        # 基本敌人
    CHASER = 2       # 追踪者
    SHOOTER = 3      # 射击者
    TANK = 4         # 重装坦克
    SPEEDSTER = 5    # 速攻者
    SPLITTER = 6     # 分裂者
    MINER = 7        # 矿工（掉落金币）
    BOSS_1 = 8       # BOSS 1
    BOSS_2 = 9       # BOSS 2
    BOSS_3 = 10      # BOSS 3

class UpgradeType(Enum):
    """升级类型"""
    HEALTH = "生命值"
    DAMAGE = "攻击力"
    SPEED = "移动速度"
    FIRE_RATE = "射速"
    BULLET_SPEED = "子弹速度"
    SHIELD = "护盾"
    MAGNET = "磁铁"
    DOUBLE_SHOT = "双发"
    TRIPLE_SHOT = "三发"
    PIERCING = "穿透子弹"
    EXPLOSIVE = "爆炸子弹"

class PowerUpType(Enum):
    """道具类型"""
    HEALTH = "❤️ 生命"
    SHIELD = "🛡️ 护盾"
    SPEED = "⚡ 加速"
    SLOW = "⏰ 慢速时间"
    BOMB = "💣 炸弹"
    COIN = "💰 金币"
    MAGNET = "🧲 磁铁"
    INVINCIBLE = "✨ 无敌"
    DOUBLE_SCORE = "2️⃣ 双倍分数"

class SpaceShooter:
    def __init__(self, root):
        self.root = root
        self.root.title("星际战机 - Galactic Defender")
        self.root.configure(bg="#0a0a1a")
        
        # 窗口设置
        self.screen_width = root.winfo_screenwidth()
        self.screen_height = root.winfo_screenheight()
        self.width = min(1200, self.screen_width - 100)
        self.height = min(800, self.screen_height - 100)
        
        # 中心定位
        x = (self.screen_width - self.width) // 2
        y = (self.screen_height - self.height) // 2
        self.root.geometry(f"{self.width}x{self.height}+{x}+{y}")
        self.root.resizable(False, False)
        
        # 游戏状态
        self.game_running = False
        self.game_paused = False
        self.game_mode = GameMode.CLASSIC
        self.score = 0
        self.high_score = 0
        self.coins = 0
        self.player_level = 1
        self.wave = 1
        self.boss_wave = False
        
        # 加载数据
        self.load_game_data()
        
        # 玩家属性
        self.player_x = self.width // 2
        self.player_y = self.height - 100
        self.player_size = 20
        self.player_speed = 6
        self.player_health = 100
        self.max_health = 100
        self.shield = 0
        self.invincible = False
        self.invincible_timer = 0
        
        # 武器系统
        self.weapon_level = 1
        self.fire_rate = 0.3  # 秒
        self.last_shot = 0
        self.bullet_speed = 8
        self.bullet_damage = 1
        self.bullet_count = 1
        self.bullet_spread = 0
        
        # 特殊能力
        self.bomb_count = 3
        self.slow_time = False
        self.slow_time_timer = 0
        self.magnet_active = False
        self.magnet_timer = 0
        self.double_score = False
        self.double_score_timer = 0
        
        # 敌人系统
        self.enemies = []
        self.enemy_spawn_timer = 0
        self.enemy_spawn_rate = 2.0
        
        # 子弹系统
        self.bullets = []
        self.enemy_bullets = []
        
        # 道具系统
        self.powerups = []
        self.powerup_spawn_rate = 0.01
        
        # 粒子系统
        self.particles = []
        
        # 爆炸效果
        self.explosions = []
        
        # 视觉效果
        self.stars = []
        self.create_stars(200)
        self.parallax_layers = []
        self.create_parallax_layers()
        
        # 控制状态
        self.keys_pressed = set()
        
        # 创建界面
        self.create_ui()
        
        # 绑定事件
        self.root.bind("<KeyPress>", self.on_key_press)
        self.root.bind("<KeyRelease>", self.on_key_release)
        self.root.bind("<Button-1>", self.on_mouse_click)
        
        # 显示主菜单
        self.show_main_menu()
    
    def create_ui(self):
        """创建用户界面"""
        # 主框架
        self.main_frame = tk.Frame(self.root, bg="#0a0a1a")
        self.main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 画布
        self.canvas = tk.Canvas(
            self.main_frame,
            width=self.width,
            height=self.height,
            bg="#0a0a1a",
            highlightthickness=0
        )
        self.canvas.pack()
        
        # 状态栏（透明覆盖层）
        self.status_frame = tk.Frame(
            self.canvas,
            bg="#0a0a1a",
            highlightbackground="#2a2a4a",
            highlightthickness=1
        )
        self.status_frame.place(x=10, y=10, width=self.width-20, height=40)
        
        # 生命值条
        self.health_frame = tk.Frame(self.status_frame, bg="#1a1a2a")
        self.health_frame.place(x=10, y=5, width=200, height=15)
        
        self.health_bar = tk.Canvas(
            self.health_frame,
            width=200,
            height=15,
            bg="#1a1a2a",
            highlightthickness=0
        )
        self.health_bar.pack()
        self.health_fill = self.health_bar.create_rectangle(0, 0, 200, 15, fill="#4CAF50", outline="")
        
        self.health_label = tk.Label(
            self.health_frame,
            text="100/100",
            font=("Arial", 8),
            fg="white",
            bg="#1a1a2a"
        )
        self.health_label.place(relx=0.5, rely=0.5, anchor="center")
        
        # 分数显示
        self.score_label = tk.Label(
            self.status_frame,
            text=f"分数: {self.score}",
            font=("Arial", 10, "bold"),
            fg="white",
            bg="#0a0a1a"
        )
        self.score_label.place(relx=0.5, rely=0.5, anchor="center")
        
        # 右侧状态
        right_frame = tk.Frame(self.status_frame, bg="#0a0a1a")
        right_frame.place(relx=1.0, y=5, anchor="ne", x=-10)
        
        self.coin_label = tk.Label(
            right_frame,
            text=f"💰 {self.coins}",
            font=("Arial", 10, "bold"),
            fg="gold",
            bg="#0a0a1a"
        )
        self.coin_label.pack(side=tk.LEFT, padx=5)
        
        self.wave_label = tk.Label(
            right_frame,
            text=f"波次: {self.wave}",
            font=("Arial", 10, "bold"),
            fg="#4CAF50",
            bg="#0a0a1a"
        )
        self.wave_label.pack(side=tk.LEFT, padx=5)
        
        self.bomb_label = tk.Label(
            right_frame,
            text=f"💣 {self.bomb_count}",
            font=("Arial", 10, "bold"),
            fg="#FF5722",
            bg="#0a0a1a"
        )
        self.bomb_label.pack(side=tk.LEFT, padx=5)
    
    def create_stars(self, count):
        """创建星空背景"""
        for _ in range(count):
            x = random.randint(0, self.width)
            y = random.randint(0, self.height)
            size = random.uniform(0.5, 3)
            speed = random.uniform(0.2, 1.0)
            brightness = random.randint(100, 255)
            self.stars.append({
                "x": x, "y": y, "size": size,
                "speed": speed, "brightness": brightness,
                "twinkle_speed": random.uniform(0.01, 0.05),
                "twinkle_phase": random.uniform(0, math.pi*2)
            })
    
    def create_parallax_layers(self):
        """创建视差滚动层"""
        layers = 3
        for layer in range(layers):
            layer_stars = []
            speed_factor = 0.5 + layer * 0.5
            for _ in range(50):
                x = random.randint(0, self.width)
                y = random.randint(0, self.height)
                size = 1 + layer * 0.5
                speed = 0.3 + layer * 0.2
                layer_stars.append({"x": x, "y": y, "speed": speed})
            self.parallax_layers.append(layer_stars)
    
    def show_main_menu(self):
        """显示主菜单"""
        self.clear_canvas()
        
        # 绘制背景
        self.draw_background()
        
        # 游戏标题
        title_text = self.canvas.create_text(
            self.width // 2,
            self.height // 4,
            text="星际战机",
            font=("Microsoft YaHei", 60, "bold"),
            fill="#4CAF50"
        )
        
        subtitle = self.canvas.create_text(
            self.width // 2,
            self.height // 4 + 70,
            text="Galactic Defender",
            font=("Arial", 24, "italic"),
            fill="#2196F3"
        )
        
        # 最高分
        high_score = self.canvas.create_text(
            self.width // 2,
            self.height // 4 + 120,
            text=f"最高分: {self.high_score}",
            font=("Arial", 20),
            fill="gold"
        )
        
        # 游戏模式选择
        modes_y = self.height // 2
        modes = [
            ("经典模式", self.start_classic_mode, "#4CAF50"),
            ("限时挑战", self.start_timed_mode, "#2196F3"),
            ("BOSS挑战", self.start_boss_rush, "#9C27B0"),
            ("波次模式", self.start_wave_mode, "#FF9800"),
        ]
        
        self.mode_buttons = []
        for i, (text, command, color) in enumerate(modes):
            btn = tk.Button(
                self.root,
                text=text,
                command=command,
                font=("Microsoft YaHei", 16),
                bg=color,
                fg="white",
                width=20,
                relief=tk.RAISED,
                bd=3
            )
            btn_window = self.canvas.create_window(
                self.width // 2,
                modes_y + i * 60,
                window=btn
            )
            self.mode_buttons.append((btn, btn_window))
        
        # 商店和退出按钮
        bottom_y = modes_y + len(modes) * 60 + 40
        
        shop_btn = tk.Button(
            self.root,
            text="商店升级",
            command=self.show_upgrade_shop,
            font=("Microsoft YaHei", 14),
            bg="#607D8B",
            fg="white",
            width=15
        )
        self.canvas.create_window(
            self.width // 2 - 100,
            bottom_y,
            window=shop_btn
        )
        
        quit_btn = tk.Button(
            self.root,
            text="退出游戏",
            command=self.root.quit,
            font=("Microsoft YaHei", 14),
            bg="#F44336",
            fg="white",
            width=15
        )
        self.canvas.create_window(
            self.width // 2 + 100,
            bottom_y,
            window=quit_btn
        )
        
        # 开发者信息
        self.canvas.create_text(
            self.width // 2,
            self.height - 20,
            text="WASD/方向键移动 | 空格射击 | P暂停 | B炸弹",
            font=("Arial", 10),
            fill="white"
        )
    
    def show_upgrade_shop(self):
        """显示升级商店"""
        self.clear_canvas()
        
        # 背景
        self.draw_background()
        
        # 标题
        self.canvas.create_text(
            self.width // 2,
            50,
            text="升级商店",
            font=("Microsoft YaHei", 40, "bold"),
            fill="gold"
        )
        
        # 金币显示
        self.canvas.create_text(
            self.width // 2,
            100,
            text=f"💰 金币: {self.coins}",
            font=("Arial", 24, "bold"),
            fill="gold"
        )
        
        # 升级项
        upgrades = [
            ("生命值 +20", 100, UpgradeType.HEALTH, "+20 最大生命值"),
            ("攻击力 +1", 150, UpgradeType.DAMAGE, "+1 子弹伤害"),
            ("移动速度 +1", 80, UpgradeType.SPEED, "+1 移动速度"),
            ("射速 +20%", 120, UpgradeType.FIRE_RATE, "-20% 射击间隔"),
            ("双发子弹", 200, UpgradeType.DOUBLE_SHOT, "同时发射两发子弹"),
            ("三发子弹", 300, UpgradeType.TRIPLE_SHOT, "同时发射三发子弹"),
            ("穿透子弹", 250, UpgradeType.PIERCING, "子弹可穿透敌人"),
            ("爆炸子弹", 400, UpgradeType.EXPLOSIVE, "子弹爆炸造成范围伤害"),
        ]
        
        start_y = 150
        self.shop_buttons = []
        
        for i, (name, cost, upgrade_type, description) in enumerate(upgrades):
            y = start_y + i * 80
            
            # 升级项背景
            bg = self.canvas.create_rectangle(
                100, y-30,
                self.width-100, y+30,
                fill="#1a1a2a",
                outline="#4CAF50",
                width=2
            )
            
            # 名称
            self.canvas.create_text(
                200, y,
                text=name,
                font=("Microsoft YaHei", 16, "bold"),
                fill="white",
                anchor="w"
            )
            
            # 描述
            self.canvas.create_text(
                200, y+20,
                text=description,
                font=("Arial", 10),
                fill="#aaa",
                anchor="w"
            )
            
            # 价格
            self.canvas.create_text(
                self.width-200, y,
                text=f"💰 {cost}",
                font=("Arial", 16, "bold"),
                fill="gold"
            )
            
            # 购买按钮
            btn = tk.Button(
                self.root,
                text="购买" if self.coins >= cost else "金币不足",
                command=lambda ut=upgrade_type, c=cost: self.buy_upgrade(ut, c),
                font=("Microsoft YaHei", 12),
                bg="#4CAF50" if self.coins >= cost else "#666",
                fg="white",
                width=10,
                state=tk.NORMAL if self.coins >= cost else tk.DISABLED
            )
            btn_window = self.canvas.create_window(
                self.width-100, y,
                window=btn
            )
            self.shop_buttons.append((btn, btn_window))
        
        # 返回按钮
        back_btn = tk.Button(
            self.root,
            text="返回主菜单",
            command=self.show_main_menu,
            font=("Microsoft YaHei", 14),
            bg="#607D8B",
            fg="white",
            width=20
        )
        self.canvas.create_window(
            self.width // 2,
            self.height - 50,
            window=back_btn
        )
    
    def buy_upgrade(self, upgrade_type, cost):
        """购买升级"""
        if self.coins >= cost:
            self.coins -= cost
            
            if upgrade_type == UpgradeType.HEALTH:
                self.max_health += 20
                self.player_health = min(self.player_health + 20, self.max_health)
            elif upgrade_type == UpgradeType.DAMAGE:
                self.bullet_damage += 1
            elif upgrade_type == UpgradeType.SPEED:
                self.player_speed += 1
            elif upgrade_type == UpgradeType.FIRE_RATE:
                self.fire_rate = max(0.1, self.fire_rate * 0.8)
            elif upgrade_type == UpgradeType.DOUBLE_SHOT:
                self.bullet_count = 2
                self.bullet_spread = 10
            elif upgrade_type == UpgradeType.TRIPLE_SHOT:
                self.bullet_count = 3
                self.bullet_spread = 15
            elif upgrade_type == UpgradeType.PIERCING:
                # 穿透效果
                pass
            elif upgrade_type == UpgradeType.EXPLOSIVE:
                # 爆炸效果
                pass
            
            self.save_game_data()
            self.show_upgrade_shop()
    
    def start_classic_mode(self):
        """开始经典模式"""
        self.game_mode = GameMode.CLASSIC
        self.start_game()
    
    def start_timed_mode(self):
        """开始限时挑战"""
        self.game_mode = GameMode.TIMED
        self.start_game()
    
    def start_boss_rush(self):
        """开始BOSS挑战"""
        self.game_mode = GameMode.BOSS_RUSH
        self.start_game()
    
    def start_wave_mode(self):
        """开始波次模式"""
        self.game_mode = GameMode.WAVE
        self.start_game()
    
    def start_game(self):
        """开始游戏"""
        self.clear_canvas()
        
        # 重置游戏状态
        self.game_running = True
        self.game_paused = False
        self.game_over = False
        
        if self.game_mode == GameMode.CLASSIC:
            self.score = 0
            self.wave = 1
        elif self.game_mode == GameMode.WAVE:
            self.score = 0
            self.wave = 1
        elif self.game_mode == GameMode.BOSS_RUSH:
            self.score = 0
            self.wave = 1
            self.boss_wave = True
        
        # 重置玩家状态
        self.player_x = self.width // 2
        self.player_y = self.height - 100
        self.player_health = self.max_health
        self.shield = 0
        self.invincible = False
        self.invincible_timer = 0
        
        # 清空所有对象
        self.enemies.clear()
        self.bullets.clear()
        self.enemy_bullets.clear()
        self.powerups.clear()
        self.particles.clear()
        self.explosions.clear()
        
        # 开始游戏循环
        self.game_loop()
    
    def draw_background(self):
        """绘制背景"""
        # 星空背景
        for star in self.stars:
            # 闪烁效果
            twinkle = (math.sin(time.time() * star["twinkle_speed"] + star["twinkle_phase"]) + 1) / 2
            brightness = int(star["brightness"] * (0.5 + twinkle * 0.5))
            color = f"#{brightness:02x}{brightness:02x}{brightness:02x}"
            
            self.canvas.create_oval(
                star["x"], star["y"],
                star["x"] + star["size"], star["y"] + star["size"],
                fill=color, outline=color
            )
        
        # 视差层
        for layer_idx, layer in enumerate(self.parallax_layers):
            for star in layer:
                star["y"] += star["speed"]
                if star["y"] > self.height:
                    star["y"] = 0
                    star["x"] = random.randint(0, self.width)
                
                size = 1 + layer_idx * 0.5
                brightness = 100 + layer_idx * 50
                color = f"#{brightness:02x}{brightness:02x}{brightness:02x}"
                
                self.canvas.create_oval(
                    star["x"], star["y"],
                    star["x"] + size, star["y"] + size,
                    fill=color, outline=color
                )
    
    def draw_player(self):
        """绘制玩家飞船"""
        # 清除之前的玩家图形
        self.canvas.delete("player")
        
        # 绘制护盾
        if self.shield > 0:
            shield_radius = self.player_size + 10
            alpha = int(100 + 155 * (self.shield / 100))
            self.canvas.create_oval(
                self.player_x - shield_radius, self.player_y - shield_radius,
                self.player_x + shield_radius, self.player_y + shield_radius,
                outline=f"#00bcd4",
                width=3,
                tags="player"
            )
        
        # 无敌状态闪烁
        if self.invincible and int(time.time() * 10) % 2 == 0:
            self.canvas.create_oval(
                self.player_x - self.player_size - 5, self.player_y - self.player_size - 5,
                self.player_x + self.player_size + 5, self.player_y + self.player_size + 5,
                outline="#ffcc00",
                width=2,
                tags="player"
            )
        
        # 绘制飞船主体
        points = []
        for i in range(3):
            angle = 2 * math.pi * i / 3
            x = self.player_x + self.player_size * math.cos(angle - math.pi/2)
            y = self.player_y + self.player_size * math.sin(angle - math.pi/2)
            points.extend([x, y])
        
        self.canvas.create_polygon(
            points,
            fill="#2196F3",
            outline="#1976D2",
            width=2,
            tags="player"
        )
        
        # 引擎火焰
        flame_size = self.player_size * 0.8
        for i in range(2):
            angle = math.pi/4 + i * math.pi/2
            flame_points = [
                self.player_x + flame_size * math.cos(math.pi/2),
                self.player_y + flame_size * math.sin(math.pi/2),
                self.player_x + flame_size * math.cos(math.pi/2 + angle),
                self.player_y + flame_size * math.sin(math.pi/2 + angle),
                self.player_x + flame_size * math.cos(math.pi/2 - angle),
                self.player_y + flame_size * math.sin(math.pi/2 - angle)
            ]
            self.canvas.create_polygon(
                flame_points,
                fill="#FF9800",
                outline="#F57C00",
                width=1,
                tags="player"
            )
    
    def move_player(self):
        """移动玩家"""
        dx = dy = 0
        speed = self.player_speed
        
        if "w" in self.keys_pressed or "Up" in self.keys_pressed:
            dy -= speed
        if "s" in self.keys_pressed or "Down" in self.keys_pressed:
            dy += speed
        if "a" in self.keys_pressed or "Left" in self.keys_pressed:
            dx -= speed
        if "d" in self.keys_pressed or "Right" in self.keys_pressed:
            dx += speed
        
        # 更新位置
        new_x = self.player_x + dx
        new_y = self.player_y + dy
        
        # 边界检查
        self.player_x = max(self.player_size, min(self.width - self.player_size, new_x))
        self.player_y = max(self.player_size, min(self.height - self.player_size, new_y))
        
        # 绘制玩家
        self.draw_player()
    
    def spawn_enemy(self):
        """生成敌人"""
        current_time = time.time()
        
        if current_time - self.enemy_spawn_timer > self.enemy_spawn_rate:
            self.enemy_spawn_timer = current_time
            
            # 根据波次和模式决定生成的敌人类型
            if self.boss_wave:
                # BOSS波
                boss_type = EnemyType.BOSS_1
                if self.wave >= 10:
                    boss_type = EnemyType.BOSS_3
                elif self.wave >= 5:
                    boss_type = EnemyType.BOSS_2
                
                self.create_enemy(boss_type)
                self.boss_wave = False
            else:
                # 普通敌人
                enemy_types = [EnemyType.BASIC, EnemyType.CHASER, EnemyType.SHOOTER]
                
                if self.wave >= 3:
                    enemy_types.append(EnemyType.TANK)
                if self.wave >= 5:
                    enemy_types.append(EnemyType.SPEEDSTER)
                if self.wave >= 7:
                    enemy_types.append(EnemyType.SPLITTER)
                if self.wave >= 9:
                    enemy_types.append(EnemyType.MINER)
                
                # 一次生成多个敌人
                spawn_count = min(1 + self.wave // 3, 5)
                for _ in range(spawn_count):
                    enemy_type = random.choice(enemy_types)
                    self.create_enemy(enemy_type)
    
    def create_enemy(self, enemy_type):
        """创建敌人"""
        x = random.randint(50, self.width - 50)
        y = random.randint(-100, -20)
        
        if enemy_type == EnemyType.BASIC:
            size = 20
            health = 1
            speed = 2
            color = "#f44336"
            score = 10
        elif enemy_type == EnemyType.CHASER:
            size = 18
            health = 2
            speed = 3
            color = "#2196F3"
            score = 20
        elif enemy_type == EnemyType.SHOOTER:
            size = 22
            health = 3
            speed = 1.5
            color = "#FF9800"
            score = 30
        elif enemy_type == EnemyType.TANK:
            size = 35
            health = 10
            speed = 1
            color = "#795548"
            score = 50
        elif enemy_type == EnemyType.SPEEDSTER:
            size = 15
            health = 1
            speed = 5
            color = "#E91E63"
            score = 25
        elif enemy_type == EnemyType.SPLITTER:
            size = 25
            health = 4
            speed = 2
            color = "#4CAF50"
            score = 40
        elif enemy_type == EnemyType.MINER:
            size = 20
            health = 2
            speed = 2
            color = "#FFC107"
            score = 15
        elif enemy_type == EnemyType.BOSS_1:
            size = 60
            health = 100
            speed = 0.5
            color = "#9C27B0"
            score = 1000
        elif enemy_type == EnemyType.BOSS_2:
            size = 80
            health = 200
            speed = 0.4
            color = "#3F51B5"
            score = 2000
        elif enemy_type == EnemyType.BOSS_3:
            size = 100
            health = 300
            speed = 0.3
            color = "#F44336"
            score = 5000
        else:
            size = 20
            health = 1
            speed = 2
            color = "#f44336"
            score = 10
        
        enemy_id = self.canvas.create_oval(
            x - size, y - size,
            x + size, y + size,
            fill=color,
            outline="white",
            width=2
        )
        
        enemy = {
            "id": enemy_id,
            "type": enemy_type,
            "x": x, "y": y,
            "size": size,
            "health": health,
            "max_health": health,
            "speed": speed,
            "color": color,
            "score": score,
            "shoot_timer": random.uniform(0, 2),
            "shoot_interval": 2.0,
            "direction": random.choice([-1, 1])
        }
        
        self.enemies.append(enemy)
    
    def move_enemies(self):
        """移动敌人"""
        for enemy in self.enemies[:]:
            enemy_type = enemy["type"]
            
            if enemy_type == EnemyType.BASIC or enemy_type == EnemyType.TANK or enemy_type == EnemyType.MINER:
                # 直线向下
                enemy["y"] += enemy["speed"]
                
            elif enemy_type == EnemyType.CHASER:
                # 追踪玩家
                dx = self.player_x - enemy["x"]
                dy = self.player_y - enemy["y"]
                dist = max(1, math.sqrt(dx*dx + dy*dy))
                enemy["x"] += (dx / dist) * enemy["speed"]
                enemy["y"] += (dy / dist) * enemy["speed"]
                
            elif enemy_type == EnemyType.SPEEDSTER:
                # 快速移动
                enemy["y"] += enemy["speed"]
                enemy["x"] += math.sin(enemy["y"] * 0.1) * 3
                
            elif enemy_type == EnemyType.SPLITTER:
                # 正弦波移动
                enemy["y"] += enemy["speed"]
                enemy["x"] += math.sin(enemy["y"] * 0.05) * enemy["direction"] * 2
                
            elif enemy_type in [EnemyType.BOSS_1, EnemyType.BOSS_2, EnemyType.BOSS_3]:
                # BOSS移动模式
                enemy["y"] += enemy["speed"] * 0.5
                enemy["x"] += math.sin(time.time() * 0.5) * 3
                
                # BOSS射击
                enemy["shoot_timer"] += 1/60
                if enemy["shoot_timer"] >= enemy["shoot_interval"]:
                    self.enemy_shoot(enemy)
                    enemy["shoot_timer"] = 0
            
            # 射击敌人
            if enemy_type == EnemyType.SHOOTER:
                enemy["y"] += enemy["speed"]
                enemy["shoot_timer"] += 1/60
                if enemy["shoot_timer"] >= enemy["shoot_interval"]:
                    self.enemy_shoot(enemy)
                    enemy["shoot_timer"] = 0
            
            # 更新位置
            self.canvas.coords(
                enemy["id"],
                enemy["x"] - enemy["size"], enemy["y"] - enemy["size"],
                enemy["x"] + enemy["size"], enemy["y"] + enemy["size"]
            )
            
            # 绘制血条
            if enemy["max_health"] > 1:
                health_ratio = enemy["health"] / enemy["max_health"]
                bar_width = enemy["size"] * 2
                bar_height = 4
                x1 = enemy["x"] - enemy["size"]
                y1 = enemy["y"] - enemy["size"] - 8
                x2 = x1 + bar_width * health_ratio
                y2 = y1 + bar_height
                
                # 删除旧血条
                if "health_bar" in enemy:
                    self.canvas.delete(enemy["health_bar"])
                
                # 绘制新血条
                enemy["health_bar"] = self.canvas.create_rectangle(
                    x1, y1, x2, y2,
                    fill="#4CAF50",
                    outline="",
                    tags="enemy_ui"
                )
                
                # 血条边框
                self.canvas.create_rectangle(
                    x1, y1, x1 + bar_width, y2,
                    outline="white",
                    width=1,
                    tags="enemy_ui"
                )
            
            # 检查是否出界
            if (enemy["y"] > self.height + 100 or 
                enemy["x"] < -100 or 
                enemy["x"] > self.width + 100):
                self.canvas.delete(enemy["id"])
                if "health_bar" in enemy:
                    self.canvas.delete(enemy["health_bar"])
                self.enemies.remove(enemy)
    
    def enemy_shoot(self, enemy):
        """敌人射击"""
        if enemy["type"] in [EnemyType.SHOOTER, EnemyType.BOSS_1, EnemyType.BOSS_2, EnemyType.BOSS_3]:
            # 向玩家发射子弹
            dx = self.player_x - enemy["x"]
            dy = self.player_y - enemy["y"]
            dist = max(1, math.sqrt(dx*dx + dy*dy))
            
            if enemy["type"] == EnemyType.BOSS_1:
                # BOSS 1: 三向射击
                for angle in [-15, 0, 15]:
                    rad = math.radians(angle)
                    cos_a, sin_a = math.cos(rad), math.sin(rad)
                    bullet_dx = (dx * cos_a - dy * sin_a) / dist * 4
                    bullet_dy = (dx * sin_a + dy * cos_a) / dist * 4
                    
                    bullet = {
                        "x": enemy["x"],
                        "y": enemy["y"] + enemy["size"],
                        "dx": bullet_dx,
                        "dy": bullet_dy,
                        "size": 6,
                        "color": "#9C27B0"
                    }
                    bullet_id = self.canvas.create_oval(
                        bullet["x"] - bullet["size"], bullet["y"] - bullet["size"],
                        bullet["x"] + bullet["size"], bullet["y"] + bullet["size"],
                        fill=bullet["color"],
                        outline="#7B1FA2",
                        width=1
                    )
                    bullet["id"] = bullet_id
                    self.enemy_bullets.append(bullet)
            else:
                # 普通射击
                bullet = {
                    "x": enemy["x"],
                    "y": enemy["y"] + enemy["size"],
                    "dx": (dx / dist) * 4,
                    "dy": (dy / dist) * 4,
                    "size": 4,
                    "color": "#FF9800"
                }
                bullet_id = self.canvas.create_oval(
                    bullet["x"] - bullet["size"], bullet["y"] - bullet["size"],
                    bullet["x"] + bullet["size"], bullet["y"] + bullet["size"],
                    fill=bullet["color"],
                    outline="#F57C00",
                    width=1
                )
                bullet["id"] = bullet_id
                self.enemy_bullets.append(bullet)
    
    def player_shoot(self):
        """玩家射击"""
        current_time = time.time()
        
        if current_time - self.last_shot >= self.fire_rate:
            self.last_shot = current_time
            
            # 多发射击
            if self.bullet_count == 1:
                # 单发
                bullet = {
                    "x": self.player_x,
                    "y": self.player_y - self.player_size,
                    "dx": 0,
                    "dy": -self.bullet_speed,
                    "size": 6,
                    "color": "#00bcd4",
                    "damage": self.bullet_damage
                }
                bullet_id = self.canvas.create_oval(
                    bullet["x"] - bullet["size"], bullet["y"] - bullet["size"],
                    bullet["x"] + bullet["size"], bullet["y"] + bullet["size"],
                    fill=bullet["color"],
                    outline="#0097A7",
                    width=2
                )
                bullet["id"] = bullet_id
                self.bullets.append(bullet)
            else:
                # 多发
                for i in range(self.bullet_count):
                    spread = self.bullet_spread
                    angle_offset = (-spread/2) + (spread/(self.bullet_count-1)) * i if self.bullet_count > 1 else 0
                    
                    rad = math.radians(angle_offset)
                    bullet_dx = math.sin(rad) * 2
                    bullet_dy = -self.bullet_speed
                    
                    bullet = {
                        "x": self.player_x + bullet_dx * 5,
                        "y": self.player_y - self.player_size,
                        "dx": bullet_dx,
                        "dy": bullet_dy,
                        "size": 5,
                        "color": "#9C27B0" if self.bullet_count >= 3 else "#2196F3",
                        "damage": self.bullet_damage
                    }
                    bullet_id = self.canvas.create_oval(
                        bullet["x"] - bullet["size"], bullet["y"] - bullet["size"],
                        bullet["x"] + bullet["size"], bullet["y"] + bullet["size"],
                        fill=bullet["color"],
                        outline="#7B1FA2" if self.bullet_count >= 3 else "#1976D2",
                        width=1
                    )
                    bullet["id"] = bullet_id
                    self.bullets.append(bullet)
    
    def move_bullets(self):
        """移动子弹"""
        # 玩家子弹
        for bullet in self.bullets[:]:
            bullet["x"] += bullet["dx"]
            bullet["y"] += bullet["dy"]
            
            self.canvas.coords(
                bullet["id"],
                bullet["x"] - bullet["size"], bullet["y"] - bullet["size"],
                bullet["x"] + bullet["size"], bullet["y"] + bullet["size"]
            )
            
            # 检查出界
            if (bullet["x"] < -20 or bullet["x"] > self.width + 20 or
                bullet["y"] < -20 or bullet["y"] > self.height + 20):
                self.canvas.delete(bullet["id"])
                self.bullets.remove(bullet)
        
        # 敌人子弹
        for bullet in self.enemy_bullets[:]:
            bullet["x"] += bullet["dx"]
            bullet["y"] += bullet["dy"]
            
            self.canvas.coords(
                bullet["id"],
                bullet["x"] - bullet["size"], bullet["y"] - bullet["size"],
                bullet["x"] + bullet["size"], bullet["y"] + bullet["size"]
            )
            
            # 检查出界
            if (bullet["x"] < -20 or bullet["x"] > self.width + 20 or
                bullet["y"] < -20 or bullet["y"] > self.height + 20):
                self.canvas.delete(bullet["id"])
                self.enemy_bullets.remove(bullet)
    
    def check_collisions(self):
        """检测碰撞"""
        # 玩家子弹 vs 敌人
        for bullet in self.bullets[:]:
            for enemy in self.enemies[:]:
                dx = bullet["x"] - enemy["x"]
                dy = bullet["y"] - enemy["y"]
                distance = math.sqrt(dx*dx + dy*dy)
                
                if distance < bullet["size"] + enemy["size"]:
                    # 命中敌人
                    enemy["health"] -= bullet.get("damage", 1)
                    
                    # 粒子效果
                    self.create_particles(
                        bullet["x"], bullet["y"],
                        count=5,
                        color=bullet["color"],
                        speed=2
                    )
                    
                    # 移除子弹
                    self.canvas.delete(bullet["id"])
                    if bullet in self.bullets:
                        self.bullets.remove(bullet)
                    
                    # 检查敌人是否死亡
                    if enemy["health"] <= 0:
                        # 分数
                        score_gain = enemy["score"]
                        if self.double_score:
                            score_gain *= 2
                        self.score += score_gain
                        
                        # 金币掉落
                        if enemy["type"] == EnemyType.MINER:
                            self.coins += random.randint(2, 5)
                        elif enemy["type"] in [EnemyType.BOSS_1, EnemyType.BOSS_2, EnemyType.BOSS_3]:
                            self.coins += random.randint(20, 50)
                        
                        # 爆炸效果
                        self.create_explosion(
                            enemy["x"], enemy["y"],
                            size=enemy["size"],
                            color=enemy["color"]
                        )
                        
                        # 分裂敌人
                        if enemy["type"] == EnemyType.SPLITTER:
                            for _ in range(2):
                                self.create_enemy(EnemyType.BASIC)
                        
                        # 移除敌人
                        self.canvas.delete(enemy["id"])
                        if "health_bar" in enemy:
                            self.canvas.delete(enemy["health_bar"])
                        if enemy in self.enemies:
                            self.enemies.remove(enemy)
                        
                        # 道具掉落
                        if random.random() < 0.2:  # 20%几率掉落道具
                            self.spawn_powerup(enemy["x"], enemy["y"])
                    break
        
        # 敌人 vs 玩家
        if not self.invincible:
            for enemy in self.enemies[:]:
                dx = enemy["x"] - self.player_x
                dy = enemy["y"] - self.player_y
                distance = math.sqrt(dx*dx + dy*dy)
                
                if distance < enemy["size"] + self.player_size:
                    # 计算伤害
                    damage = 10
                    if enemy["type"] in [EnemyType.BOSS_1, EnemyType.BOSS_2, EnemyType.BOSS_3]:
                        damage = 30
                    elif enemy["type"] == EnemyType.TANK:
                        damage = 20
                    
                    # 护盾吸收
                    if self.shield > 0:
                        self.shield -= damage
                        if self.shield < 0:
                            damage = -self.shield
                            self.shield = 0
                        else:
                            damage = 0
                    
                    if damage > 0:
                        self.player_health -= damage
                        self.invincible = True
                        self.invincible_timer = 60
                        
                        # 爆炸效果
                        self.create_explosion(
                            self.player_x, self.player_y,
                            size=self.player_size,
                            color="#f44336"
                        )
                    
                    # 移除敌人（如果是小型敌人）
                    if enemy["type"] not in [EnemyType.BOSS_1, EnemyType.BOSS_2, EnemyType.BOSS_3, EnemyType.TANK]:
                        self.canvas.delete(enemy["id"])
                        if "health_bar" in enemy:
                            self.canvas.delete(enemy["health_bar"])
                        if enemy in self.enemies:
                            self.enemies.remove(enemy)
                    
                    break
        
        # 敌人子弹 vs 玩家
        if not self.invincible:
            for bullet in self.enemy_bullets[:]:
                dx = bullet["x"] - self.player_x
                dy = bullet["y"] - self.player_y
                distance = math.sqrt(dx*dx + dy*dy)
                
                if distance < bullet["size"] + self.player_size:
                    damage = 5
                    
                    # 护盾吸收
                    if self.shield > 0:
                        self.shield -= damage
                        if self.shield < 0:
                            damage = -self.shield
                            self.shield = 0
                        else:
                            damage = 0
                    
                    if damage > 0:
                        self.player_health -= damage
                        self.invincible = True
                        self.invincible_timer = 30
                        
                        # 爆炸效果
                        self.create_particles(
                            bullet["x"], bullet["y"],
                            count=8,
                            color=bullet["color"],
                            speed=3
                        )
                    
                    # 移除子弹
                    self.canvas.delete(bullet["id"])
                    self.enemy_bullets.remove(bullet)
                    
                    break
        
        # 道具 vs 玩家
        for powerup in self.powerups[:]:
            dx = powerup["x"] - self.player_x
            dy = powerup["y"] - self.player_y
            distance = math.sqrt(dx*dx + dy*dy)
            
            if distance < 20 + self.player_size or (self.magnet_active and distance < 150):
                # 收集道具
                self.apply_powerup(powerup["type"])
                
                # 效果
                self.create_particles(
                    powerup["x"], powerup["y"],
                    count=15,
                    color=powerup["color"],
                    speed=2
                )
                
                # 移除道具
                self.canvas.delete(powerup["id"])
                self.powerups.remove(powerup)
    
    def create_particles(self, x, y, count=10, color="#FFFFFF", speed=1):
        """创建粒子效果"""
        for _ in range(count):
            angle = random.uniform(0, math.pi*2)
            particle_speed = random.uniform(0.5, 2) * speed
            dx = math.cos(angle) * particle_speed
            dy = math.sin(angle) * particle_speed
            size = random.uniform(2, 4)
            life = random.randint(20, 40)
            
            particle_id = self.canvas.create_oval(
                x - size, y - size,
                x + size, y + size,
                fill=color,
                outline=""
            )
            
            particle = {
                "id": particle_id,
                "x": x, "y": y,
                "dx": dx, "dy": dy,
                "size": size,
                "life": life,
                "color": color
            }
            
            self.particles.append(particle)
    
    def update_particles(self):
        """更新粒子效果"""
        for particle in self.particles[:]:
            particle["x"] += particle["dx"]
            particle["y"] += particle["dy"]
            particle["life"] -= 1
            
            # 更新位置
            self.canvas.coords(
                particle["id"],
                particle["x"] - particle["size"], particle["y"] - particle["size"],
                particle["x"] + particle["size"], particle["y"] + particle["size"]
            )
            
            # 淡出效果
            alpha = particle["life"] / 40
            r, g, b = int(particle["color"][1:3], 16), int(particle["color"][3:5], 16), int(particle["color"][5:7], 16)
            new_color = f"#{int(r*alpha):02x}{int(g*alpha):02x}{int(b*alpha):02x}"
            self.canvas.itemconfig(particle["id"], fill=new_color)
            
            # 移除寿命结束的粒子
            if particle["life"] <= 0:
                self.canvas.delete(particle["id"])
                self.particles.remove(particle)
    
    def create_explosion(self, x, y, size=20, color="#FF9800"):
        """创建爆炸效果"""
        for _ in range(3):
            for i in range(8):
                angle = i * math.pi/4
                distance = random.uniform(size*0.5, size*1.5)
                dx = math.cos(angle) * distance
                dy = math.sin(angle) * distance
                
                explosion_id = self.canvas.create_line(
                    x, y,
                    x + dx, y + dy,
                    fill=color,
                    width=3
                )
                
                explosion = {
                    "id": explosion_id,
                    "x": x, "y": y,
                    "dx": dx, "dy": dy,
                    "life": 10
                }
                
                self.explosions.append(explosion)
    
    def update_explosions(self):
        """更新爆炸效果"""
        for explosion in self.explosions[:]:
            explosion["life"] -= 1
            
            # 淡出效果
            alpha = explosion["life"] / 10
            self.canvas.itemconfig(explosion["id"], width=int(3 * alpha))
            
            if explosion["life"] <= 0:
                self.canvas.delete(explosion["id"])
                self.explosions.remove(explosion)
    
    def spawn_powerup(self, x, y):
        """生成道具"""
        if random.random() < self.powerup_spawn_rate:
            powerup_types = [
                (PowerUpType.HEALTH, 0.2, "#4CAF50", "❤️"),
                (PowerUpType.SHIELD, 0.15, "#00bcd4", "🛡️"),
                (PowerUpType.SPEED, 0.1, "#2196F3", "⚡"),
                (PowerUpType.SLOW, 0.1, "#9C27B0", "⏰"),
                (PowerUpType.BOMB, 0.15, "#FF5722", "💣"),
                (PowerUpType.COIN, 0.1, "#FFC107", "💰"),
                (PowerUpType.MAGNET, 0.1, "#E91E63", "🧲"),
                (PowerUpType.INVINCIBLE, 0.05, "#ffcc00", "✨"),
                (PowerUpType.DOUBLE_SCORE, 0.05, "#4CAF50", "2️⃣"),
            ]
            
            # 根据权重选择道具
            total_weight = sum(weight for _, weight, _, _ in powerup_types)
            r = random.uniform(0, total_weight)
            current = 0
            
            for ptype, weight, color, symbol in powerup_types:
                current += weight
                if r <= current:
                    selected_type = ptype
                    selected_color = color
                    selected_symbol = symbol
                    break
            
            powerup_id = self.canvas.create_text(
                x, y,
                text=selected_symbol,
                font=("Arial", 20),
                fill=selected_color
            )
            
            powerup = {
                "id": powerup_id,
                "type": selected_type,
                "x": x, "y": y,
                "color": selected_color,
                "speed": 1
            }
            
            self.powerups.append(powerup)
    
    def move_powerups(self):
        """移动道具"""
        for powerup in self.powerups[:]:
            # 磁铁效果
            if self.magnet_active:
                dx = self.player_x - powerup["x"]
                dy = self.player_y - powerup["y"]
                dist = max(1, math.sqrt(dx*dx + dy*dy))
                powerup["x"] += (dx / dist) * 5
                powerup["y"] += (dy / dist) * 5
            else:
                powerup["y"] += powerup["speed"]
            
            self.canvas.coords(powerup["id"], powerup["x"], powerup["y"])
            
            # 检查出界
            if powerup["y"] > self.height + 30:
                self.canvas.delete(powerup["id"])
                self.powerups.remove(powerup)
    
    def apply_powerup(self, powerup_type):
        """应用道具效果"""
        if powerup_type == PowerUpType.HEALTH:
            self.player_health = min(self.max_health, self.player_health + 20)
        elif powerup_type == PowerUpType.SHIELD:
            self.shield = min(100, self.shield + 30)
        elif powerup_type == PowerUpType.SPEED:
            self.player_speed = 8
            self.root.after(5000, lambda: setattr(self, "player_speed", 6))
        elif powerup_type == PowerUpType.SLOW:
            self.slow_time = True
            self.slow_time_timer = 300
        elif powerup_type == PowerUpType.BOMB:
            self.bomb_count = min(5, self.bomb_count + 1)
        elif powerup_type == PowerUpType.COIN:
            self.coins += random.randint(5, 10)
        elif powerup_type == PowerUpType.MAGNET:
            self.magnet_active = True
            self.magnet_timer = 300
        elif powerup_type == PowerUpType.INVINCIBLE:
            self.invincible = True
            self.invincible_timer = 300
        elif powerup_type == PowerUpType.DOUBLE_SCORE:
            self.double_score = True
            self.double_score_timer = 300
    
    def use_bomb(self):
        """使用炸弹"""
        if self.bomb_count > 0:
            self.bomb_count -= 1
            
            # 清除所有敌人
            for enemy in self.enemies[:]:
                score_gain = enemy["score"]
                if self.double_score:
                    score_gain *= 2
                self.score += score_gain
                
                # 爆炸效果
                self.create_explosion(
                    enemy["x"], enemy["y"],
                    size=enemy["size"],
                    color="#FF9800"
                )
                
                # 移除敌人
                self.canvas.delete(enemy["id"])
                if "health_bar" in enemy:
                    self.canvas.delete(enemy["health_bar"])
            
            self.enemies.clear()
            
            # 清除所有敌人子弹
            for bullet in self.enemy_bullets:
                self.canvas.delete(bullet["id"])
            self.enemy_bullets.clear()
    
    def update_hud(self):
        """更新HUD"""
        # 生命值条
        health_ratio = self.player_health / self.max_health
        health_width = 200 * health_ratio
        self.health_bar.coords(self.health_fill, 0, 0, health_width, 15)
        self.health_label.config(text=f"{int(self.player_health)}/{self.max_health}")
        
        # 分数
        self.score_label.config(text=f"分数: {self.score}")
        
        # 金币
        self.coin_label.config(text=f"💰 {self.coins}")
        
        # 波次
        self.wave_label.config(text=f"波次: {self.wave}")
        
        # 炸弹
        self.bomb_label.config(text=f"💣 {self.bomb_count}")
    
    def check_wave(self):
        """检查波次"""
        if not self.enemies and self.game_mode == GameMode.WAVE:
            self.wave += 1
            
            # 每5波出现BOSS
            if self.wave % 5 == 0:
                self.boss_wave = True
            
            # 增加难度
            self.enemy_spawn_rate = max(0.5, 2.0 - self.wave * 0.1)
            
            # 显示波次信息
            self.show_wave_message()
    
    def show_wave_message(self):
        """显示波次信息"""
        wave_text = f"波次 {self.wave}"
        if self.boss_wave:
            wave_text = f"BOSS 波次 {self.wave}"
        
        text_id = self.canvas.create_text(
            self.width // 2,
            self.height // 2,
            text=wave_text,
            font=("Microsoft YaHei", 40, "bold"),
            fill="#FF9800"
        )
        
        # 淡出效果
        def fade_out(alpha=1.0):
            if alpha > 0:
                self.canvas.itemconfig(text_id, fill=f"#FF{int(alpha*200):02x}{int(alpha*100):02x}")
                self.root.after(50, fade_out, alpha - 0.05)
            else:
                self.canvas.delete(text_id)
        
        self.root.after(1000, fade_out)
    
    def game_loop(self):
        """游戏主循环"""
        if not self.game_running or self.game_paused:
            return
        
        # 清除画布
        self.canvas.delete("all")
        
        # 绘制背景
        self.draw_background()
        
        # 更新状态
        if self.invincible:
            self.invincible_timer -= 1
            if self.invincible_timer <= 0:
                self.invincible = False
        
        if self.slow_time:
            self.slow_time_timer -= 1
            if self.slow_time_timer <= 0:
                self.slow_time = False
        
        if self.magnet_active:
            self.magnet_timer -= 1
            if self.magnet_timer <= 0:
                self.magnet_active = False
        
        if self.double_score:
            self.double_score_timer -= 1
            if self.double_score_timer <= 0:
                self.double_score = False
        
        # 自动射击
        if " " in self.keys_pressed:
            self.player_shoot()
        
        # 移动玩家
        self.move_player()
        
        # 生成敌人
        self.spawn_enemy()
        
        # 移动和更新
        self.move_enemies()
        self.move_bullets()
        self.move_powerups()
        self.update_particles()
        self.update_explosions()
        
        # 碰撞检测
        self.check_collisions()
        
        # 检查波次
        self.check_wave()
        
        # 更新HUD
        self.update_hud()
        
        # 检查游戏结束
        if self.player_health <= 0:
            self.game_over()
            return
        
        # 继续游戏循环
        if self.game_running and not self.game_paused:
            self.root.after(16, self.game_loop)  # ~60 FPS
    
    def on_key_press(self, event):
        """按键按下"""
        if not self.game_running:
            return
        
        self.keys_pressed.add(event.keysym)
        
        if event.keysym == "p" or event.keysym == "P":
            self.game_paused = not self.game_paused
            if not self.game_paused:
                self.game_loop()
        elif event.keysym == "b" or event.keysym == "B":
            self.use_bomb()
        elif event.keysym == "Escape":
            if self.game_paused:
                self.game_running = False
                self.show_main_menu()
            else:
                self.game_paused = True
    
    def on_key_release(self, event):
        """按键释放"""
        if event.keysym in self.keys_pressed:
            self.keys_pressed.remove(event.keysym)
    
    def on_mouse_click(self, event):
        """鼠标点击"""
        if not self.game_running or self.game_paused:
            return
        
        # 可以添加鼠标控制功能
        pass
    
    def game_over(self):
        """游戏结束"""
        self.game_running = False
        
        # 更新最高分
        if self.score > self.high_score:
            self.high_score = self.score
            self.save_game_data()
        
        # 保存金币
        self.save_game_data()
        
        # 显示游戏结束画面
        self.canvas.create_rectangle(
            0, 0, self.width, self.height,
            fill="black", stipple="gray25"
        )
        
        self.canvas.create_text(
            self.width // 2,
            self.height // 2 - 100,
            text="游戏结束",
            font=("Microsoft YaHei", 60, "bold"),
            fill="#F44336"
        )
        
        self.canvas.create_text(
            self.width // 2,
            self.height // 2 - 20,
            text=f"最终分数: {self.score}",
            font=("Microsoft YaHei", 36),
            fill="#4CAF50"
        )
        
        self.canvas.create_text(
            self.width // 2,
            self.height // 2 + 40,
            text=f"最高分: {self.high_score}",
            font=("Microsoft YaHei", 28),
            fill="#FF9800"
        )
        
        self.canvas.create_text(
            self.width // 2,
            self.height // 2 + 100,
            text=f"金币: {self.coins}",
            font=("Microsoft YaHei", 24),
            fill="gold"
        )
        
        # 按钮
        restart_btn = tk.Button(
            self.root,
            text="重新开始",
            command=lambda: self.start_game(),
            font=("Microsoft YaHei", 20),
            bg="#4CAF50",
            fg="white",
            width=15
        )
        
        menu_btn = tk.Button(
            self.root,
            text="返回主菜单",
            command=self.show_main_menu,
            font=("Microsoft YaHei", 20),
            bg="#2196F3",
            fg="white",
            width=15
        )
        
        self.canvas.create_window(
            self.width // 2,
            self.height // 2 + 180,
            window=restart_btn
        )
        
        self.canvas.create_window(
            self.width // 2,
            self.height // 2 + 240,
            window=menu_btn
        )
    
    def clear_canvas(self):
        """清空画布"""
        self.canvas.delete("all")
    
    def load_game_data(self):
        """加载游戏数据"""
        try:
            if os.path.exists("game_data.json"):
                with open("game_data.json", "r") as f:
                    data = json.load(f)
                    self.high_score = data.get("high_score", 0)
                    self.coins = data.get("coins", 0)
        except:
            self.high_score = 0
            self.coins = 0
    
    def save_game_data(self):
        """保存游戏数据"""
        try:
            data = {
                "high_score": self.high_score,
                "coins": self.coins
            }
            with open("game_data.json", "w") as f:
                json.dump(data, f)
        except:
            pass

def main():
    root = tk.Tk()
    game = SpaceShooter(root)
    root.mainloop()

if __name__ == "__main__":
    main()