游戏失败音效实现

UnifiedAudioSystemGuide.md

@@ -1,285 +0,0 @@
-# 统一音频系统使用指南
-
-## 系统概述
-
-统一音频系统是一个完整的游戏音频管理解决方案，支持背景音乐、UI音效、敌人音效、环境音效和武器音效的分类管理。该系统提供了灵活的配置、独立的音量控制和便捷的静态访问接口。
-
-## 系统架构
-
-```
-AudioManager (核心管理器)
-    ├── 背景音乐管理 (Music)
-    ├── UI音效管理 (UI Sounds)
-    ├── 敌人音效管理 (Enemy Sounds) ← EnemyAudios
-    ├── 环境音效管理 (Environment Sounds)
-    └── 武器音效管理 (Weapon Sounds)
-
-AudioConfig (配置管理)
-    └── 统一音频资源配置
-```
-
-### 依赖关系
-- **AudioManager**: 核心音频管理器，提供分类音频播放和音量控制
-- **AudioConfig**: 音频配置管理器，统一管理所有音频资源配置
-- **EnemyAudios**: 敌人音效专用管理器，基于enemies.json配置
-- **Audio**: 静态访问接口，提供便捷的全局音频操作方法
-
-## 文件结构
-
-```
-assets/scripts/AudioManager/
-├── AudioManager.ts        # 核心音频管理器
-├── AudioConfig.ts         # 音频配置管理
-├── EnemyAudios.ts         # 敌人音效管理器
-└── SoundController.ts     # 音频控制器（UI相关）
-```
-
-## 音频分类
-
-### 1. 背景音乐 (Music)
-- **用途**: 游戏背景音乐
-- **特点**: 通常循环播放，音量较低
-- **示例**: 主菜单音乐、游戏内背景音乐、胜利/失败音乐
-
-### 2. UI音效 (UI Sounds)
-- **用途**: 用户界面交互音效
-- **特点**: 短促、清脆，提供即时反馈
-- **示例**: 按钮点击、菜单切换、提示音
-
-### 3. 敌人音效 (Enemy Sounds)
-- **用途**: 敌人相关的所有音效
-- **特点**: 基于敌人类型动态配置
-- **示例**: 攻击声、死亡声、受击声、行走声
-
-### 4. 环境音效 (Environment Sounds)
-- **用途**: 游戏环境和氛围音效
-- **特点**: 增强游戏沉浸感
-- **示例**: 风声、爆炸声、脚步声
-
-### 5. 武器音效 (Weapon Sounds)
-- **用途**: 武器相关音效
-- **特点**: 动作反馈，增强打击感
-- **示例**: 射击声、装弹声、切换武器声
-
-## 使用方法
-
-### 1. 基础音频播放
-
-```typescript
-// 播放背景音乐
-Audio.playMusic('audio/music/game_background', true);
-
-// 播放UI音效
-Audio.playUISound('audio/ui/button_click');
-
-// 播放敌人音效
-Audio.playEnemySound('audio/enemy/goblin_attack');
-
-// 播放环境音效
-Audio.playEnvironmentSound('audio/environment/explosion');
-
-// 播放武器音效
-Audio.playWeaponSound('audio/weapon/gun_shot');
-```
-
-### 2. 音量控制
-
-```typescript
-// 设置音乐音量
-Audio.setMusicVolume(0.6);
-
-// 设置UI音效音量
-Audio.setUISoundVolume(0.8);
-
-// 设置敌人音效音量
-Audio.setEnemySoundVolume(0.7);
-
-// 设置所有音效音量
-Audio.setAllSoundVolume(0.5);
-
-// 静音所有音频
-Audio.muteAll();
-
-// 只静音音效，保留音乐
-Audio.muteAllSounds();
-```
-
-### 3. 敌人音效专用接口
-
-```typescript
-// 播放特定敌人的音效
-EnemyAudio.playAttackSound('goblin');
-EnemyAudio.playDeathSound('orc');
-EnemyAudio.playHitSound('skeleton');
-EnemyAudio.playWalkSound('zombie');
-EnemyAudio.playSpecialSound('boss');
-```
-
-### 4. 直接使用AudioManager
-
-```typescript
-const audioManager = AudioManager.getInstance();
-
-// 播放分类音效
-audioManager.playUISound('audio/ui/button_click');
-audioManager.playEnemySound('audio/enemy/attack');
-
-// 音量控制
-audioManager.setUISoundVolume(0.8);
-audioManager.setEnemySoundVolume(0.7);
-```
-
-## 配置管理
-
-### 音频配置文件 (AudioConfig.ts)
-
-```typescript
-// 获取音频配置
-const config = AudioConfig.getAudioConfig('audio/ui/button_click');
-
-// 获取分类配置
-const uiCategory = AudioConfig.getCategoryConfig(AudioType.UI_SOUND);
-
-// 获取默认音量
-const defaultVolume = AudioConfig.getDefaultVolume(AudioType.ENEMY_SOUND);
-
-// 验证音频路径
-const isValid = AudioConfig.isValidAudioPath('audio/music/background');
-```
-
-### 配置助手类
-
-```typescript
-// 快速访问各类音频配置
-const musicList = AudioConfigHelper.music;
-const uiSounds = AudioConfigHelper.uiSounds;
-const enemySounds = AudioConfigHelper.enemySounds;
-```
-
-## 敌人音效配置
-
-敌人音效通过 `enemies.json` 文件进行配置：
-
-```json
-{
-  "goblin": {
-    "audioConfig": {
-      "attack": "audio/enemy/goblin/attack",
-      "death": "audio/enemy/goblin/death",
-      "hit": "audio/enemy/goblin/hit",
-      "walk": "audio/enemy/goblin/walk"
-    }
-  }
-}
-```
-
-## 组件挂载
-
-### AudioManager 挂载
-1. 在场景中创建 `Canvas/AudioManager` 节点
-2. 添加 `AudioManager` 组件
-3. 系统会自动创建各类音频源节点
-
-### EnemyAudios 挂载
-1. `EnemyAudios` 作为 `AudioManager` 的子模块
-2. 通过单例模式访问，无需手动挂载
-3. 自动初始化并加载敌人音频配置
-
-## 最佳实践
-
-### 1. 音频文件组织
-```
-assets/audio/
-├── music/              # 背景音乐
-│   ├── main_menu.mp3
-│   └── game_background.mp3
-├── ui/                 # UI音效
-│   ├── button_click.wav
-│   └── menu_open.wav
-├── enemy/              # 敌人音效
-│   ├── goblin/
-│   └── orc/
-├── environment/        # 环境音效
-│   └── explosion.wav
-└── weapon/             # 武器音效
-    └── gun_shot.wav
-```
-
-### 2. 性能优化
-- 使用合适的音频格式（WAV用于短音效，MP3用于长音乐）
-- 控制同时播放的音效数量
-- 及时释放不需要的音频资源
-
-### 3. 音量平衡
-- 背景音乐: 0.4-0.6
-- UI音效: 0.6-0.8
-- 敌人音效: 0.5-0.7
-- 环境音效: 0.3-0.5
-- 武器音效: 0.7-0.9
-
-### 4. 错误处理
-- 系统提供默认音效fallback机制
-- 音频文件缺失时不会导致游戏崩溃
-- 控制台会输出详细的调试信息
-
-## 扩展功能
-
-### 1. 添加新的音频分类
-1. 在 `AudioType` 枚举中添加新类型
-2. 在 `AudioManager` 中添加对应的 `AudioSource`
-3. 实现相应的播放和音量控制方法
-4. 在 `AudioConfig` 中添加配置
-
-### 2. 动态音频加载
-```typescript
-// 可以扩展为支持运行时动态加载音频资源
-AudioManager.getInstance().loadAudioClip(path).then(clip => {
-    // 播放动态加载的音频
-});
-```
-
-### 3. 音频效果
-```typescript
-// 可以扩展支持音频效果，如淡入淡出、变调等
-AudioManager.getInstance().playWithFadeIn(audioPath, 2.0); // 2秒淡入
-```
-
-## 故障排除
-
-### 常见问题
-
-1. **音效不播放**
-   - 检查音频文件路径是否正确
-   - 确认音频文件格式是否支持
-   - 检查音量设置是否为0
-
-2. **音效延迟**
-   - 检查音频文件大小
-   - 考虑预加载重要音效
-   - 优化音频文件格式
-
-3. **音量控制无效**
-   - 确认使用了正确的音量控制方法
-   - 检查AudioSource组件是否正确初始化
-
-### 调试信息
-
-系统提供详细的控制台日志：
-```
-[AudioManager] 初始化音频源: UI音效
-[EnemyAudios] 播放攻击音效: audio/enemy/goblin/attack
-[AudioManager] 设置敌人音效音量: 0.7
-```
-
-## 总结
-
-统一音频系统提供了：
-- ✅ 分类音频管理
-- ✅ 独立音量控制
-- ✅ 配置驱动的音效系统
-- ✅ 便捷的静态访问接口
-- ✅ 完善的错误处理
-- ✅ 向后兼容性
-- ✅ 可扩展的架构设计
-
-该系统为游戏提供了专业级的音频管理解决方案，支持从简单的音效播放到复杂的音频系统管理的各种需求。

assets/resources/data/skill.json

@@ -12,7 +12,7 @@
           0,
           0.1,
           0.2,
-          0.30000000000000004,
+          0.3,
           0.4,
           0.5
         ],
