// 暗物质领域成就
            {
                id: "dark_explorer",
                name: "暗物质探索者",
                description: "在暗物质领域收集200,000暗物质",
                target: 200000,
                reward: 12,
                icon: "fa-moon",
                level: 3
            },
            {
                id: "dark_master",
                name: "暗物质大师",
                description: "在暗物质领域收集2,000,000暗物质",
                target: 2000000,
                reward: 20,
                icon: "fa-circle",
                level: 3
            },
            {
                id: "dark_upgrader",
                name: "暗物质升级者",
                description: "在暗物质领域达到100级总升级",
                target: 100,
                reward: 15,
                icon: "fa-cogs",
                level: 3
            },
            {
                id: "dark_speedster",
                name: "暗物质速行者",
                description: "在暗物质领域达到2,000/秒产量",
                target: 2000,
                reward: 25,
                icon: "fa-bolt",
                level: 3
            },
            {
                id: "dark_completionist",
                name: "暗物质完成者",
                description: "完成暗物质领域所有目标",
                target: 1,
                reward: 30,
                icon: "fa-check-circle",
                level: 3
            },
            
            // 能量核心成就
            {
                id: "energy_explorer",
                name: "能量探索者",
                description: "在能量核心收集1,000,000能量核心",
                target: 1000000,
                reward: 15,
                icon: "fa-bolt",
                level: 4
            },
            {
                id: "energy_master",
                name: "能量大师",
                description: "在能量核心收集10,000,000能量核心",
                target: 10000000,
                reward: 25,
                icon: "fa-power-off",
                level: 4
            },
            {
                id: "energy_upgrader",
                name: "能量升级者",
                description: "在能量核心达到150级总升级",
                target: 150,
                reward: 20,
                icon: "fa-cogs",
                level: 4
            },
            {
                id: "energy_speedster",
                name: "能量速行者",
                description: "在能量核心达到10,000/秒产量",
                target: 10000,
                reward: 30,
                icon: "fa-bolt",
                level: 4
            },
            {
                id: "energy_completionist",
                name: "能量完成者",
                description: "完成能量核心所有目标",
                target: 1,
                reward: 40,
                icon: "fa-check-circle",
                level: 4
            },
            
            // 宇宙尽头成就
            {
                id: "cosmic_explorer",
                name: "宇宙探索者",
                description: "在宇宙尽头收集5,000,000宇宙尘埃",
                target: 5000000,
                reward: 20,
                icon: "fa-star",
                level: 5
            },
            {
                id: "cosmic_master",
                name: "宇宙大师",
                description: "在宇宙尽头收集50,000,000宇宙尘埃",
                target: 50000000,
                reward: 35,
                icon: "fa-globe-americas",
                level: 5
            },
            {
                id: "cosmic_upgrader",
                name: "宇宙升级者",
                description: "在宇宙尽头达到200级总升级",
                target: 200,
                reward: 25,
                icon: "fa-cogs",
                level: 5
            },
            {
                id: "cosmic_speedster",
                name: "宇宙速行者",
                description: "在宇宙尽头达到50,000/秒产量",
                target: 50000,
                reward: 40,
                icon: "fa-bolt",
                level: 5
            },
            {
                id: "cosmic_completionist",
                name: "宇宙完成者",
                description: "完成宇宙尽头所有目标",
                target: 1,
                reward: 50,
                icon: "fa-check-circle",
                level: 5
            },
            
            // 量子领域成就
            {
                id: "quantum_explorer",
                name: "量子探索者",
                description: "在量子领域收集20,000,000量子粒子",
                target: 20000000,
                reward: 25,
                icon: "fa-atom",
                level: 6
            },
            {
                id: "quantum_master",
                name: "量子大师",
                description: "在量子领域收集200,000,000量子粒子",
                target: 200000000,
                reward: 45,
                icon: "fa-microchip",
                level: 6
            },
            {
                id: "quantum_upgrader",
                name: "量子升级者",
                description: "在量子领域达到300级总升级",
                target: 300,
                reward: 30,
                icon: "fa-cogs",
                level: 6
            },
            {
                id: "quantum_speedster",
                name: "量子速行者",
                description: "在量子领域达到200,000/秒产量",
                target: 200000,
                reward: 50,
                icon: "fa-bolt",
                level: 6
            },
            {
                id: "quantum_completionist",
                name: "量子完成者",
                description: "完成量子领域所有目标",
                target: 1,
                reward: 60,
                icon: "fa-check-circle",
                level: 6
            },
            
            // 维度之门成就
            {
                id: "dimension_explorer",
                name: "维度探索者",
                description: "在维度之门收集100,000,000维度碎片",
                target: 100000000,
                reward: 30,
                icon: "fa-cube",
                level: 7
            },
            {
                id: "dimension_master",
                name: "维度大师",
                description: "在维度之门收集1,000,000,000维度碎片",
                target: 1000000000,
                reward: 55,
                icon: "fa-dice-d20",
                level: 7
            },
            {
                id: "dimension_upgrader",
                name: "维度升级者",
                description: "在维度之门达到400级总升级",
                target: 400,
                reward: 35,
                icon: "fa-cogs",
                level: 7
            },
            {
                id: "dimension_speedster",
                name: "维度速行者",
                description: "在维度之门达到1,000,000/秒产量",
                target: 1000000,
                reward: 60,
                icon: "fa-bolt",
                level: 7
            },
            {
                id: "dimension_completionist",
                name: "维度完成者",
                description: "完成维度之门所有目标",
                target: 1,
                reward: 70,
                icon: "fa-check-circle",
                level: 7
            },
            
            // 创世之源成就
            {
                id: "creation_explorer",
                name: "创世探索者",
                description: "在创世之源收集500,000,000创世能量",
                target: 500000000,
                reward: 35,
                icon: "fa-infinity",
                level: 8
            },
            {
                id: "creation_master",
                name: "创世大师",
                description: "在创世之源收集5,000,000,000创世能量",
                target: 5000000000,
                reward: 65,
                icon: "fa-crown",
                level: 8
            },
            {
                id: "creation_upgrader",
                name: "创世升级者",
                description: "在创世之源达到500级总升级",
                target: 500,
                reward: 40,
                icon: "fa-cogs",
                level: 8
            },
            {
                id: "creation_speedster",
                name: "创世速行者",
                description: "在创世之源达到5,000,000/秒产量",
                target: 5000000,
                reward: 70,
                icon: "fa-bolt",
                level: 8
            },
            {
                id: "creation_completionist",
                name: "创世完成者",
                description: "完成创世之源所有目标",
                target: 1,
                reward: 80,
                icon: "fa-check-circle",
                level: 8
            },
            
            // 全局成就
            {
                id: "first_million",
                name: "百万富翁",
                description: "累计收集100万资源",
                target: 1000000,
                reward: 10,
                icon: "fa-money-bill-wave",
                level: 0
            },
            {
                id: "upgrade_expert",
                name: "升级专家",
                description: "总升级等级达到1000级",
                target: 1000,
                reward: 20,
                icon: "fa-cogs",
                level: 0
            },
            {
                id: "automation_king",
                name: "自动化之王",
                description: "每秒产量达到10,000",
                target: 10000,
                reward: 25,
                icon: "fa-crown",
                level: 0
            },
            {
                id: "speed_demon",
                name: "速度恶魔",
                description: "每秒产量达到100,000",
                target: 100000,
                reward: 35,
                icon: "fa-bolt",
                level: 0
            },
            {
                id: "universe_explorer",
                name: "宇宙探险家",
                description: "解锁所有关卡",
                target: 8,
                reward: 30,
                icon: "fa-rocket",
                level: 0
            },
            {
                id: "tech_master",
                name: "科技大师",
                description: "解锁所有科技",
                target: 15,
                reward: 60,
                icon: "fa-flask",
                level: 0
            },
            {
                id: "prestige_master",
                name: "重生大师",
                description: "完成5次重生",
                target: 5,
                reward: 100,
                icon: "fa-infinity",
                level: 0
            }
        ];

        // 游戏状态
        const gameState = {
            currentLevel: 1,
            resources: 0,
            totalCollected: 0,
            productionRate: 1,
            lastUpdate: Date.now(),
            playTime: 0,
            levelProgress: {},
            upgrades: {},
            techUnlocked: {},
            achievementsUnlocked: {},
            prestigePoints: 0,
            prestigeCount: 0,
            prestigeResources: {
                timeCrystals: 0,
                spaceGems: 0,
                darkMatter: 0,
                energyCores: 0,
                cosmicDust: 0,
                quantumParticles: 0,
                dimensionFragments: 0,
                creationEnergy: 0
            },
            prestigeMultiplier: 1
        };

        // 初始化游戏
        function initGame() {
            // 初始化关卡进度
            levels.forEach(level => {
                if (!gameState.levelProgress[level.id]) {
                    gameState.levelProgress[level.id] = {
                        unlocked: level.id === 1,
                        completed: false,
                        resourcesCollected: 0,
                        resources: 0,
                        productionRate: level.baseProduction
                    };
                }
            });
            
            // 初始化升级状态
            levels.forEach(level => {
                if (!gameState.upgrades[level.id]) {
                    gameState.upgrades[level.id] = {};
                    level.upgrades.forEach(upgrade => {
                        gameState.upgrades[level.id][upgrade.id] = {
                            level: 0,
                            cost: upgrade.baseCost
                        };
                    });
                }
            });
            
            // 初始化科技树
            techTree.forEach(tech => {
                if (gameState.techUnlocked[tech.id] === undefined) {
                    gameState.techUnlocked[tech.id] = false;
                }
            });
            
            // 初始化成就
            achievements.forEach(achievement => {
                if (gameState.achievementsUnlocked[achievement.id] === undefined) {
                    gameState.achievementsUnlocked[achievement.id] = false;
                }
            });
            
            loadGame();
            updateLevelDisplay();
            updateUpgradesDisplay();
            updateLevelsGrid();
            updateTechTree();
            updateAchievements();
            updatePrestigeDisplay();
            
            // 初始化标签页切换
            initTabs();
            
            // 游戏主循环
            setInterval(gameLoop, 100);
            
            // 每秒更新一次显示
            setInterval(updateDisplay, 1000);
        }

        // 初始化标签页
        function initTabs() {
            const tabs = document.querySelectorAll('.tab');
            tabs.forEach(tab => {
                tab.addEventListener('click', () => {
                    // 移除所有活动标签
                    tabs.forEach(t => t.classList.remove('active'));
                    // 添加当前活动标签
                    tab.classList.add('active');
                    
                    // 隐藏所有内容
                    document.querySelectorAll('.tab-content').forEach(content => {
                        content.classList.remove('active');
                    });
                    
                    // 显示对应内容
                    const tabId = tab.getAttribute('data-tab');
                    document.getElementById(`${tabId}-tab`).classList.add('active');
                });
            });
        }

        // 游戏主循环
        function gameLoop() {
            const now = Date.now();
            const deltaTime = (now - gameState.lastUpdate) / 1000;
            gameState.lastUpdate = now;
            
            // 增加游戏时间
            gameState.playTime += deltaTime;
            
            // 计算科技加成
            const techMultiplier = calculateTechMultiplier();
            
            // 生成资源
            const currentLevelData = getCurrentLevelData();
            const currentLevelState = gameState.levelProgress[gameState.currentLevel];
            const resourcesGenerated = currentLevelState.productionRate * deltaTime * techMultiplier;
            
            currentLevelState.resources += resourcesGenerated;
            currentLevelState.resourcesCollected += resourcesGenerated;
            gameState.totalCollected += resourcesGenerated;
            
            // 检查是否完成当前关卡
            if (!currentLevelState.completed && 
                currentLevelState.resourcesCollected >= currentLevelData.targetAmount) {
                currentLevelState.completed = true;
                
                // 解锁下一关
                if (gameState.currentLevel < levels.length) {
                    gameState.levelProgress[gameState.currentLevel + 1].unlocked = true;
                }
                
                showNotification(`恭喜！你已完成 ${currentLevelData.name} 关卡！`);
                updateLevelsGrid();
                checkAchievements();
            }
            
            updateDisplay();
        }

        // 计算科技加成
        function calculateTechMultiplier() {
            let multiplier = 1;
            
            // 生产加速
            if (gameState.techUnlocked.production_boost) {
                multiplier *= 1.1;
            }
            
            // 量子飞跃
            if (gameState.techUnlocked.quantum_leap) {
                multiplier *= 2;
            }
            
            // 时间扭曲
            if (gameState.techUnlocked.time_warp) {
                multiplier *= 1.5;
            }
            
            // 多元宇宙连接
            if (gameState.techUnlocked.multiverse_connection) {
                multiplier *= 2;
            }
            
            // 资源回收
            if (gameState.techUnlocked.resource_recycling) {
                multiplier *= 1.3;
            }
            
            // 并行处理
            if (gameState.techUnlocked.parallel_processing) {
                multiplier *= 1.4;
            }
            
            // 维度转换
            if (gameState.techUnlocked.dimensional_shift) {
                multiplier *= 2;
            }
            
            // 时间压缩
            if (gameState.techUnlocked.time_compression) {
                multiplier *= 1.75;
            }
            
            // 奇点引擎
            if (gameState.techUnlocked.singularity_engine) {
                multiplier *= 4;
            }
            
            return multiplier;
        }

        // 获取当前关卡数据
        function getCurrentLevelData() {
            return levels.find(level => level.id === gameState.currentLevel);
        }

        // 获取当前关卡状态
        function getCurrentLevelState() {
            return gameState.levelProgress[gameState.currentLevel];
        }

        // 更新显示
        function updateDisplay() {
            const currentLevelData = getCurrentLevelData();
            const currentLevelState = getCurrentLevelState();
            
            document.getElementById('resource-amount').textContent = Math.floor(currentLevelState.resources).toLocaleString();
            document.getElementById('resource-name').textContent = currentLevelData.resourceName;
            document.getElementById('resource-core-icon').textContent = currentLevelData.resourceIcon;
            document.getElementById('production-rate').textContent = (currentLevelState.productionRate * calculateTechMultiplier()).toFixed(1);
            document.getElementById('total-collected').textContent = Math.floor(gameState.totalCollected).toLocaleString();
            
            // 格式化游戏时间
            const hours = Math.floor(gameState.playTime / 3600);
            const minutes = Math.floor((gameState.playTime % 3600) / 60);
            const seconds = Math.floor(gameState.playTime % 60);
            document.getElementById('play-time').textContent = 
                `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
            
            // 更新关卡进度
            const progress = currentLevelState.resourcesCollected / currentLevelData.targetAmount * 100;
            document.getElementById('level-progress-bar').style.width = `${Math.min(progress, 100)}%`;
            document.getElementById('level-target').textContent = 
                `目标: ${Math.floor(currentLevelState.resourcesCollected).toLocaleString()}/${currentLevelData.targetAmount.toLocaleString()} ${currentLevelData.resourceName}`;
            
            // 更新关卡进度百分比
            document.getElementById('level-progress').textContent = `${Math.min(progress, 100).toFixed(1)}%`;
            
            // 显示/隐藏下一关按钮
            const nextLevelBtn = document.getElementById('next-level-btn');
            if (currentLevelState.completed && gameState.currentLevel < levels.length) {
                nextLevelBtn.style.display = 'block';
                nextLevelBtn.textContent = `进入 ${levels[gameState.currentLevel].name}`;
            } else {
                nextLevelBtn.style.display = 'none';
            }
            
            updateUpgradesDisplay();
            updatePrestigeDisplay();
        }

        // 更新关卡显示
        function updateLevelDisplay() {
            const currentLevelData = getCurrentLevelData();
            
            document.getElementById('current-level-name').textContent = currentLevelData.name;
            document.body.style.background = currentLevelData.background;
        }

        // 更新升级显示
        function updateUpgradesDisplay() {
            const currentLevelData = getCurrentLevelData();
            const currentLevelState = getCurrentLevelState();
            const upgradesContainer = document.getElementById('upgrades-container');
            upgradesContainer.innerHTML = '';
            
            currentLevelData.upgrades.forEach(upgrade => {
                const upgradeState = gameState.upgrades[gameState.currentLevel][upgrade.id];
                const cost = calculateUpgradeCost(upgrade);
                const canAfford = currentLevelState.resources >= cost;
                const isMaxed = upgradeState.level >= upgrade.maxLevel;

                const upgradeElement = document.createElement('div');
                upgradeElement.className = 'upgrade';
                
                if (!isMaxed) {
                    upgradeElement.onclick = () => buyUpgrade(upgrade.id);
                }

                upgradeElement.innerHTML = `
                    <div class="upgrade-header">
                        <span class="upgrade-name">${upgrade.name}</span>
                        <span class="upgrade-cost">${isMaxed ? '已满级' : cost.toLocaleString()}</span>
                    </div>
                    <div class="upgrade-level">等级: <span>${upgradeState.level}/${upgrade.maxLevel}</span></div>
                    <div class="upgrade-description">${upgrade.description}</div>
                    <div class="flex justify-between items-center mt-2">
                        <span class="text-white font-semibold">+${upgrade.production}/秒</span>
                    </div>
                `;

                if (isMaxed) {
                    upgradeElement.classList.add('opacity-50');
                } else if (!canAfford) {
                    upgradeElement.classList.add('opacity-50');
                }

                upgradesContainer.appendChild(upgradeElement);
            });
        }

        // 计算升级成本
        function calculateUpgradeCost(upgrade) {
            const upgradeState = gameState.upgrades[gameState.currentLevel][upgrade.id];
            // 应用成本降低科技
            let costMultiplier = 1;
            if (gameState.techUnlocked.cost_reduction) {
                costMultiplier *= 0.95;
            }
            if (gameState.techUnlocked.energy_efficiency) {
                costMultiplier *= 0.75;
            }
            
            return Math.floor(upgrade.baseCost * Math.pow(1.5, upgradeState.level) * costMultiplier);
        }

        // 更新关卡网格
        function updateLevelsGrid() {
            const levelsGrid = document.getElementById('levels-grid');
            levelsGrid.innerHTML = '';
            
            levels.forEach(level => {
                const levelState = gameState.levelProgress[level.id];
                const levelElement = document.createElement('div');
                
                let classes = 'level-card';
                if (level.id === gameState.currentLevel) classes += ' active';
                if (levelState.completed) classes += ' completed';
                if (!levelState.unlocked) classes += ' locked';
                
                levelElement.className = classes;
                if (levelState.unlocked) {
                    levelElement.onclick = () => switchLevel(level.id);
                }
                
                levelElement.innerHTML = `
                    <div class="level-icon">${level.resourceIcon}</div>
                    <div class="level-name">${level.name}</div>
                    <div class="level-status">${levelState.completed ? '已完成' : levelState.unlocked ? '进行中' : '锁定'}</div>
                `;
                
                levelsGrid.appendChild(levelElement);
            });
        }

        // 更新科技树
        function updateTechTree() {
            const techTreeContainer = document.getElementById('tech-tree-container');
            techTreeContainer.innerHTML = '';
            
            techTree.forEach(tech => {
                const techElement = document.createElement('div');
                
                let classes = 'tech-node';
                if (gameState.techUnlocked[tech.id]) {
                    classes += ' unlocked';
                } else if (isTechAvailable(tech)) {
                    classes += ' available';
                }
                
                techElement.className = classes;
                techElement.onclick = () => unlockTech(tech.id);
                
                techElement.innerHTML = `
                    <div class="tech-node-header">
                        <span class="tech-node-name"><i class="fas ${tech.icon} mr-2"></i>${tech.name}</span>
                        <span class="tech-node-cost">${tech.cost}</span>
                    </div>
                    <div class="tech-node-description">${tech.description}</div>
                `;
                
                techTreeContainer.appendChild(techElement);
            });
        }

        // 检查科技是否可用
        function isTechAvailable(tech) {
            // 检查依赖
            for (const dep of tech.dependencies) {
                if (!gameState.techUnlocked[dep]) {
                    return false;
                }
            }
            
            // 检查是否有足够的时空精华
            return gameState.prestigePoints >= tech.cost && !gameState.techUnlocked[tech.id];
        }

        // 更新成就
        function updateAchievements() {
            const achievementsContainer = document.getElementById('achievements-container');
            achievementsContainer.innerHTML = '';
            
            // 按关卡分组显示成就
            const levelAchievements = {};
            achievements.forEach(achievement => {
                if (!levelAchievements[achievement.level]) {
                    levelAchievements[achievement.level] = [];
                }
                levelAchievements[achievement.level].push(achievement);
            });
            
            // 显示全局成就
            if (levelAchievements[0]) {
                const globalSection = document.createElement('div');
                globalSection.className = 'col-span-full mb-4';
                globalSection.innerHTML = `<h3 class="text-xl font-bold text-white mb-2">全局成就</h3>`;
                achievementsContainer.appendChild(globalSection);
                
                levelAchievements[0].forEach(achievement => {
                    const achievementElement = createAchievementElement(achievement);
                    achievementsContainer.appendChild(achievementElement);
                });
            }
            
            // 显示各关卡成就
            for (let level = 1; level <= 8; level++) {
                if (levelAchievements[level]) {
                    const levelSection = document.createElement('div');
                    levelSection.className = 'col-span-full mb-4 mt-6';
                    levelSection.innerHTML = `<h3 class="text-xl font-bold text-white mb-2">${levels[level-1].name}成就</h3>`;
                    achievementsContainer.appendChild(levelSection);
                    
                    levelAchievements[level].forEach(achievement => {
                        const achievementElement = createAchievementElement(achievement);
                        achievementsContainer.appendChild(achievementElement);
                    });
                }
            }
        }

        // 创建成就元素
        function createAchievementElement(achievement) {
            const achievementElement = document.createElement('div');
            
            let classes = 'achievement';
            if (gameState.achievementsUnlocked[achievement.id]) {
                classes += ' unlocked';
            }
            
            const progress = getAchievementProgress(achievement);
            
            achievementElement.className = classes;
            achievementElement.innerHTML = `
                <div class="flex items-center mb-2">
                    <i class="fas ${achievement.icon} text-xl mr-3 ${gameState.achievementsUnlocked[achievement.id] ? 'text-yellow-400' : 'text-gray-400'}"></i>
                    <div>
                        <h4 class="font-bold ${gameState.achievementsUnlocked[achievement.id] ? 'text-white' : 'text-gray-300'}">${achievement.name}</h4>
                        <p class="text-sm ${gameState.achievementsUnlocked[achievement.id] ? 'text-gray-200' : 'text-gray-500'}">${achievement.description}</p>
                    </div>
                </div>
                <div class="achievement-progress">
                    <div class="achievement-progress-fill" style="width: ${progress}%"></div>
                </div>
                <div class="flex justify-between mt-2 text-sm">
                    <span class="${gameState.achievementsUnlocked[achievement.id] ? 'text-green-400' : 'text-gray-400'}">
                        ${gameState.achievementsUnlocked[achievement.id] ? '已解锁' : '进度: ' + progress + '%'}
                    </span>
                    <span class="text-yellow-400">奖励: ${achievement.reward} 时空精华</span>
                </div>
            `;
            
            return achievementElement;
        }

        // 获取成就进度
        function getAchievementProgress(achievement) {
            let current = 0;
            
            switch(achievement.id) {
                case 'first_million':
                    current = gameState.totalCollected;
                    break;
                case 'upgrade_expert':
                    current = Object.values(gameState.upgrades).reduce((total, levelUpgrades) => {
                        return total + Object.values(levelUpgrades).reduce((sum, upgrade) => sum + upgrade.level, 0);
                    }, 0);
                    break;
                case 'automation_king':
                    current = Math.max(...Object.values(gameState.levelProgress).map(level => level.productionRate));
                    break;
                case 'speed_demon':
                    current = Math.max(...Object.values(gameState.levelProgress).map(level => level.productionRate));
                    break;
                case 'universe_explorer':
                    current = Object.values(gameState.levelProgress).filter(level => level.unlocked).length;
                    break;
                case 'tech_master':
                    current = Object.values(gameState.techUnlocked).filter(unlocked => unlocked).length;
                    break;
                case 'prestige_master':
                    current = gameState.prestigeCount;
                    break;
                default:
                    // 关卡特定成就
                    if (achievement.level > 0) {
                        const levelState = gameState.levelProgress[achievement.level];
                        if (!levelState) break;
                        
                        if (achievement.id.includes('completionist')) {
                            current = levelState.completed ? 1 : 0;
                        } else if (achievement.id.includes('upgrader')) {
                            current = Object.values(gameState.upgrades[achievement.level] || {}).reduce((sum, upgrade) => sum + upgrade.level, 0);
                        } else if (achievement.id.includes('speedster')) {
                            current = levelState.productionRate;
                        } else {
                            current = levelState.resourcesCollected;
                        }
                    }
            }
            
            return Math.min(100, Math.floor((current / achievement.target) * 100));
        }

        // 检查成就
        function checkAchievements() {
            achievements.forEach(achievement => {
                if (!gameState.achievementsUnlocked[achievement.id]) {
                    const progress = getAchievementProgress(achievement);
                    
                    if (progress >= 100) {
                        gameState.achievementsUnlocked[achievement.id] = true;
                        gameState.prestigePoints += achievement.reward;
                        showNotification(`成就解锁: ${achievement.name}! 获得 ${achievement.reward} 时空精华`);
                        updateAchievements();
                        updatePrestigeDisplay();
                    }
                }
            });
        }

        // 更新重生显示
        function updatePrestigeDisplay() {
            // 计算重生奖励
            let reward = 0;
            for (let i = 1; i <= levels.length; i++) {
                if (gameState.levelProgress[i] && gameState.levelProgress[i].completed) {
                    reward += i * 10; // 每完成一关获得基础奖励
                    reward += Math.sqrt(gameState.levelProgress[i].resourcesCollected) * 0.1; // 根据收集的资源增加奖励
                }
            }
            
            // 应用重生加成科技
            if (gameState.techUnlocked.prestige_boost) {
                reward *= 1.2;
            }
            
            // 应用全局倍率
            reward *= gameState.prestigeMultiplier;
            
            document.getElementById('prestige-reward').textContent = Math.floor(reward).toLocaleString();
            
            // 检查是否所有关卡都已完成
            const allLevelsCompleted = Object.values(gameState.levelProgress).every(level => level.completed);
            const prestigeBtn = document.getElementById('prestige-btn');
            if (allLevelsCompleted) {
                prestigeBtn.disabled = false;
                prestigeBtn.textContent = '重生';
            } else {
                prestigeBtn.disabled = true;
                prestigeBtn.textContent = '需要完成所有关卡才能重生';
            }
            
            // 更新重生资源显示
            const resourcesContainer = document.getElementById('prestige-resources');
            resourcesContainer.innerHTML = '';
            
            Object.keys(gameState.prestigeResources).forEach((resource, index) => {
                const level = levels[index];
                if (!level) return;
                
                const resourceElement = document.createElement('div');
                resourceElement.className = 'resource-item';
                
                resourceElement.innerHTML = `
                    <div class="resource-icon">${level.resourceIcon}</div>
                    <div class="resource-count">${gameState.prestigeResources[resource].toLocaleString()}</div>
                    <div class="resource-name">${level.resourceName}</div>
                `;
                
                resourcesContainer.appendChild(resourceElement);
            });
        }

        // 切换关卡
        function switchLevel(levelId) {
            if (!gameState.levelProgress[levelId].unlocked) {
                showNotification('该关卡尚未解锁！');
                return;
            }
            
            gameState.currentLevel = levelId;
            
            updateLevelDisplay();
            updateUpgradesDisplay();
            updateLevelsGrid();
            showNotification(`已切换到 ${getCurrentLevelData().name}`);
        }

        // 购买升级
        function buyUpgrade(upgradeId) {
            tryBuyUpgrade(upgradeId);
        }

        // 尝试购买升级
        function tryBuyUpgrade(upgradeId) {
            const currentLevelData = getCurrentLevelData();
            const currentLevelState = getCurrentLevelState();
            const upgrade = currentLevelData.upgrades.find(u => u.id === upgradeId);
            const upgradeState = gameState.upgrades[gameState.currentLevel][upgradeId];
            
            if (!upgrade || upgradeState.level >= upgrade.maxLevel) return;

            const cost = calculateUpgradeCost(upgrade);
            if (currentLevelState.resources >= cost) {
                currentLevelState.resources -= cost;
                upgradeState.level++;
                
                // 更新生产速率
                currentLevelState.productionRate += upgrade.production;
                
                updateDisplay();
                updateUpgradesDisplay();
                showNotification(`成功购买 ${upgrade.name} 升级！`);
                checkAchievements();
            } else {
                showNotification(`${currentLevelData.resourceName} 不足！`);
            }
        }

        // 解锁科技
        function unlockTech(techId) {
            const tech = techTree.find(t => t.id === techId);
            
            if (!tech) return;
            
            if (gameState.techUnlocked[techId]) {
                showNotification('该科技已经解锁！');
                return;
            }
            
            if (!isTechAvailable(tech)) {
                showNotification('无法解锁该科技！');
                return;
            }
            
            if (gameState.prestigePoints >= tech.cost) {
                gameState.prestigePoints -= tech.cost;
                gameState.techUnlocked[techId] = true;
                
                updateTechTree();
                updatePrestigeDisplay();
                showNotification(`成功解锁科技：${tech.name}`);
                checkAchievements();
            } else {
                showNotification('时空精华不足！');
            }
        }

        // 进入下一关
        function nextLevel() {
            if (gameState.currentLevel < levels.length) {
                switchLevel(gameState.currentLevel + 1);
            }
        }

        // 重生
        function prestige() {
            // 检查是否所有关卡都已完成
            const allLevelsCompleted = Object.values(gameState.levelProgress).every(level => level.completed);
            if (!allLevelsCompleted) {
                showNotification('需要完成所有关卡才能重生！');
                return;
            }
            
            // 计算重生奖励
            let reward = 0;
            for (let i = 1; i <= levels.length; i++) {
                if (gameState.levelProgress[i] && gameState.levelProgress[i].completed) {
                    reward += i * 10;
                    reward += Math.sqrt(gameState.levelProgress[i].resourcesCollected) * 0.1;
                }
            }
            
            // 应用重生加成科技
            if (gameState.techUnlocked.prestige_boost) {
                reward *= 1.2;
            }
            
            // 应用全局倍率
            reward *= gameState.prestigeMultiplier;
            
            // 增加时空精华
            gameState.prestigePoints += Math.floor(reward);
            gameState.prestigeCount++;
            
            // 记录各关卡收集的资源
            levels.forEach(level => {
                if (gameState.levelProgress[level.id]) {
                    const resourceKey = level.resourceName.replace(/\s+/g, '').toLowerCase();
                    if (gameState.prestigeResources[resourceKey] !== undefined) {
                        gameState.prestigeResources[resourceKey] += Math.floor(gameState.levelProgress[level.id].resourcesCollected / 1000);
                    }
                }
            });
            
            // 重置游戏状态（但保留科技树和重生点数）
            const techUnlocked = {...gameState.techUnlocked};
            const prestigePoints = gameState.prestigePoints;
            const prestigeResources = {...gameState.prestigeResources};
            const prestigeCount = gameState.prestigeCount;
            const achievementsUnlocked = {...gameState.achievementsUnlocked};
            
            // 重新初始化游戏状态
            Object.assign(gameState, {
                currentLevel: 1,
                totalCollected: 0,
                lastUpdate: Date.now(),
                playTime: 0,
                levelProgress: {},
                upgrades: {},
                techUnlocked: techUnlocked,
                achievementsUnlocked: achievementsUnlocked,
                prestigePoints: prestigePoints,
                prestigeResources: prestigeResources,
                prestigeCount: prestigeCount,
                prestigeMultiplier: gameState.prestigeMultiplier * 1.1 // 每次重生增加10%的倍率
            });
            
            // 重新初始化关卡进度和升级
            levels.forEach(level => {
                gameState.levelProgress[level.id] = {
                    unlocked: level.id === 1,
                    completed: false,
                    resourcesCollected: 0,
                    resources: 0,
                    productionRate: level.baseProduction
                };
                
                gameState.upgrades[level.id] = {};
                level.upgrades.forEach(upgrade => {
                    gameState.upgrades[level.id][upgrade.id] = {
                        level: 0,
                        cost: upgrade.baseCost
                    };
                });
            });
            
            updateLevelDisplay();
            updateUpgradesDisplay();
            updateLevelsGrid();
            updateAchievements();
            updatePrestigeDisplay();
            
            showNotification(`重生完成！获得 ${Math.floor(reward).toLocaleString()} 时空精华`);
        }

        // 显示通知
        function showNotification(message) {
            const notification = document.getElementById('notification');
            notification.textContent = message;
            notification.classList.add('show');
            
            setTimeout(() => {
                notification.classList.remove('show');
            }, 3000);
        }

        // 保存游戏
        function saveGame() {
            const saveData = {
                ...gameState,
                lastUpdate: Date.now()
            };
            localStorage.setItem('timeExplorerEnhancedSave', JSON.stringify(saveData));
            showNotification('游戏已保存！');
        }

        // 加载游戏
        function loadGame() {
            const saveData = localStorage.getItem('timeExplorerEnhancedSave');
            if (saveData) {
                const loadedState = JSON.parse(saveData);
                
                // 计算离线收益
                const now = Date.now();
                const offlineTime = (now - loadedState.lastUpdate) / 1000;
                const currentLevelState = loadedState.levelProgress[loadedState.currentLevel];
                const offlineResources = currentLevelState.productionRate * offlineTime * calculateTechMultiplier();
                
                // 恢复游戏状态
                Object.assign(gameState, loadedState);
                
                // 为离线期间生成资源
                gameState.levelProgress[gameState.currentLevel].resources += offlineResources;
                gameState.levelProgress[gameState.currentLevel].resourcesCollected += offlineResources;
                gameState.totalCollected += offlineResources;
                gameState.lastUpdate = now;
                
                // 确保所有关卡进度已初始化
                levels.forEach(level => {
                    if (!gameState.levelProgress[level.id]) {
                        gameState.levelProgress[level.id] = {
                            unlocked: level.id === 1,
                            completed: false,
                            resourcesCollected: 0,
                            resources: 0,
                            productionRate: level.baseProduction
                        };
                    }
                });
                
                // 确保所有升级已初始化
                levels.forEach(level => {
                    if (!gameState.upgrades[level.id]) {
                        gameState.upgrades[level.id] = {};
                        level.upgrades.forEach(upgrade => {
                            gameState.upgrades[level.id][upgrade.id] = {
                                level: 0,
                                cost: upgrade.baseCost
                            };
                        });
                    }
                });
                
                showNotification(`游戏已加载！离线期间获得了 ${Math.floor(offlineResources).toLocaleString()} ${getCurrentLevelData().resourceName}`);
            } else {
                showNotification('没有找到存档，开始新游戏！');
            }
        }

        // 重置游戏
        function resetGame() {
            if (confirm('确定要重置游戏吗？所有进度将丢失！')) {
                localStorage.removeItem('timeExplorerEnhancedSave');
                
                // 重置游戏状态
                gameState.currentLevel = 1;
                gameState.totalCollected = 0;
                gameState.lastUpdate = Date.now();
                gameState.playTime = 0;
                gameState.levelProgress = {};
                gameState.upgrades = {};
                gameState.techUnlocked = {};
                gameState.achievementsUnlocked = {};
                gameState.prestigePoints = 0;
                gameState.prestigeCount = 0;
                gameState.prestigeResources = {
                    timeCrystals: 0,
                    spaceGems: 0,
                    darkMatter: 0,
                    energyCores: 0,
                    cosmicDust: 0,
                    quantumParticles: 0,
                    dimensionFragments: 0,
                    creationEnergy: 0
                };
                gameState.prestigeMultiplier = 1;
                
                initGame();
                showNotification('游戏已重置！');
            }
        }

        // 初始化游戏
        window.onload = function() {
            initGame();
            document.getElementById('next-level-btn').onclick = nextLevel;
        };
    </script>
</body>
</html>