游戏结束敌人清理

assets/scripts/CombatSystem/EnemyController.ts

@@ -199,13 +199,10 @@ export class EnemyController extends BaseSingleton {
         
         // 监听游戏成功/失败事件
         eventBus.on(GameEvents.GAME_SUCCESS, this.onGameEndEvent, this);
-        eventBus.on(GameEvents.GAME_DEFEAT, this.onGameEndEvent, this);
+        eventBus.on(GameEvents.GAME_DEFEAT, this.onGameDefeatEvent, this);
         
         // 监听敌人相关事件
         eventBus.on(GameEvents.ENEMY_UPDATE_COUNT, this.onUpdateEnemyCountEvent, this);
-        eventBus.on(GameEvents.ENEMY_CHECK_ACTIVE, this.onCheckActiveEnemiesEvent, this);
-        eventBus.on(GameEvents.ENEMY_CHECK_GAME_STARTED, this.onCheckGameStartedEvent, this);
-        eventBus.on(GameEvents.ENEMY_GET_COUNT, this.onGetEnemyCountEvent, this);
         eventBus.on(GameEvents.ENEMY_START_WAVE, this.onStartWaveEvent, this);
         eventBus.on(GameEvents.ENEMY_START_GAME, this.onStartGameEvent, this);
         eventBus.on(GameEvents.ENEMY_SHOW_START_WAVE_PROMPT, this.onShowStartWavePromptEvent, this);
@@ -275,6 +272,14 @@ export class EnemyController extends BaseSingleton {
         this.stopGame(false); // 停止游戏但不清除敌人
     }
     
+    /**
+     * 处理游戏失败事件
+     */
+    private onGameDefeatEvent() {
+        console.log('[EnemyController] 接收到游戏失败事件，直接删除所有敌人');
+        this.stopGame(true); // 停止游戏并清除所有敌人
+    }
+    
     /**
      * 处理清除所有游戏对象事件
      */
@@ -501,8 +506,8 @@ export class EnemyController extends BaseSingleton {
         
         // 只有在指定时才清除所有敌人
         if (clearEnemies) {
-            // 清除敌人，通过事件系统判断是否触发事件
-            this.clearAllEnemies(true);
+            // 清除敌人，在重置状态时不触发事件，避免错误的游戏成功判定
+            this.clearAllEnemies(false);
         }
         
         console.log('停止生成敌人');
@@ -714,7 +719,6 @@ export class EnemyController extends BaseSingleton {
     // 检查是否有活跃敌人
     public hasActiveEnemies(): boolean {
         const activeCount = this.getActiveEnemies().length;
-        console.log(`[EnemyController] hasActiveEnemies() 检查: ${activeCount} 个活跃敌人`);
         return activeCount > 0;
     }
     
@@ -1101,26 +1105,9 @@ export class EnemyController extends BaseSingleton {
         this.updateEnemyCountLabel(killedCount);
     }
 
-    /**
-     * 处理检查活跃敌人事件
-     */
-    private onCheckActiveEnemiesEvent(callback: (active: boolean) => void) {
-        callback(this.hasActiveEnemies());
-    }
 
-    /**
-     * 处理检查游戏是否开始事件
-     */
-    private onCheckGameStartedEvent(callback: (started: boolean) => void) {
-        callback(this.isGameStarted());
-    }
 
-    /**
-     * 处理获取敌人数量事件
-     */
-    private onGetEnemyCountEvent(callback: (count: number) => void) {
-        callback(this.getCurrentEnemyCount());
-    }
+
 
     /**
      * 处理启动波次事件
@@ -1155,9 +1142,8 @@ export class EnemyController extends BaseSingleton {
         
         // 清理新增的事件监听
         eventBus.off(GameEvents.ENEMY_UPDATE_COUNT, this.onUpdateEnemyCountEvent, this);
-        eventBus.off(GameEvents.ENEMY_CHECK_ACTIVE, this.onCheckActiveEnemiesEvent, this);
-        eventBus.off(GameEvents.ENEMY_CHECK_GAME_STARTED, this.onCheckGameStartedEvent, this);
-        eventBus.off(GameEvents.ENEMY_GET_COUNT, this.onGetEnemyCountEvent, this);
+
+
         eventBus.off(GameEvents.ENEMY_START_WAVE, this.onStartWaveEvent, this);
         eventBus.off(GameEvents.ENEMY_START_GAME, this.onStartGameEvent, this);
         eventBus.off(GameEvents.ENEMY_SHOW_START_WAVE_PROMPT, this.onShowStartWavePromptEvent, this);

assets/scripts/CombatSystem/EnemyInstance.ts

@@ -182,6 +182,12 @@ export class EnemyInstance extends Component {
         console.log(`[EnemyInstance] onDestroy 被调用，准备通知控制器`);
         // 通知控制器 & GameManager
         if (this.controller && typeof (this.controller as any).notifyEnemyDead === 'function') {
+            // 检查控制器是否处于清理状态，避免在清理过程中触发游戏事件
+            const isClearing = (this.controller as any).isClearing;
+            if (isClearing) {
+                console.log(`[EnemyInstance] 控制器处于清理状态，跳过死亡通知`);
+                return;
+            }
             console.log(`[EnemyInstance] 调用 notifyEnemyDead`);
             (this.controller as any).notifyEnemyDead(this.node);
         } else {

assets/scripts/CombatSystem/GamePause.ts

@@ -41,6 +41,12 @@ export class GamePause extends Component {
         // 监听游戏开始和结束事件来更新游戏模式状态
         eventBus.on(GameEvents.GAME_START, this.onGameStartEvent, this);
         
+        // 监听游戏暂停事件
+        eventBus.on(GameEvents.GAME_PAUSE, this.onGamePauseEvent, this);
+        
+        // 监听游戏恢复事件
+        eventBus.on(GameEvents.GAME_RESUME, this.onGameResumeEvent, this);
+        
         // 监听子弹发射检查事件
         eventBus.on(GameEvents.BALL_FIRE_BULLET, this.onBallFireBulletEvent, this);
         
@@ -67,6 +73,22 @@ export class GamePause extends Component {
         this.isInGameMode = true;
     }
     
+    /**
+     * 处理游戏暂停事件
+     */
+    private onGamePauseEvent() {
+        console.log('[GamePause] 接收到游戏暂停事件');
+        this.pauseGame();
+    }
+    
+    /**
+     * 处理游戏恢复事件
+     */
+    private onGameResumeEvent() {
+        console.log('[GamePause] 接收到游戏恢复事件');
+        this.resumeGame();
+    }
+    
     /**
      * 处理游戏结束事件
      */
@@ -108,10 +130,8 @@ export class GamePause extends Component {
             return;
         }
         
-        if (this.isGameOver()) {
-            console.log('[GamePause] 游戏已结束，无法暂停，当前状态:', this.currentState);
-            return;
-        }
+        // 移除游戏结束检查，允许游戏结束时也能暂停
+        // 这样可以在成功/失败时暂停所有游戏对象的行为
 
         console.log('[GamePause] 设置游戏状态为暂停，之前状态:', this.currentState);
         this.currentState = GameState.PAUSED;
@@ -278,6 +298,8 @@ export class GamePause extends Component {
         const eventBus = EventBus.getInstance();
         eventBus.off(GameEvents.RESET_GAME_PAUSE, this.onResetGamePauseEvent, this);
         eventBus.off(GameEvents.GAME_START, this.onGameStartEvent, this);
+        eventBus.off(GameEvents.GAME_PAUSE, this.onGamePauseEvent, this);
+        eventBus.off(GameEvents.BALL_FIRE_BULLET, this.onBallFireBulletEvent, this);
         eventBus.off(GameEvents.GAME_CHECK_OVER, this.onGameCheckOverEvent, this);
         
         GamePause._instance = null;

assets/scripts/Core/EventBus.ts

@@ -63,9 +63,8 @@ export enum GameEvents {
     ENEMY_SPAWN_REQUEST = 'ENEMY_SPAWN_REQUEST',
     ENEMY_GET_NEAREST = 'ENEMY_GET_NEAREST',
     ENEMY_UPDATE_COUNT = 'ENEMY_UPDATE_COUNT',
-    ENEMY_CHECK_ACTIVE = 'ENEMY_CHECK_ACTIVE',
-    ENEMY_CHECK_GAME_STARTED = 'ENEMY_CHECK_GAME_STARTED',
-    ENEMY_GET_COUNT = 'ENEMY_GET_COUNT',
+
+
     ENEMY_START_WAVE = 'ENEMY_START_WAVE',
     ENEMY_START_GAME = 'ENEMY_START_GAME',
     ENEMY_SHOW_START_WAVE_PROMPT = 'ENEMY_SHOW_START_WAVE_PROMPT',

assets/scripts/LevelSystem/GameManager.ts

@@ -542,8 +542,11 @@ export class GameManager extends Component {
     private onMainMenuClick() {
         console.log('[GameManager] 返回主菜单');
         
-        // 1. 通过InGameManager清理游戏数据（敌人清除、能量条重置、方块清除、敌人波数和数量重置）
+        // 1. 无论游戏状态如何，都进行清理（游戏结束时只是暂停，需要在此时清理）
         const inGameManager = this.getInGameManager();
+        const currentGameState = inGameManager?.getCurrentState();
+        
+        console.log(`[GameManager] 当前游戏状态：${currentGameState}，开始清理游戏数据`);
         if (inGameManager) {
             console.log('[GameManager] 触发游戏数据清理');
             inGameManager.triggerGameDataCleanup();

assets/scripts/LevelSystem/IN_game.ts

@@ -291,6 +291,9 @@ export class InGameManager extends Component {
             console.log('[InGameManager] 技能选择UI已关闭');
         }
         
+        // 恢复游戏
+        this.resumeGame();
+        
         // 如果有等待的diban动画，现在播放diban动画
         if (this.pendingBlockSelection) {
             console.log('[InGameManager] 技能选择完成，现在播放diban动画');
@@ -352,6 +355,11 @@ export class InGameManager extends Component {
     private onGameSuccessEvent() {
         console.log('[InGameManager] 接收到游戏成功事件');
         this.currentState = GameState.SUCCESS;
+        
+        // 游戏结束时进入暂停状态，停止所有游戏对象的行为
+        console.log('[InGameManager] 游戏成功，触发游戏暂停');
+        const eventBus = EventBus.getInstance();
+        eventBus.emit(GameEvents.GAME_PAUSE);
     }
 
     /**
@@ -360,6 +368,11 @@ export class InGameManager extends Component {
     private onGameDefeatEvent() {
         console.log('[InGameManager] 接收到游戏失败事件');
         this.currentState = GameState.DEFEAT;
+        
+        // 游戏结束时进入暂停状态，停止所有游戏对象的行为
+        console.log('[InGameManager] 游戏失败，触发游戏暂停');
+        const eventBus = EventBus.getInstance();
+        eventBus.emit(GameEvents.GAME_PAUSE);
     }
 
     /**
@@ -401,35 +414,29 @@ export class InGameManager extends Component {
         // 检查能量是否已满，如果满了需要触发技能选择
         const energyWillBeFull = energyBeforeIncrement + 1 >= this.energyMax;
         
-        // 通过事件系统检查是否有活跃敌人
-        let hasActiveEnemies = false;
-        EventBus.getInstance().emit(GameEvents.ENEMY_CHECK_ACTIVE, (active: boolean) => {
-            hasActiveEnemies = active;
-            
-            // 在回调中检查波次是否结束
-            const isWaveEnd = remaining <= 0 && !hasActiveEnemies;
+        // 基于UI显示的敌人数量判断波次是否结束（Canvas-001/TopArea/EnemyNode/EnemyNumber为0）
+        const isWaveEnd = remaining <= 0;
+        
+        if (isWaveEnd) {
+            console.log(`[InGameManager] 波次结束检测: remaining=${remaining}`);
             
-            if (isWaveEnd) {
-                console.log(`[InGameManager] 波次结束检测: remaining=${remaining}, hasActiveEnemies=${hasActiveEnemies}`);
-                
-                // 如果能量已满，设置等待方块选择状态
-                if (energyWillBeFull) {
-                    this.pendingBlockSelection = true;
-                    this.preparingNextWave = true;
-                    this.currentState = GameState.BLOCK_SELECTION;
+            // 如果能量已满，设置等待方块选择状态
+            if (energyWillBeFull) {
+                this.pendingBlockSelection = true;
+                this.preparingNextWave = true;
+                this.currentState = GameState.BLOCK_SELECTION;
+            } else {
+                if (this.currentWave < (this.levelWaves?.length || 1)) {
+                    this.showNextWavePrompt();
                 } else {
-                    if (this.currentWave < (this.levelWaves?.length || 1)) {
-                        this.showNextWavePrompt();
-                    } else {
-                        this.triggerGameSuccess();
-                    }
+                    this.triggerGameSuccess();
                 }
-            } else if (energyWillBeFull) {
-                // 如果波次未结束但能量已满，也需要触发技能选择
-                console.log('[InGameManager] 能量已满但波次未结束，触发技能选择');
-                this.currentState = GameState.BLOCK_SELECTION;
             }
-        });
+        } else if (energyWillBeFull) {
+            // 如果波次未结束但能量已满，也需要触发技能选择
+            console.log('[InGameManager] 能量已满但波次未结束，触发技能选择');
+            this.currentState = GameState.BLOCK_SELECTION;
+        }
     }
 
     /**
@@ -492,39 +499,17 @@ export class InGameManager extends Component {
      * 检查所有敌人是否被击败
      */
     private checkAllEnemiesDefeated(): boolean {
-        // 通过事件系统检查游戏是否开始
-        let gameStarted = false;
-        EventBus.getInstance().emit(GameEvents.ENEMY_CHECK_GAME_STARTED, (started: boolean) => {
-            gameStarted = started;
-        });
-
+        // 如果敌人生成还未开始，不进行胜利检查
         if (!this.enemySpawningStarted) {
-            if (gameStarted) {
-                this.enemySpawningStarted = true;
-            } else {
-                return false;
-            }
+            return false;
         }
 
-        // 通过事件系统获取当前敌人数量
-        let currentEnemyCount = 0;
-        EventBus.getInstance().emit(GameEvents.ENEMY_GET_COUNT, (count: number) => {
-            currentEnemyCount = count;
-        });
-
-        if (this.levelTotalEnemies > 0) {
-            return this.enemiesKilled >= this.levelTotalEnemies && currentEnemyCount === 0;
-        }
-
-        if (currentEnemyCount > this.totalEnemiesSpawned) {
-            this.totalEnemiesSpawned = currentEnemyCount;
-        }
-
-        const shouldCheckVictory = this.enemySpawningStarted && 
-                                 currentEnemyCount === 0 && 
-                                 this.totalEnemiesSpawned > 0;
-
-        return shouldCheckVictory;
+        // 基于当前波次的敌人击杀数量判断是否胜利
+        // 如果当前波次的剩余敌人数量为0，且是最后一波，则胜利
+        const currentWaveRemaining = this.currentWaveTotalEnemies - this.currentWaveEnemyCount;
+        const isLastWave = this.currentWave >= (this.levelWaves?.length || 1);
+        
+        return currentWaveRemaining <= 0 && isLastWave;
     }
 
     /**
@@ -647,6 +632,14 @@ export class InGameManager extends Component {
         EventBus.getInstance().emit(GameEvents.GAME_PAUSE);
     }
     
+    /**
+     * 恢复游戏
+     */
+    private resumeGame() {
+        console.log('[InGameManager] 恢复游戏');
+        EventBus.getInstance().emit(GameEvents.GAME_RESUME);
+    }
+    
     /**
      * 检查游戏是否结束
      */
@@ -958,6 +951,13 @@ export class InGameManager extends Component {
         eventBus.emit(GameEvents.RESET_WALL_HEALTH);         // 重置墙体血量
         eventBus.emit(GameEvents.RESET_UI_STATES);           // 重置UI状态
         
+        // 8. 发送游戏结束事件，确保游戏状态正确转换
+        console.log('[InGameManager] 发送游戏结束事件');
+        eventBus.emit('GAME_END');
+        
+        // 9. 重置游戏状态为初始状态
+        this.currentState = GameState.PLAYING;
+        
         console.log('[InGameManager] 游戏数据清理完成，可以安全返回主页面');
     }