@@ -37,7 +37,7 @@
           0,
           0.1,
           0.2,
-          0.30000000000000004,
+          0.3,
           0.4,
           0.5
         ],
@@ -62,7 +62,7 @@
           0,
           0.1,
           0.2,
-          0.30000000000000004,
+          0.3,
           0.4,
           0.5
         ],
@@ -87,7 +87,7 @@
           0,
           0.1,
           0.2,
-          0.30000000000000004,
+          0.3,
           0.4,
           0.5
         ],
@@ -112,7 +112,7 @@
           0,
           0.1,
           0.2,
-          0.30000000000000004,
+          0.3,
           0.4,
           0.5
         ],
@@ -137,7 +137,7 @@
           0,
           0.1,
           0.2,
-          0.30000000000000004,
+          0.3,
           0.4,
           0.5
         ],

assets/resources/data/weapons.json

@@ -50,7 +50,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/001-1",
-        "fireSound": "audio/pea_shooter_shot"
+        "attackSound": "data/弹球音效/bean atk"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -160,7 +160,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/002",
-        "fireSound": "audio/sharp_carrot_shot"
+        "attackSound": "data/弹球音效/cawl"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -276,7 +276,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/003",
-        "fireSound": "audio/saw_grass_shot"
+        "attackSound": "data/弹球音效/juchi atk"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -387,7 +387,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/007",
-        "fireSound": "audio/watermelon_bomb_shot"
+        "attackSound": "data/弹球音效/bomb"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -496,7 +496,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/004",
-        "fireSound": "audio/boomerang_plant_shot"
+        "attackSound": "data/弹球音效/huixuanbiao atk"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -612,7 +612,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/005",
-        "fireSound": "audio/hot_pepper_shot"
+        "attackSound": "data/弹球音效/fire"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -721,7 +721,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/008",
-        "fireSound": "audio/cactus_shotgun_shot"
+        "attackSound": "data/弹球音效/xianrenzhang hit"
       },
       "upgradeConfig": {
         "maxLevel": 10,
@@ -832,7 +832,7 @@
       },
       "visualConfig": {
         "weaponSprites": "images/PlantsSprite/006",
-        "fireSound": "audio/okra_missile_shot"
+        "attackSound": "data/弹球音效/qiukui hit"
       },
       "upgradeConfig": {
         "maxLevel": 10,

assets/scripts/Animations/MoneyAni.ts

@@ -2,6 +2,7 @@ import { _decorator, Component, Node, Vec3, tween, instantiate, Prefab, math, La
 import { SaveDataManager } from '../LevelSystem/SaveDataManager';
 import { TopBarController } from '../FourUI/TopBarController';
 import EventBus, { GameEvents } from '../Core/EventBus';
+import { Audio } from '../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 /**
@@ -228,7 +229,10 @@ export class MoneyAni extends Component {
             )
             // 短暂停留
             .delay(0.1)
-            // 第二阶段：飞向目标（带缩小和旋转）
+            // 播放音效并开始第二阶段：飞向目标（带缩小和旋转）
+            .call(() => {
+                Audio.playUISound('data/弹球音效/get money');
+            })
             .parallel(
                 tween().to(0.5, { worldPosition: targetWorldPos }, { easing: 'quadIn' }),
                 tween().to(0.5, { scale: new Vec3(0.3, 0.3, 0.3) }, { easing: 'quadIn' }),
@@ -269,7 +273,10 @@ export class MoneyAni extends Component {
             )
             // 短暂停留
             .delay(0.15)
-            // 第二阶段：飞向目标（带缩小和旋转）
+            // 播放音效并开始第二阶段：飞向目标（带缩小和旋转）
+            .call(() => {
+                Audio.playUISound('data/弹球音效/get money');
+            })
             .parallel(
                 tween().to(0.6, { worldPosition: targetWorldPos }, { easing: 'quadIn' }),
                 tween().to(0.6, { scale: new Vec3(0.4, 0.4, 0.4) }, { easing: 'quadIn' }),

assets/scripts/AudioManager/AudioConfig.ts

@@ -97,7 +97,7 @@ export class AudioConfig extends Component {
             description: '用户界面相关音效，包括按钮点击、菜单切换等',
             audios: [
                 {
-                    path: 'audio/ui/button_click',
+                    path: 'data/弹球音效/ui play',
                     type: AudioType.UI_SOUND,
                     volume: 0.8,
                     loop: false,

assets/scripts/AudioManager/EnemyAudios.ts

@@ -115,12 +115,6 @@ export class EnemyAudios extends Component {
         this.audioManager.playEnemySound(soundPath, volume);
     }
     
-
-    
-
-    
-
-    
     onDestroy() {
         if (EnemyAudios._instance === this) {
             EnemyAudios._instance = null;

assets/scripts/CombatSystem/BlockSelection/GameBlockSelection.ts

@@ -6,6 +6,7 @@ import { ConfigManager } from '../../Core/ConfigManager';
 import { BlockTag } from './BlockTag';
 import { WeaponInfo } from './WeaponInfo';
 import { SkillManager } from '../SkillSelection/SkillManager';
+import { Audio } from '../../AudioManager/AudioManager';
 
 import EventBus, { GameEvents } from '../../Core/EventBus';
 const { ccclass, property } = _decorator;
@@ -275,6 +276,8 @@ export class GameBlockSelection extends Component {
 
     // 新增小球按钮点击
     private onAddBallClicked() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 应用便宜技能效果计算实际费用
         const actualCost = this.getActualCost(this.ADD_BALL_COST);
         
@@ -296,6 +299,8 @@ export class GameBlockSelection extends Component {
 
     // 增加金币按钮点击
     private onAddCoinClicked() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 免费增加金币（模拟看广告获得奖励）
         const coinsToAdd = 80; // 免费获得的金币数量
         this.session.addCoins(coinsToAdd);        
@@ -304,7 +309,9 @@ export class GameBlockSelection extends Component {
     }
 
     // 刷新方块按钮点击
-    private onRefreshClicked() {        
+    private onRefreshClicked() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 应用便宜技能效果计算实际费用
         const actualCost = this.getActualCost(this.REFRESH_COST);
         

assets/scripts/CombatSystem/BulletEffects/BulletHitEffect.ts

@@ -7,6 +7,7 @@ import { GroundBurnArea } from './GroundBurnArea';
 import { GroundBurnAreaManager } from './GroundBurnAreaManager';
 import { WeaponBullet } from '../WeaponBullet';
 import EventBus, { GameEvents } from '../../Core/EventBus';
+import { Audio } from '../../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 /**
@@ -170,6 +171,9 @@ export class BulletHitEffect extends Component {
         console.log(`[BulletHitEffect] 爆炸伤害处理 - 配置伤害: ${effect.damage || 0}, 最终伤害: ${explosionDamage}`);
         
         const scheduleExplosion = () => {
+            // 播放爆炸音效
+            this.playAttackSound();
+            
             // 生成爆炸特效
             this.spawnExplosionEffect(position);
             
@@ -288,6 +292,9 @@ export class BulletHitEffect extends Component {
     private damageEnemy(enemyNode: Node, damage: number) {
         if (!this.isEnemyNode(enemyNode)) return;
         
+        // 播放攻击音效
+        this.playAttackSound();
+        
         // 计算暴击伤害和暴击状态
         const damageResult = this.calculateCriticalDamage(damage);
         
@@ -357,6 +364,35 @@ export class BulletHitEffect extends Component {
         return 1.0;
     }
     
+    /**
+     * 播放攻击音效
+     */
+    private playAttackSound() {
+        try {
+            // 获取武器子弹组件
+            const weaponBullet = this.getComponent(WeaponBullet);
+            if (!weaponBullet) {
+                console.log('[BulletHitEffect] 未找到WeaponBullet组件，无法播放攻击音效');
+                return;
+            }
+            
+            // 获取武器配置
+            const weaponConfig = weaponBullet.getWeaponConfig();
+            if (!weaponConfig || !weaponConfig.visualConfig || !weaponConfig.visualConfig.attackSound) {
+                console.log('[BulletHitEffect] 武器配置中未找到attackSound，跳过音效播放');
+                return;
+            }
+            
+            // 播放攻击音效
+            const attackSoundPath = weaponConfig.visualConfig.attackSound;
+            console.log(`[BulletHitEffect] 播放攻击音效: ${attackSoundPath}`);
+            Audio.playWeaponSound(attackSoundPath);
+            
+        } catch (error) {
+            console.error('[BulletHitEffect] 播放攻击音效时出错:', error);
+        }
+    }
+    
     /**
      * 显示暴击特效
      */

assets/scripts/CombatSystem/BulletEffects/BulletTrajectory.ts

@@ -318,7 +318,14 @@ export class BulletTrajectory extends Component {
                     this.rigidBody.linearVelocity = new Vec2(0, 0);
                 }
                 
-                // 通知生命周期组件触发爆炸
+                // 先触发命中效果（包括音效播放）
+                const hitEffect = this.getComponent('BulletHitEffect') as any;
+                if (hitEffect && typeof hitEffect.processHit === 'function') {
+                    // 使用当前位置作为命中位置，传入子弹节点作为命中目标
+                    hitEffect.processHit(this.node, currentPos);
+                }
+                
+                // 然后通知生命周期组件触发爆炸
                 const lifecycle = this.getComponent('BulletLifecycle') as any;
                 if (lifecycle && typeof lifecycle.onHit === 'function') {
                     lifecycle.onHit(this.node); // 触发爆炸逻辑

assets/scripts/CombatSystem/EnemyController.ts

@@ -274,6 +274,7 @@ export class EnemyController extends BaseSingleton {
      */
     private onGameDefeatEvent() {
         this.stopGame(true); // 停止游戏并清除所有敌人
+        //是否是应该此时调用onGameDefeat()方法？
     }
     
     /**

assets/scripts/CombatSystem/GameEnd.ts

@@ -1,7 +1,8 @@
-import { _decorator, Component, Node, Label, Button } from 'cc';
+import { _decorator, Component, Node, Label, Button, tween, Tween, Vec3, UIOpacity, find } from 'cc';
 import { SaveDataManager } from '../LevelSystem/SaveDataManager';
 import { InGameManager, GameState } from '../LevelSystem/IN_game';
 import EventBus, { GameEvents } from '../Core/EventBus';
+import { Audio } from '../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 /**
@@ -42,16 +43,44 @@ export class GameEnd extends Component {
     })
     public inGameManager: InGameManager = null;
     
-    // 动画相关属性已移除，现在由MoneyAni组件负责处理奖励动画
+    @property({
+        type: Label,
+        tooltip: 'EndLabel文本显示 (Canvas/GameEnd/Sprite/EndLabel)'
+    })
+    public endLabel: Label = null;
+    
+    // === 动画相关属性 ===
+    @property({ tooltip: '动画持续时间（秒）' })
+    public animationDuration: number = 0.3;
+    
+    // 淡入淡出和缩放动画都直接作用于当前节点(Canvas/GameEnd)
+    // 不需要额外的目标节点属性
+    
+    private _originalScale: Vec3 = new Vec3();
     
     // === 私有属性 ===
     private saveDataManager: SaveDataManager = null;
     public currentRewards: {money: number, diamonds: number};
     private hasDoubledReward: boolean = false;
     private isGameSuccess: boolean = false;
+
+    onLoad() {
+        console.log('[GameEnd] onLoad方法被调用');
+        this.setupEventListeners();
+    }
     
     start() {
         console.log('[GameEnd] start方法被调用');
+        
+        // 保存原始缩放值
+        if (this.node) {
+            this._originalScale.set(this.node.scale);
+        }
+        
+        // 初始化为隐藏状态（通过动画实现）
+        this.initializeHiddenState();
+
+        // 监听游戏事件
         // start方法只在节点首次激活时调用一次
         // 如果节点初始状态为false，start不会被调用
     }
@@ -67,9 +96,6 @@ export class GameEnd extends Component {
         // 绑定按钮事件
         this.bindButtonEvents();
         
-        // 监听游戏事件
-        this.setupEventListeners();
-        
         // 初始化UI状态
         this.initializeUI();
         
@@ -83,6 +109,116 @@ export class GameEnd extends Component {
     private initializeManagers() {
         this.saveDataManager = SaveDataManager.getInstance();
         // InGameManager已通过装饰器挂载，无需查找
+        
+        // 如果UI组件未在编辑器中绑定，尝试自动查找
+        this.autoFindUIComponents();
+    }
+    
+    /**
+     * 自动查找UI组件（如果编辑器中未绑定）
+     */
+    private autoFindUIComponents() {
+        // 自动查找moneyLabel
+        if (!this.moneyLabel) {
+            // 尝试多个可能的路径
+            const moneyLabelPaths = [
+                'ResourceNode/MoneyResourceNode/MoneyLabel',
+                'Sprite/ResourceNode/MoneyResourceNode/MoneyLabel',
+                'ResourceNode/MoneyLabel',
+                'MoneyResourceNode/MoneyLabel'
+            ];
+            
+            for (const path of moneyLabelPaths) {
+                const moneyLabelNode = this.node.getChildByPath(path);
+                if (moneyLabelNode) {
+                    this.moneyLabel = moneyLabelNode.getComponent(Label);
+                    if (this.moneyLabel) {
+                        console.log(`[GameEnd] 自动找到moneyLabel，路径: ${path}`);
+                        break;
+                    }
+                }
+            }
+            
+            // 如果还是没找到，尝试递归查找
+            if (!this.moneyLabel) {
+                this.moneyLabel = this.findLabelByName(this.node, 'MoneyLabel');
+                if (this.moneyLabel) {
+                    console.log('[GameEnd] 通过递归查找找到moneyLabel');
+                }
+            }
+        }
+        
+        // 自动查找diamondLabel
+        if (!this.diamondLabel) {
+            // 尝试多个可能的路径
+            const diamondLabelPaths = [
+                'ResourceNode/DiamondResourceNode/DiamondLabel',
+                'Sprite/ResourceNode/DiamondResourceNode/DiamondLabel',
+                'ResourceNode/DiamondLabel',
+                'DiamondResourceNode/DiamondLabel'
+            ];
+            
+            for (const path of diamondLabelPaths) {
+                const diamondLabelNode = this.node.getChildByPath(path);
+                if (diamondLabelNode) {
+                    this.diamondLabel = diamondLabelNode.getComponent(Label);
+                    if (this.diamondLabel) {
+                        console.log(`[GameEnd] 自动找到diamondLabel，路径: ${path}`);
+                        break;
+                    }
+                }
+            }
+            
+            // 如果还是没找到，尝试递归查找
+            if (!this.diamondLabel) {
+                this.diamondLabel = this.findLabelByName(this.node, 'DiamondLabel');
+                if (this.diamondLabel) {
+                    console.log('[GameEnd] 通过递归查找找到diamondLabel');
+                }
+            }
+        }
+        
+        console.log('[GameEnd] UI组件自动查找完成 - moneyLabel:', !!this.moneyLabel, 'diamondLabel:', !!this.diamondLabel);
+        
+        // 如果仍然没有找到组件，打印节点结构用于调试
+        if (!this.moneyLabel || !this.diamondLabel) {
+            console.warn('[GameEnd] 部分UI组件未找到，打印节点结构用于调试:');
+            this.printNodeStructure(this.node, 0, 3); // 最多打印3层
+        }
+    }
+    
+    /**
+     * 递归查找指定名称的Label组件
+     */
+    private findLabelByName(node: Node, targetName: string): Label | null {
+        // 检查当前节点
+        if (node.name === targetName) {
+            const label = node.getComponent(Label);
+            if (label) return label;
+        }
+        
+        // 递归检查子节点
+        for (const child of node.children) {
+            const result = this.findLabelByName(child, targetName);
+            if (result) return result;
+        }
+        
+        return null;
+    }
+    
+    /**
+     * 打印节点结构用于调试
+     */
+    private printNodeStructure(node: Node, depth: number, maxDepth: number) {
+        if (depth > maxDepth) return;
+        
+        const indent = '  '.repeat(depth);
+        const components = node.getComponents(Component).map(c => c.constructor.name).join(', ');
+        console.log(`${indent}${node.name} [${components || 'No Components'}]`);
+        
+        for (const child of node.children) {
+            this.printNodeStructure(child, depth + 1, maxDepth);
+        }
     }
 
     /**
@@ -122,14 +258,11 @@ export class GameEnd extends Component {
      * 初始化UI状态
      */
     private initializeUI() {
-        // 不强制隐藏面板，让UIStateManager控制面板显示状态
-        // this.node.active = false;
-        
         // 重置状态
         this.hasDoubledReward = false;
         this.currentRewards = {money: 0, diamonds: 0};
         
-        console.log('[GameEnd] UI状态初始化完成，面板状态由UIStateManager控制');
+        console.log('[GameEnd] UI状态初始化完成');
     }
     
     /**
@@ -160,20 +293,57 @@ export class GameEnd extends Component {
     
     /**
      * 处理游戏成功事件
+     * 统一处理游戏成功逻辑：状态切换 + UI显示 + 奖励计算
      */
     private onGameSuccess() {
         console.log('[GameEnd] 接收到GAME_SUCCESS事件');
-        console.log('[GameEnd] 游戏成功，准备显示奖励');
+        console.log('[GameEnd] 游戏成功，开始统一处理流程');
+        
+        // 1. 设置游戏状态为成功（如果还未设置）
+        if (this.inGameManager && this.inGameManager.getCurrentState() !== GameState.SUCCESS) {
+            this.inGameManager.setCurrentState(GameState.SUCCESS);
+            console.log('[GameEnd] 已将游戏状态切换为SUCCESS');
+        }
+        
+        // 2. 设置EndLabel文本
+        this.setEndLabelText('SUCCESS');
+        
+        // 3. 显示UI面板
+        this.showEndPanelWithAnimation();
+        
+        // 4. 计算和显示奖励
         this.isGameSuccess = true;
         this.calculateAndShowRewards();
     }
     
     /**
      * 处理游戏失败事件
+     * 统一处理游戏失败逻辑：状态切换 + UI显示 + 奖励计算
      */
     private onGameDefeat() {
         console.log('[GameEnd] 接收到GAME_DEFEAT事件');
-        console.log('[GameEnd] 游戏失败，准备显示奖励');
+        console.log('[GameEnd] 游戏失败，开始统一处理流程');
+        console.log('[GameEnd] 当前节点激活状态:', this.node.active);
+        console.log('[GameEnd] moneyLabel绑定状态:', !!this.moneyLabel);
+        console.log('[GameEnd] diamondLabel绑定状态:', !!this.diamondLabel);
+        
+        // 1. 设置游戏状态为失败（如果还未设置）
+        if (this.inGameManager && this.inGameManager.getCurrentState() !== GameState.DEFEAT) {
+            this.inGameManager.setCurrentState(GameState.DEFEAT);
+            console.log('[GameEnd] 已将游戏状态切换为DEFEAT');
+        }
+        
+        // 2. 播放游戏失败音效
+        Audio.playUISound('data/弹球音效/lose');
+        console.log('[GameEnd] 已播放游戏失败音效');
+        
+        // 3. 设置EndLabel文本
+        this.setEndLabelText('DEFEAT');
+        
+        // 4. 显示UI面板
+        this.showEndPanelWithAnimation();
+        
+        // 5. 计算和显示奖励
         this.isGameSuccess = false;
         this.calculateAndShowRewards();
     }
@@ -213,8 +383,8 @@ export class GameEnd extends Component {
             console.log('[GameEnd] 获取到的奖励数据:', this.currentRewards);
             this.updateRewardDisplay();
             
-            // 显示结算面板
-            this.showEndPanel();
+            // 显示结算面板（通过动画）
+            this.showEndPanelWithAnimation();
             
         } catch (error) {
             console.error('[GameEnd] 计算奖励时出错:', error);
@@ -225,38 +395,106 @@ export class GameEnd extends Component {
      * 更新奖励显示
      */
     private updateRewardDisplay() {
+        console.log(`[GameEnd] 开始更新奖励显示 - 钞票: ${this.currentRewards.money}, 钻石: ${this.currentRewards.diamonds}`);
+        
+        // 检查moneyLabel绑定状态
         if (this.moneyLabel) {
             this.moneyLabel.string = this.currentRewards.money.toString();
+            console.log(`[GameEnd] 钞票标签已更新: ${this.currentRewards.money}`);
+        } else {
+            console.error('[GameEnd] moneyLabel未绑定！请在编辑器中将Canvas/GameEnd/ResourceNode/MoneyResourceNode/MoneyLabel拖拽到GameEnd组件的moneyLabel属性');
         }
         
+        // 检查diamondLabel绑定状态
         if (this.diamondLabel) {
             this.diamondLabel.string = this.currentRewards.diamonds.toString();
+            console.log(`[GameEnd] 钻石标签已更新: ${this.currentRewards.diamonds}`);
+        } else {
+            console.error('[GameEnd] diamondLabel未绑定！请在编辑器中将Canvas/GameEnd/ResourceNode/DiamondResourceNode/DiamondLabel拖拽到GameEnd组件的diamondLabel属性');
         }
         
-        console.log(`[GameEnd] 更新奖励显示 - 钞票: ${this.currentRewards.money}, 钻石: ${this.currentRewards.diamonds}`);
+        console.log(`[GameEnd] 奖励显示更新完成`);
     }
     
     /**
-     * 显示结算面板
+     * 显示结算面板（通过动画）
      */
-    private showEndPanel() {
-        this.node.active = true;
-        
+    private showEndPanelWithAnimation() {
+
         // 重置双倍奖励状态
         this.hasDoubledReward = false;
         if (this.doubleButton) {
             this.doubleButton.interactable = true;
         }
         
-        console.log('[GameEnd] 结算面板已显示');
+        // 播放显示动画（如果有的话）
+        if (this.animationDuration > 0) {
+            this.playShowAnimation();
+        }
         
-
+        console.log('[GameEnd] 结算面板已通过动画显示');
+    }
+    
+    /**
+     * 播放显示动画
+     */
+    private playShowAnimation() {
+        if (!this.node) return;
+        
+        // 设置节点位置到屏幕中心
+        this.centerNodeOnScreen();
+        
+        // 设置初始状态
+        this.node.setScale(0.5, 0.5, 1);
+        const uiOpacity = this.node.getComponent(UIOpacity);
+        if (uiOpacity) {
+            uiOpacity.opacity = 0;
+        }
+        
+        // 播放缩放和淡入动画
+        tween(this.node)
+            .to(this.animationDuration, {
+                scale: new Vec3(1, 1, 1)
+            }, {
+                easing: 'backOut'
+            })
+            .start();
+            
+        if (uiOpacity) {
+            tween(uiOpacity)
+                .to(this.animationDuration, {
+                    opacity: 255
+                })
+                .start();
+        }
+        
+        console.log('[GameEnd] 播放显示动画');
+    }
+    
+    /**
+     * 将节点居中到屏幕中央
+     */
+    private centerNodeOnScreen() {
+        if (!this.node) return;
+        
+        // 获取Canvas节点
+        const canvas = find('Canvas');
+        if (!canvas) {
+            console.warn('[GameEnd] 未找到Canvas节点');
+            return;
+        }
+        
+        // 设置位置为(0, 0)，这在Canvas坐标系中是屏幕中心
+        this.node.setPosition(0, 0, 0);
+        console.log('[GameEnd] 已将面板居中到屏幕中央');
     }
     
     /**
      * 双倍按钮点击事件
      */
     private onDoubleButtonClick() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         if (this.hasDoubledReward) {
             console.log('[GameEnd] 已经获得过双倍奖励');
             return;
@@ -315,6 +553,8 @@ export class GameEnd extends Component {
      * 继续按钮点击事件
      */
     private onContinueButtonClick() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         console.log('[GameEnd] 点击继续按钮');
         
         // 派发事件给MoneyAni播放奖励动画
@@ -328,16 +568,18 @@ export class GameEnd extends Component {
         // 触发返回主菜单事件
         EventBus.getInstance().emit('CONTINUE_CLICK');
         
-        // 隐藏结算面板
-        this.hideEndPanel();
+        // 隐藏结算面板（通过动画）
+        this.hideEndPanelWithAnimation();
     }
     
     /**
-     * 隐藏结算面板
+     * 隐藏结算面板（通过动画）
      */
-    private hideEndPanel() {
-        this.node.active = false;
-        console.log('[GameEnd] 结算面板已隐藏');
+    private async hideEndPanelWithAnimation() {
+        // 播放隐藏动画
+        await this.fadeOutWithScale();
+        
+        console.log('[GameEnd] 结算面板已通过动画隐藏');
     }
     
     /**
@@ -345,11 +587,36 @@ export class GameEnd extends Component {
      */
     private onResetUI() {
         console.log('[GameEnd] 重置UI状态');
-        this.hideEndPanel();
+        this.hideEndPanelWithAnimation();
         this.hasDoubledReward = false;
         this.currentRewards = {money: 0, diamonds: 0};
     }
     
+    /**
+     * 设置EndLabel文本
+     * @param text 要显示的文本内容
+     */
+    private setEndLabelText(text: string) {
+        if (this.endLabel) {
+            this.endLabel.string = text;
+            console.log(`[GameEnd] 已设置EndLabel文本为: ${text}`);
+        } else {
+            // 如果endLabel未绑定，尝试通过路径查找
+            const endLabelNode = find('Canvas/GameEnd/Sprite/EndLabel');
+            if (endLabelNode) {
+                const labelComponent = endLabelNode.getComponent(Label);
+                if (labelComponent) {
+                    labelComponent.string = text;
+                    console.log(`[GameEnd] 通过路径查找设置EndLabel文本为: ${text}`);
+                } else {
+                    console.warn('[GameEnd] 找到EndLabel节点但无Label组件');
+                }
+            } else {
+                console.warn('[GameEnd] 未找到EndLabel节点，请检查路径: Canvas/GameEnd/Sprite/EndLabel');
+            }
+        }
+    }
+    
     /**
      * 获取当前奖励信息（用于外部查询）
      */
@@ -364,27 +631,205 @@ export class GameEnd extends Component {
         return this.hasDoubledReward;
     }
     
+    // === 动画方法 ===
     
+    /**
+     * 初始化为隐藏状态
+     */
+    private initializeHiddenState() {
+        // 设置初始透明度为0
+        if (this.node) {
+            let uiOpacity = this.node.getComponent(UIOpacity);
+            if (!uiOpacity) {
+                uiOpacity = this.node.addComponent(UIOpacity);
+            }
+            uiOpacity.opacity = 0;
+        }
+        
+        // 设置初始缩放为0
+        if (this.node) {
+            this.node.setScale(0, 0, 1);
+        }
+        
+        console.log('[GameEnd] 初始化为隐藏状态');
+    }
     
-
-    
-
+    /**
+     * 淡入动画
+     */
+    public fadeIn(target?: Node, duration?: number): Promise<void> {
+        const animTarget = target || this.node;
+        const animDuration = duration !== undefined ? duration : this.animationDuration;
+        
+        if (!animTarget) {
+            console.warn('[GameEnd] fadeIn: 未指定目标节点');
+            return Promise.resolve();
+        }
+        
+        return new Promise<void>((resolve) => {
+            let uiOpacity = animTarget.getComponent(UIOpacity);
+            if (!uiOpacity) {
+                uiOpacity = animTarget.addComponent(UIOpacity);
+            }
+            
+            Tween.stopAllByTarget(uiOpacity);
+            uiOpacity.opacity = 0;
+            
+            tween(uiOpacity)
+                .to(animDuration, { opacity: 255 }, { easing: 'quadOut' })
+                .call(() => {
+                    resolve();
+                })
+                .start();
+        });
+    }
     
-
+    /**
+     * 淡出动画
+     */
+    public fadeOut(target?: Node, duration?: number): Promise<void> {
+        const animTarget = target || this.node;
+        const animDuration = duration !== undefined ? duration : this.animationDuration;
+        
+        if (!animTarget) {
+            console.warn('[GameEnd] fadeOut: 未指定目标节点');
+            return Promise.resolve();
+        }
+        
+        return new Promise<void>((resolve) => {
+            let uiOpacity = animTarget.getComponent(UIOpacity);
+            if (!uiOpacity) {
+                uiOpacity = animTarget.addComponent(UIOpacity);
+            }
+            
+            Tween.stopAllByTarget(uiOpacity);
+            
+            tween(uiOpacity)
+                .to(animDuration, { opacity: 0 }, { easing: 'quadIn' })
+                .call(() => {
+                    resolve();
+                })
+                .start();
+        });
+    }
     
-
+    /**
+     * 缩放弹出动画
+     */
+    public scalePopIn(target?: Node, duration?: number): Promise<void> {
+        const animTarget = target || this.node;
+        const animDuration = duration !== undefined ? duration : this.animationDuration;
+        
+        if (!animTarget) {
+            console.warn('[GameEnd] scalePopIn: 未指定目标节点');
+            return Promise.resolve();
+        }
+        
+        return new Promise<void>((resolve) => {
+            Tween.stopAllByTarget(animTarget);
+            animTarget.setScale(0, 0, 1);
+            
+            tween(animTarget)
+                .to(animDuration, { scale: this._originalScale }, { easing: 'backOut' })
+                .call(() => {
+                    resolve();
+                })
+                .start();
+        });
+    }
     
-
+    /**
+     * 缩放收缩动画
+     */
+    public scalePopOut(target?: Node, duration?: number): Promise<void> {
+        const animTarget = target || this.node;
+        const animDuration = duration !== undefined ? duration : this.animationDuration;
+        
+        if (!animTarget) {
+            console.warn('[GameEnd] scalePopOut: 未指定目标节点');
+            return Promise.resolve();
+        }
+        
+        return new Promise<void>((resolve) => {
+            Tween.stopAllByTarget(animTarget);
+            
+            tween(animTarget)
+                .to(animDuration, { scale: new Vec3(0, 0, 1) }, { easing: 'backIn' })
+                .call(() => {
+                    resolve();
+                })
+                .start();
+        });
+    }
     
-
+    /**
+     * 组合动画：淡入 + 缩放弹出
+     */
+    public async fadeInWithScale(fadeTarget?: Node, scaleTarget?: Node, duration?: number): Promise<void> {
+        const promises: Promise<void>[] = [];
+        
+        if (fadeTarget || this.node) {
+            promises.push(this.fadeIn(fadeTarget, duration));
+        }
+        
+        if (scaleTarget || this.node) {
+            promises.push(this.scalePopIn(scaleTarget, duration));
+        }
+        
+        await Promise.all(promises);
+    }
     
-
+    /**
+     * 组合动画：淡出 + 缩放收缩
+     */
+    public async fadeOutWithScale(fadeTarget?: Node, scaleTarget?: Node, duration?: number): Promise<void> {
+        const promises: Promise<void>[] = [];
+        
+        if (fadeTarget || this.node) {
+            promises.push(this.fadeOut(fadeTarget, duration));
+        }
+        
+        if (scaleTarget || this.node) {
+            promises.push(this.scalePopOut(scaleTarget, duration));
+        }
+        
+        await Promise.all(promises);
+    }
     
-
+    /**
+     * 停止所有动画
+     */
+    public stopAllAnimations() {
+        if (this.node) {
+            const uiOpacity = this.node.getComponent(UIOpacity);
+            if (uiOpacity) {
+                Tween.stopAllByTarget(uiOpacity);
+            }
+            Tween.stopAllByTarget(this.node);
+        }
+    }
     
+    /**
+     * 重置所有目标节点到初始状态
+     */
+    public resetToInitialState() {
+        this.stopAllAnimations();
+        
+        if (this.node) {
+            let uiOpacity = this.node.getComponent(UIOpacity);
+            if (uiOpacity) {
+                uiOpacity.opacity = 255;
+            }
+            this.node.setScale(this._originalScale);
+        }
+    }
 
     onDisable() {
         console.log('[GameEnd] onDisable方法被调用，节点已禁用');
+        
+        // 停止所有动画
+        this.stopAllAnimations();
+        
         // 清理事件监听
         const eventBus = EventBus.getInstance();
         eventBus.off(GameEvents.GAME_SUCCESS, this.onGameSuccess, this);
@@ -394,6 +839,9 @@ export class GameEnd extends Component {
     }
     
     protected onDestroy() {
+        // 停止所有动画
+        this.stopAllAnimations();
+        
         // 清理事件监听
         const eventBus = EventBus.getInstance();
         eventBus.off(GameEvents.GAME_SUCCESS, this.onGameSuccess, this);

assets/scripts/CombatSystem/MenuSystem/MenuController.ts

@@ -3,8 +3,8 @@ import { PopUPAni } from '../../Animations/PopUPAni';
 import EventBus, { GameEvents } from '../../Core/EventBus';
 import { GameManager, AppState } from '../../LevelSystem/GameManager';
 import { GameStartMove } from '../../Animations/GameStartMove';
-import { GamePause } from '../GamePause';
 import { SoundController } from './SoundController';
+import { Audio } from '../../AudioManager/AudioManager';
 
 const { ccclass, property } = _decorator;
 
@@ -73,6 +73,8 @@ export class MenuController extends Component {
      * 菜单按钮点击事件
      */
     private async onMenuButtonClick() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         if (this.isMenuOpen) {
             await this.closeMenu();
         } else {
@@ -84,6 +86,8 @@ export class MenuController extends Component {
      * 关闭按钮点击事件
      */
     private async onCloseButtonClick() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         await this.closeMenu();
     }
     
@@ -91,6 +95,8 @@ export class MenuController extends Component {
      * 继续游戏按钮点击事件
      */
     private async onContinueButtonClick() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         console.log('[MenuController] 继续游戏按钮被点击');
         
         // 检查GameManager组件引用
@@ -118,6 +124,8 @@ export class MenuController extends Component {
      * 退出游戏按钮点击事件
      */
     private async onBackButtonClick() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         console.log('[MenuController] 退出游戏按钮被点击');
         
         // 检查GameManager组件引用
@@ -185,11 +193,11 @@ export class MenuController extends Component {
         
         this.isMenuOpen = true;
         
-        // 检查是否在游戏中，如果是则暂停游戏
+        // 检查是否在游戏中，如果是则通过事件系统触发游戏暂停
         if (this.gameManager && this.gameManager.getCurrentAppState() === AppState.IN_GAME) {
-            console.log('[MenuController] 游戏中打开菜单，暂停游戏');
-            const gamePause = GamePause.getInstance();
-            gamePause.pauseGame();
+            console.log('[MenuController] 游戏中打开菜单，通过事件系统触发游戏暂停');
+            const eventBus = EventBus.getInstance();
+            eventBus.emit(GameEvents.GAME_PAUSE);
         }
         
         // 使用动画显示菜单面板
@@ -215,11 +223,11 @@ export class MenuController extends Component {
         }
         // 注意：不再有fallback逻辑设置active，菜单面板始终保持active=true
         
-        // 检查是否在游戏中，如果是则恢复游戏
+        // 检查是否在游戏中，如果是则通过事件系统触发游戏恢复
         if (this.gameManager && this.gameManager.getCurrentAppState() === AppState.IN_GAME) {
-            console.log('[MenuController] 游戏中关闭菜单，恢复游戏');
-            const gamePause = GamePause.getInstance();
-            gamePause.resumeGame();
+            console.log('[MenuController] 游戏中关闭菜单，通过事件系统触发游戏恢复');
+            const eventBus = EventBus.getInstance();
+            eventBus.emit(GameEvents.GAME_RESUME);
         }
         
         console.log('菜单已关闭');

assets/scripts/CombatSystem/MenuSystem/SoundController.ts

@@ -1,6 +1,7 @@
 import { _decorator, Component, Node, Slider, Button, Sprite, SpriteFrame, ProgressBar, resources, tween, Vec3 } from 'cc';
 import { AudioManager } from '../../AudioManager/AudioManager';
 import { SaveDataManager } from '../../LevelSystem/SaveDataManager';
+import { Audio } from '../../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 /**
@@ -135,6 +136,7 @@ export class SoundController extends Component {
      * 音效开关按钮点击事件
      */
     private onSoundEffectCheckboxClick() {
+        Audio.playUISound('data/弹球音效/ui play');
         this.soundEffectEnabled = !this.soundEffectEnabled;
         
         if (this.soundEffectEnabled) {
@@ -162,6 +164,7 @@ export class SoundController extends Component {
      * 音乐开关按钮点击事件
      */
     private onMusicCheckboxClick() {
+        Audio.playUISound('data/弹球音效/ui play');
         this.musicEnabled = !this.musicEnabled;
         
         if (this.musicEnabled) {
@@ -189,6 +192,7 @@ export class SoundController extends Component {
      * 震动开启按钮点击事件
      */
     private onVibrationOnClick() {
+        Audio.playUISound('data/弹球音效/ui play');
         this.vibrationEnabled = true;
         this.updateVibrationSlideButton();
         this.saveVibrationSetting();
@@ -201,6 +205,7 @@ export class SoundController extends Component {
      * 震动关闭按钮点击事件
      */
     private onVibrationOffClick() {
+        Audio.playUISound('data/弹球音效/ui play');
         this.vibrationEnabled = false;
         this.updateVibrationSlideButton();
         this.saveVibrationSetting();

assets/scripts/CombatSystem/SkillSelection/SkillButtonController.ts

@@ -1,6 +1,7 @@
 import { _decorator, Component, Node, Button, Label, Sprite, resources, SpriteFrame } from 'cc';
 import { SkillManager, SkillData } from './SkillManager';
 import { SkillButtonAnimator } from './SkillButtonAnimator';
+import { Audio } from '../../AudioManager/AudioManager';
 
 const { ccclass, property } = _decorator;
 
@@ -146,10 +147,15 @@ export class SkillButtonController extends Component {
         if (label) {
             const skillManager = SkillManager.getInstance();
             if (skillManager) {
-                // 获取当前技能等级的描述
-                const currentLevel = skillManager.getSkillLevel(this._skillData.id);
-                const description = skillManager.getSkillDescription(this._skillData.id, currentLevel);
-                label.string = description;
+                // 检查技能是否满级
+                if (skillManager.isSkillMaxLevel(this._skillData.id)) {
+                    label.string = "技能等级已满";
+                } else {
+                    // 获取当前技能等级的描述
+                    const currentLevel = skillManager.getSkillLevel(this._skillData.id);
+                    const description = skillManager.getSkillDescription(this._skillData.id, currentLevel);
+                    label.string = description;
+                }
             } else {
                 label.string = this._skillData.description;
             }
@@ -180,6 +186,7 @@ export class SkillButtonController extends Component {
      * 按钮点击事件
      */
     private onButtonClick() {
+        Audio.playUISound('data/弹球音效/level up 2');
         if (this._onClickCallback) {
             this._onClickCallback(this);
         }

assets/scripts/CombatSystem/SkillSelection/SkillManager.ts

@@ -323,6 +323,15 @@ export class SkillManager extends Component {
         return this.getSkillDescription(skillId, skill.currentLevel);
     }
 
+    /**
+     * 检查技能是否已满级
+     */
+    public isSkillMaxLevel(skillId: string): boolean {
+        const skill = this._skills.get(skillId);
+        if (!skill) return false;
+        return skill.currentLevel >= skill.maxLevel;
+    }
+
     /**
      * 获取所有技能数据（用于保存）
      */

assets/scripts/CombatSystem/SkillSelection/SkillSelectionController.ts

@@ -88,13 +88,39 @@ export class SkillSelectionController extends Component {
             return;
         }
 
-        // 从6个技能中随机选择3个
-        const allSkills = [...this._skillConfig.skills];
+        const skillManager = SkillManager.getInstance();
+        if (!skillManager) {
+            console.error('SkillManager未初始化');
+            return;
+        }
+
+        // 将技能分为满级和非满级两组
+        const nonMaxLevelSkills: SkillData[] = [];
+        const maxLevelSkills: SkillData[] = [];
+        
+        this._skillConfig.skills.forEach(skill => {
+            if (skillManager.isSkillMaxLevel(skill.id)) {
+                maxLevelSkills.push(skill);
+            } else {
+                nonMaxLevelSkills.push(skill);
+            }
+        });
+
+        // 优先从非满级技能中选择
         this._currentSkills = [];
+        const availableSkills = [...nonMaxLevelSkills];
+        
+        // 先从非满级技能中随机选择
+        while (this._currentSkills.length < 3 && availableSkills.length > 0) {
+            const randomIndex = Math.floor(Math.random() * availableSkills.length);
+            this._currentSkills.push(availableSkills.splice(randomIndex, 1)[0]);
+        }
         
-        for (let i = 0; i < 3 && allSkills.length > 0; i++) {
-            const randomIndex = Math.floor(Math.random() * allSkills.length);
-            this._currentSkills.push(allSkills.splice(randomIndex, 1)[0]);
+        // 如果非满级技能不足3个，再从满级技能中补充
+        const remainingMaxLevelSkills = [...maxLevelSkills];
+        while (this._currentSkills.length < 3 && remainingMaxLevelSkills.length > 0) {
+            const randomIndex = Math.floor(Math.random() * remainingMaxLevelSkills.length);
+            this._currentSkills.push(remainingMaxLevelSkills.splice(randomIndex, 1)[0]);
         }
 
         // 更新UI显示

assets/scripts/Core/ConfigManager.ts

@@ -86,7 +86,7 @@ export interface WeaponConfig {
         weaponSprites: {
             [shapeId: string]: string;
         };
-        fireSound: string;
+        attackSound: string;
     };
     upgradeConfig: {
         maxLevel: number;

assets/scripts/FourUI/MainSystem/MainUIControlller.ts

@@ -7,6 +7,7 @@ import { GameStartMove } from '../../Animations/GameStartMove';
 import { TopBarController } from '../TopBarController';
 import { MoneyAni } from '../../Animations/MoneyAni';
 import EventBus, { GameEvents } from '../../Core/EventBus';
+import { Audio } from '../../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 @ccclass('MainUIController')
@@ -86,6 +87,8 @@ export class MainUIController extends Component {
 
   /* ================= 业务逻辑 ================= */
   private upgradeWallHp () {
+    // 播放UI点击音效
+    Audio.playUISound('data/弹球音效/level up 2');
     console.log('[MainUIController] 升级墙体按钮被点击');
     
     // 检查SaveDataManager是否初始化
@@ -150,6 +153,8 @@ export class MainUIController extends Component {
   }
 
   private onBattle () {
+    // 播放UI点击音效
+    Audio.playUISound('data/弹球音效/ui play');
     // 显示 TopArea（拖拽引用），避免使用 find()
     if (this.topArea) this.topArea.active = true;
 

assets/scripts/FourUI/NavBarController.ts

@@ -1,6 +1,7 @@
 import { _decorator, Color, Component, Node, Sprite, find, Vec3 } from 'cc';
 import EventBus, { GameEvents } from '../Core/EventBus';
 import { GameStartMove } from '../Animations/GameStartMove';
+import { Audio } from '../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 @ccclass('NavBarController')
@@ -106,6 +107,8 @@ export class NavBarController extends Component {
     }
 
     onBattleClick ()  { 
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 检查Battle按钮是否被锁定（索引0）
         if (this.buttonLockStates[0]) {
             console.log('[NavBarController] Battle按钮被锁定，无法点击');
@@ -119,6 +122,8 @@ export class NavBarController extends Component {
         this.switchTo(0); 
     }
     onUpgradeClick () { 
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 检查Upgrade按钮是否被锁定（索引2）
         if (this.buttonLockStates[2]) {
             console.log('[NavBarController] Upgrade按钮被锁定，无法点击');
@@ -132,6 +137,8 @@ export class NavBarController extends Component {
         this.switchTo(1); 
     }
     onShopClick ()    { 
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 检查shop按钮是否被锁定（索引1）
         if (this.buttonLockStates[1]) {
             console.log('[NavBarController] Shop按钮被锁定，无法点击');
@@ -145,6 +152,8 @@ export class NavBarController extends Component {
         this.switchTo(2); 
     }
     onSkillClick ()   { 
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 检查Skill按钮是否被锁定（索引3）
         if (this.buttonLockStates[3]) {
             console.log('[NavBarController] Skill按钮被锁定，无法点击');

assets/scripts/FourUI/SkillSystem/SkillNodeGenerator.ts

@@ -3,6 +3,7 @@ import { PersistentSkillManager } from './PersistentSkillManager';
 import { SaveDataManager } from '../../LevelSystem/SaveDataManager';
 import { SkillConfigManager } from './SkillConfigManager';
 import EventBus, { GameEvents } from '../../Core/EventBus';
+import { Audio } from '../../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 /**
@@ -301,6 +302,9 @@ export class SkillNodeGenerator extends Component {
             return;
         }
         
+        // 播放升级成功音效
+        Audio.playUISound('data/弹球音效/level up 2');
+        
         // 更新解锁索引
         this.currentUnlockIndex = nodeIndex;
         

assets/scripts/FourUI/TopBarController.ts

@@ -2,6 +2,7 @@
 import { _decorator, Component, Node, Button, Label, find } from 'cc';
 import { SaveDataManager } from '../LevelSystem/SaveDataManager';
 import EventBus, { GameEvents } from '../Core/EventBus';
+import { Audio } from '../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 @ccclass('TopBarController')
@@ -61,12 +62,16 @@ export class TopBarController extends Component {
 
   /* ================= 业务逻辑 ================= */
   private addMoney(v: number) { 
+    // 播放UI点击音效
+    Audio.playUISound('data/弹球音效/ui play');
     this.sdm.addMoney(v, 'ad'); 
     // 触发货币变化事件
     EventBus.getInstance().emit(GameEvents.CURRENCY_CHANGED);
   }
   
   private addDiamonds(v: number) { 
+    // 播放UI点击音效
+    Audio.playUISound('data/弹球音效/ui play');
     this.sdm.addDiamonds(v, 'ad'); 
     // 触发货币变化事件
     EventBus.getInstance().emit(GameEvents.CURRENCY_CHANGED);

assets/scripts/FourUI/UpgradeSystem/UpgradeAni.ts

@@ -1,10 +1,11 @@
 import { _decorator, Component, Node, Tween, tween, Vec3, Material, Sprite, resources } from 'cc';
+import { Audio } from '../../AudioManager/AudioManager';
 
 const { ccclass, property } = _decorator;
 
 /**
- * 武器升级动画控制器
- * 负责管理武器升级相关的动画效果
+ * 植物升级动画控制器
+ * 负责管理植物升级相关的动画效果
  */
 @ccclass('UpgradeAni')
 export class UpgradeAni extends Component {
@@ -13,9 +14,9 @@ export class UpgradeAni extends Component {
     weaponSpriteNode: Node = null;
     
     /**
-     * 武器升级成功动画
-     * 播放武器图标的放大缩小动画，并在升级期间应用扫描效果材质
-     * @param weaponIconNode 武器图标节点
+     * 植物升级成功动画
+     * 播放植物图标的放大缩小动画，并在升级期间应用扫描效果材质，同时播放升级音效
+     * @param weaponIconNode 植物图标节点
      */
     public playWeaponUpgradeAnimation(weaponIconNode: Node): Promise<void> {
         return new Promise((resolve) => {
@@ -38,6 +39,9 @@ export class UpgradeAni extends Component {
             
             console.log('[UpgradeAni] 开始武器升级动画，weaponSpriteNode:', this.weaponSpriteNode);
             
+            // 播放植物升级音效
+            Audio.playUISound('data/弹球音效/equipment level up finish');
+            
             // 使用装饰器引用的WeaponSprite节点，获取其Sprite组件并保存原始材质
             if (this.weaponSpriteNode) {
                 console.log('[UpgradeAni] 找到weaponSpriteNode，开始获取Sprite组件');

assets/scripts/FourUI/UpgradeSystem/UpgradeController.ts

@@ -3,6 +3,7 @@ import { SaveDataManager, WeaponData } from '../../LevelSystem/SaveDataManager';
 import EventBus, { GameEvents } from '../../Core/EventBus';
 import { PopUPAni } from '../../Animations/PopUPAni';
 import { UpgradeAni } from './UpgradeAni';
+import { Audio } from '../../AudioManager/AudioManager';
 
 const { ccclass, property } = _decorator;
 
@@ -493,6 +494,8 @@ export class UpgradeController extends Component {
      * 关闭升级面板
      */
     private async closeUpgradePanel() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         // 停止UP图标动画
         if (this.upIcon && this.panelAni) {
             this.panelAni.stopIconTipAnimation(this.upIcon);
@@ -712,6 +715,8 @@ export class UpgradeController extends Component {
      * 升级武器
      */
     private onUpgradeWeapon() {
+        // 播放UI点击音效
+        Audio.playUISound('data/弹球音效/ui play');
         console.log(`[UpgradeController] onUpgradeWeapon方法被调用`);
         
         if (!this.currentSelectedWeapon) {

assets/scripts/LevelSystem/GameManager.ts

@@ -243,14 +243,7 @@ export class GameManager extends Component {
     private onGameSuccessEvent() {
         console.log('[GameManager] 接收到游戏成功事件，执行成功处理');
         
-        // 游戏状态管理已迁移到 InGameManager
-        // UI显示控制已迁移到 UIStateManager
-        // 奖励处理已迁移到 GameEnd.ts
-        
-        // 注意：不在这里切换到MAIN_MENU状态，保持IN_GAME状态
-        // 只有用户点击成功界面的按钮时才切换到主界面
-
-        // 执行游戏成功逻辑（仅记录时间和关卡完成）
+        // 只处理数据记录，UI显示和奖励处理已迁移到GameEnd.ts
         this.onGameSuccess();
     }
 
@@ -260,14 +253,7 @@ export class GameManager extends Component {
     private onGameDefeatEvent() {
         console.log('[GameManager] 接收到游戏失败事件，执行失败处理');
         
-        // 游戏状态管理已迁移到 InGameManager
-        // UI显示控制已迁移到 UIStateManager
-        // 奖励处理已迁移到 GameEnd.ts
-        
-        // 注意：不在这里切换到MAIN_MENU状态，保持IN_GAME状态
-        // 只有用户点击失败界面的按钮时才切换到主界面
-
-        // 执行游戏失败逻辑（仅记录时间和统计）
+        // 只处理数据记录，UI显示和奖励处理已迁移到GameEnd.ts
         this.onGameDefeat().catch(error => {
             console.error('[GameManager] 游戏失败处理出错:', error);
         });

assets/scripts/LevelSystem/IN_game.ts

@@ -536,31 +536,31 @@ export class InGameManager extends Component {
 
     /**
      * 触发游戏失败
+     * 只负责记录游戏结束时间和发送事件，状态切换由GameEnd.ts统一处理
      */
     private triggerGameDefeat() {
-        // 立即设置游戏状态为失败，防止后续敌人击杀事件被处理
-        this.currentState = GameState.DEFEAT;
+        // 记录游戏结束时间
         this.gameEndTime = Date.now();
         
         // 触发游戏结束状态事件
         EventBus.getInstance().emit(GameEvents.ENTER_GAME_END_STATE, { result: 'defeat' });
         
-        console.log('[InGameManager] 设置游戏状态为失败，发送GAME_DEFEAT事件');
+        console.log('[InGameManager] 游戏失败，发送GAME_DEFEAT事件，状态切换由GameEnd.ts处理');
         EventBus.getInstance().emit(GameEvents.GAME_DEFEAT);
     }
 
     /**
      * 触发游戏成功
+     * 只负责记录游戏结束时间和发送事件，状态切换由GameEnd.ts统一处理
      */
     private triggerGameSuccess() {
-        // 立即设置游戏状态为成功，防止后续敌人击杀事件被处理
-        this.currentState = GameState.SUCCESS;
+        // 记录游戏结束时间
         this.gameEndTime = Date.now();
         
         // 触发游戏结束状态事件
         EventBus.getInstance().emit(GameEvents.ENTER_GAME_END_STATE, { result: 'success' });
         
-        console.log('[InGameManager] 设置游戏状态为成功，发送GAME_SUCCESS事件');
+        console.log('[InGameManager] 游戏成功，发送GAME_SUCCESS事件，状态切换由GameEnd.ts处理');
         EventBus.getInstance().emit(GameEvents.GAME_SUCCESS);
     }
 

assets/scripts/LevelSystem/UIStateManager.ts

@@ -1,12 +1,13 @@
-import { _decorator, Component, Node, Button, find, Label } from 'cc';
+import { _decorator, Component, Node, Button, find } from 'cc';
 import { BaseSingleton } from '../Core/BaseSingleton';
 import EventBus, { GameEvents } from '../Core/EventBus';
+import { Audio } from '../AudioManager/AudioManager';
 const { ccclass, property } = _decorator;
 
 /**
  * UIStateManager
- * 负责游戏内 UI 面板的显示/隐藏，以及按钮事件分发。
- * 注意：仅处理 Canvas/GameLevelUI 下与战斗胜败相关的 UI。
+ * 负责游戏内 UI 按钮事件分发。
+ * 游戏失败/成功的UI显示逻辑已迁移到GameEnd.ts统一处理。
  */
 @ccclass('UIStateManager')
 export class UIStateManager extends BaseSingleton {
@@ -14,9 +15,6 @@ export class UIStateManager extends BaseSingleton {
 
     @property({ type: Node, tooltip: '游戏结束面板 (Canvas/GameEnd)' })
     public endPanel: Node = null;
-    
-    // 控制是否响应游戏结束事件的标志
-    private shouldRespondToGameEvents: boolean = true;
 
     protected init() {
         // 自动查找面板
@@ -24,16 +22,11 @@ export class UIStateManager extends BaseSingleton {
             this.endPanel = find('Canvas/GameEnd');
         }
 
-        // 默认隐藏
-        if (this.endPanel) this.endPanel.active = false;
-
-        // 绑定按钮
+        // 绑定按钮事件分发
         this.bindPanelButtons();
 
-        // 监听事件
-        EventBus.getInstance().on(GameEvents.GAME_SUCCESS, this.onGameSuccess, this);
-        EventBus.getInstance().on(GameEvents.GAME_DEFEAT, this.onGameDefeat, this);
-        EventBus.getInstance().on(GameEvents.RESET_UI_STATES, this.closeAllPanels, this);
+        // 监听UI重置事件
+        EventBus.getInstance().on(GameEvents.RESET_UI_STATES, this.onResetUI, this);
     }
 
     private bindPanelButtons() {
@@ -45,88 +38,26 @@ export class UIStateManager extends BaseSingleton {
         const buttons = panel.getComponentsInChildren(Button);
         buttons.forEach(btn => {
             btn.node.on(Button.EventType.CLICK, () => {
+                // 播放UI点击音效
+                Audio.playUISound('data/弹球音效/ui play');
                 EventBus.getInstance().emit(btn.node.name.toUpperCase() + '_CLICK');
             });
         });
     }
 
     /**
-     * 设置游戏结束UI的EndLabel文本
-     * @param text 要显示的文本 ('SUCCESS' 或 'DEFEAT')
+     * 处理UI重置事件
+     * 游戏失败/成功的UI显示逻辑已迁移到GameEnd.ts统一处理
      */
-    private setEndLabelText(text: string) {
-        if (!this.endPanel) return;
-        
-        const endLabel = this.endPanel.getChildByPath('Sprite/EndLabel');
-        if (endLabel) {
-            const labelComponent = endLabel.getComponent(Label);
-            if (labelComponent) {
-                labelComponent.string = text;
-                console.log(`[UIStateManager] 设置EndLabel文本为: ${text}`);
-            } else {
-                console.warn('[UIStateManager] 未找到EndLabel的Label组件');
-            }
-        } else {
-            console.warn('[UIStateManager] 未找到EndLabel节点路径: Sprite/EndLabel');
-        }
-    }
-
-    private onGameSuccess() {
-        // 如果被禁用响应游戏事件，则跳过
-        if (!this.shouldRespondToGameEvents) {
-            console.log('[UIStateManager] 已禁用游戏事件响应，跳过GAME_SUCCESS处理');
-            return;
-        }
-        
-        // 奖励处理已迁移到GameEnd.ts，这里只处理EndLabel显示和面板显示
-        if (this.endPanel) {
-            this.setEndLabelText('SUCCESS');
-            this.endPanel.active = true;
-            console.log('[UIStateManager] 显示GameEnd面板 - SUCCESS');
-        }
-    }
-
-    private onGameDefeat() {
-        // 如果被禁用响应游戏事件，则跳过
-        if (!this.shouldRespondToGameEvents) {
-            console.log('[UIStateManager] 已禁用游戏事件响应，跳过GAME_DEFEAT处理');
-            return;
-        }
-        
-        // 奖励处理已迁移到GameEnd.ts，这里只处理EndLabel显示和面板显示
-        if (this.endPanel) {
-            this.setEndLabelText('DEFEAT');
-            this.endPanel.active = true;
-            console.log('[UIStateManager] 显示GameEnd面板 - DEFEAT');
-        }
-    }
-
-    /** 对外接口 */
-    public closeAllPanels() {
-        console.log('[UIStateManager] 重置UI状态，关闭所有面板');
-        
-        // 关闭游戏结束面板
-        if (this.endPanel) {
-            this.endPanel.active = false;
-            console.log('[UIStateManager] 已关闭GameEnd面板');
-        }
-        
-        // 暂时禁用游戏事件响应，避免与GameManager冲突
-        this.shouldRespondToGameEvents = false;
-        
-        // 延迟重新启用游戏事件响应
-        this.scheduleOnce(() => {
-            this.shouldRespondToGameEvents = true;
-            console.log('[UIStateManager] 游戏事件响应已重新启用');
-        }, 1.0);
+    private onResetUI() {
+        console.log('[UIStateManager] 处理UI重置事件');
+        // UI重置逻辑已迁移到GameEnd.ts，这里保留空实现以维持兼容性
     }
 
     protected onDestroy() {
         // 清理事件监听
         const eventBus = EventBus.getInstance();
-        eventBus.off(GameEvents.GAME_SUCCESS, this.onGameSuccess, this);
-        eventBus.off(GameEvents.GAME_DEFEAT, this.onGameDefeat, this);
-        eventBus.off(GameEvents.RESET_UI_STATES, this.closeAllPanels, this);
+        eventBus.off(GameEvents.RESET_UI_STATES, this.onResetUI, this);
         
         super.onDestroy();
     }

test_watermelon_bomb_audio_fix.js

@@ -0,0 +1,147 @@
+/**
+ * 测试西瓜炸弹音效修复
+ * 验证西瓜炸弹在到达目标位置爆炸时是否正确播放音效
+ */
+
+console.log('=== 西瓜炸弹音效修复测试 ===');
+
+// 模拟测试场景
+function testWatermelonBombAudioFix() {
+    console.log('\n1. 问题描述：');
+    console.log('   - 西瓜炸弹有自动追击敌人功能');
+    console.log('   - 当目标敌人被其它子弹提前打死后会绕圈飞行');
+    console.log('   - 使用飞到目标位置就爆炸的方法解决了绕圈问题');
+    console.log('   - 但导致预期的西瓜炸弹音效没有触发');
+    
+    console.log('\n2. 问题原因分析：');
+    console.log('   - BulletTrajectory中距离检测触发爆炸时');
+    console.log('   - 直接调用lifecycle.onHit(this.node)');
+    console.log('   - 没有调用BulletHitEffect.processHit方法');
+    console.log('   - 音效播放在BulletHitEffect.playAttackSound中');
+    console.log('   - 只有在processExplosion中才会播放音效');
+    
+    console.log('\n3. 修复方案：');
+    console.log('   - 在BulletTrajectory距离检测触发爆炸时');
+    console.log('   - 先调用BulletHitEffect.processHit方法');
+    console.log('   - 然后再调用lifecycle.onHit方法');
+    console.log('   - 在processExplosion方法中添加音效播放');
+    
+    return true;
+}
+
+// 验证修复代码
+function verifyAudioFixCode() {
+    console.log('\n=== 验证修复代码 ===');
+    
+    console.log('\n1. BulletTrajectory.ts 修改：');
+    console.log('   修改位置：updateArcTrajectory方法中的距离检测部分');
+    console.log('   修改内容：');
+    console.log('   ```typescript');
+    console.log('   // 先触发命中效果（包括音效播放）');
+    console.log('   const hitEffect = this.getComponent(\'BulletHitEffect\') as any;');
+    console.log('   if (hitEffect && typeof hitEffect.processHit === \'function\') {');
+    console.log('       hitEffect.processHit(this.node, currentPos);');
+    console.log('   }');
+    console.log('   ');
+    console.log('   // 然后通知生命周期组件触发爆炸');
+    console.log('   const lifecycle = this.getComponent(\'BulletLifecycle\') as any;');
+    console.log('   if (lifecycle && typeof lifecycle.onHit === \'function\') {');
+    console.log('       lifecycle.onHit(this.node);');
+    console.log('   }');
+    console.log('   ```');
+    
+    console.log('\n2. BulletHitEffect.ts 修改：');
+    console.log('   修改位置：processExplosion方法中的scheduleExplosion函数');
+    console.log('   修改内容：');
+    console.log('   ```typescript');
+    console.log('   const scheduleExplosion = () => {');
+    console.log('       // 播放爆炸音效');
+    console.log('       this.playAttackSound();');
+    console.log('       ');
+    console.log('       // 生成爆炸特效');
+    console.log('       this.spawnExplosionEffect(position);');
+    console.log('       ');
+    console.log('       // 对范围内敌人造成伤害');
+    console.log('       const damage = this.damageEnemiesInRadius(position, effect.radius, explosionDamage);');
+    console.log('       return damage;');
+    console.log('   };');
+    console.log('   ```');
+}
+
+// 测试音效配置
+function testAudioConfig() {
+    console.log('\n=== 测试音效配置 ===');
+    
+    console.log('\n西瓜炸弹音效配置：');
+    console.log('   武器ID: watermelon_bomb');
+    console.log('   音效路径: data/弹球音效/bomb');
+    console.log('   配置位置: weapons.json -> visualConfig.attackSound');
+    
+    console.log('\n音效播放流程：');
+    console.log('   1. BulletTrajectory检测到达目标位置');
+    console.log('   2. 调用BulletHitEffect.processHit');
+    console.log('   3. processHit调用processExplosion');
+    console.log('   4. processExplosion调用playAttackSound');
+    console.log('   5. playAttackSound读取weaponConfig.visualConfig.attackSound');
+    console.log('   6. 调用Audio.playWeaponSound播放音效');
+}
+
+// 测试预期效果
+function testExpectedBehavior() {
+    console.log('\n=== 测试预期效果 ===');
+    
+    console.log('\n修复后的预期行为：');
+    console.log('   ✅ 西瓜炸弹发射后追踪最近敌人');
+    console.log('   ✅ 到达敌人位置50像素内时自动爆炸');
+    console.log('   ✅ 播放爆炸音效（data/弹球音效/bomb）');
+    console.log('   ✅ 显示爆炸特效');
+    console.log('   ✅ 对范围内敌人造成伤害');
+    console.log('   ✅ 即使敌人被提前击杀，也会在原位置爆炸并播放音效');
+    console.log('   ✅ 不再出现绕圈飞行问题');
+    
+    console.log('\n注意事项：');
+    console.log('   - 音效只播放一次（在爆炸时）');
+    console.log('   - 不会因为对多个敌人造成伤害而重复播放');
+    console.log('   - 爆炸延迟0.1秒后才造成伤害，但音效立即播放');
+}
+
+// 运行所有测试
+function runAllTests() {
+    try {
+        testWatermelonBombAudioFix();
+        verifyAudioFixCode();
+        testAudioConfig();
+        testExpectedBehavior();
+        
+        console.log('\n=== 测试总结 ===');
+        console.log('✅ 西瓜炸弹音效修复完成');
+        console.log('✅ 修复了距离检测触发爆炸时音效缺失问题');
+        console.log('✅ 保持了原有的爆炸逻辑和特效');
+        console.log('✅ 确保音效播放时机正确');
+        
+        console.log('\n📝 使用说明：');
+        console.log('1. 西瓜炸弹发射后会追踪最近的敌人');
+        console.log('2. 到达敌人位置50像素内时自动爆炸并播放音效');
+        console.log('3. 即使敌人被提前击杀，子弹也会在原位置爆炸并播放音效');
+        console.log('4. 音效路径：data/弹球音效/bomb');
+        console.log('5. 爆炸延迟：0.1秒（音效立即播放，伤害延迟）');
+        
+        return true;
+    } catch (error) {
+        console.error('测试过程中出现错误：', error);
+        return false;
+    }
+}
+
+// 执行测试
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        testWatermelonBombAudioFix,
+        verifyAudioFixCode,
+        testAudioConfig,
+        testExpectedBehavior,
+        runAllTests
+    };
+} else {
+    runAllTests();
+}