敌人数量波次显示

assets/scripts/CombatSystem/BallController.ts

@@ -66,12 +66,11 @@ export class BallController extends Component {
         if (!this.placedBlocksContainer) {
             this.placedBlocksContainer = find('Canvas/GameLevelUI/PlacedBlocks');
             if (!this.placedBlocksContainer) {
-                console.warn('找不到PlacedBlocks节点，某些功能可能无法正常工作');
+                // 找不到PlacedBlocks节点，某些功能可能无法正常工作
             }
         }
         
         // 只进行初始设置，不创建小球
-        console.log('🎮 BallController 已准备就绪，等待确定按钮触发');
         this.calculateGameBounds();
         
         // 延迟执行一些检查方法，但不创建小球
@@ -85,13 +84,11 @@ export class BallController extends Component {
         // 获取GameArea节点
         const gameArea = find('Canvas/GameLevelUI/GameArea');
         if (!gameArea) {
-            console.error('找不到GameArea节点');
             return;
         }
 
         const gameAreaUI = gameArea.getComponent(UITransform);
         if (!gameAreaUI) {
-            console.error('GameArea节点没有UITransform组件');
             return;
         }
 
@@ -107,15 +104,12 @@ export class BallController extends Component {
         this.gameBounds.right = worldPos.x + areaWidth / 2;
         this.gameBounds.bottom = worldPos.y - areaHeight / 2;
         this.gameBounds.top = worldPos.y + areaHeight / 2;
-
-        console.log('GameArea Bounds:', this.gameBounds);
         
     }
 
     // 创建小球
     createBall() {
         if (!this.ballPrefab) {
-            console.error('未设置Ball预制体');
             return;
         }
 
@@ -142,38 +136,26 @@ export class BallController extends Component {
         const transform = this.activeBall.getComponent(UITransform);
         if (transform) {
             this.radius = transform.width / 2;
-            console.log('小球半径设置为:', this.radius);
         } else {
             this.radius = 25; // 默认半径
-            console.warn('无法获取小球UITransform组件，使用默认半径:', this.radius);
         }
 
         // 确保有碰撞组件
         this.setupCollider();
 
         // 注意：不在这里初始化方向，等待 startBall() 调用
-        console.log('⏸️ 小球已创建但暂未开始运动，等待启动指令');
 
         this.initialized = true;
-        console.log('小球创建完成:', {
-            position: this.activeBall.position,
-            radius: this.radius,
-            initialized: this.initialized,
-            hasMovement: false // 表示尚未开始运动
-        });
     }
 
     // 检查所有已放置方块的碰撞体组件
     private checkBlockColliders() {
-        console.log('🔍 === 检查方块碰撞体组件 ===');
         
         if (!this.placedBlocksContainer) {
-            console.log('❌ PlacedBlocks容器未设置');
             return;
         }
         
         if (!this.placedBlocksContainer.isValid) {
-            console.log('❌ PlacedBlocks容器已失效');
             return;
         }
         
@@ -185,34 +167,22 @@ export class BallController extends Component {
             }
         }
         
-        console.log(`找到 ${blocks.length} 个方块`);
-        
         let fixedCount = 0;
         
         for (let i = 0; i < blocks.length; i++) {
             const block = blocks[i];
-            console.log(`\n检查方块 ${i + 1}: ${block.name}`);
-            console.log('方块路径:', this.getNodePath(block));
             
             // 检查方块本身的碰撞体
             const blockCollider = block.getComponent(Collider2D);
-            console.log('方块有碰撞体:', !!blockCollider);
             if (blockCollider) {
-                console.log('碰撞体类型:', blockCollider.constructor.name);
-                console.log('碰撞组:', blockCollider.group);
-                console.log('碰撞标签:', blockCollider.tag);
-                console.log('是否为传感器:', blockCollider.sensor);
-                
                 // 🔧 自动修复碰撞组设置
                 if (blockCollider.group !== 2) {
-                    console.log(`🔧 修复方块碰撞组: ${blockCollider.group} -> 2`);
                     blockCollider.group = 2; // 设置为Block组
                     fixedCount++;
                 }
                 
                 // 确保不是传感器
                 if (blockCollider.sensor) {
-                    console.log(`🔧 修复方块传感器设置: true -> false`);
                     blockCollider.sensor = false;
                 }
             }
@@ -221,23 +191,15 @@ export class BallController extends Component {
             const b1Node = block.getChildByName('B1');
             if (b1Node) {
                 const b1Collider = b1Node.getComponent(Collider2D);
-                console.log('B1子节点有碰撞体:', !!b1Collider);
                 if (b1Collider) {
-                    console.log('B1碰撞体类型:', b1Collider.constructor.name);
-                    console.log('B1碰撞组:', b1Collider.group);
-                    console.log('B1碰撞标签:', b1Collider.tag);
-                    console.log('B1是否为传感器:', b1Collider.sensor);
-                    
                     // 🔧 修复B1子节点的碰撞设置
                     if (b1Collider.group !== 2) {
-                        console.log(`🔧 修复B1碰撞组: ${b1Collider.group} -> 2`);
                         b1Collider.group = 2; // 设置为Block组
                         fixedCount++;
                     }
                     
                     // 确保B1不是传感器（需要实际碰撞）
                     if (b1Collider.sensor) {
-                        console.log(`🔧 修复B1传感器设置: true -> false`);
                         b1Collider.sensor = false;
                     }
                 }
@@ -245,17 +207,10 @@ export class BallController extends Component {
             
             // 检查Weapon子节点
             const weaponNode = this.findWeaponNode(block);
-            console.log('方块有Weapon节点:', !!weaponNode);
             if (weaponNode) {
-                console.log('Weapon节点路径:', this.getNodePath(weaponNode));
+                // 武器节点存在
             }
         }
-        
-        if (fixedCount > 0) {
-            console.log(`✅ 已修复 ${fixedCount} 个碰撞组设置`);
-        }
-        
-        console.log('🔍 === 方块碰撞体检查完成 ===');
     }
 
     // 随机位置小球
@@ -274,19 +229,16 @@ export class BallController extends Component {
         // 获取GameArea节点
         const gameArea = find('Canvas/GameLevelUI/GameArea');
         if (!gameArea) {
-            console.error('找不到GameArea节点');
             return;
         }
         
         // 查找PlacedBlocks节点，它包含所有放置的方块
         if (!this.placedBlocksContainer) {
-            console.log('找不到PlacedBlocks节点，使用默认随机位置');
             this.setRandomPositionDefault(minX, maxX, minY, maxY);
             return;
         }
         
         if (!this.placedBlocksContainer.isValid) {
-            console.log('PlacedBlocks容器已失效，使用默认随机位置');
             this.setRandomPositionDefault(minX, maxX, minY, maxY);
             return;
         }
@@ -301,8 +253,6 @@ export class BallController extends Component {
             }
         }
         
-        console.log(`找到 ${placedBlocks.length} 个已放置的方块`);
-        
         // 如果没有方块，使用默认随机位置
         if (placedBlocks.length === 0) {
             this.setRandomPositionDefault(minX, maxX, minY, maxY);
@@ -355,7 +305,6 @@ export class BallController extends Component {
         
         // 如果找不到有效位置，使用默认位置（游戏区域底部中心）
         if (!validPosition) {
-            console.log(`尝试 ${maxAttempts} 次后未找到有效位置，使用默认位置`);
             randomX = (this.gameBounds.left + this.gameBounds.right) / 2;
             randomY = this.gameBounds.bottom + ballRadius + 50; // 底部上方50单位
         }
@@ -363,14 +312,6 @@ export class BallController extends Component {
         // 将世界坐标转换为相对于GameArea的本地坐标
         const localPos = gameArea.getComponent(UITransform).convertToNodeSpaceAR(new Vec3(randomX, randomY, 0));
         this.activeBall.position = localPos;
-        
-        console.log('小球位置已设置:', {
-            worldX: randomX,
-            worldY: randomY,
-            localX: localPos.x,
-            localY: localPos.y,
-            overlapsWithBlock: !validPosition
-        });
     }
 
     // 设置默认随机位置
@@ -388,24 +329,15 @@ export class BallController extends Component {
             // 直接设置位置（不太准确，但作为后备）
             this.activeBall.position = new Vec3(randomX - this.gameBounds.left, randomY - this.gameBounds.bottom, 0);
         }
-        
-        console.log('使用默认随机位置设置小球:', {
-            worldX: randomX,
-            worldY: randomY
-        });
     }
 
     // 设置碰撞组件
     setupCollider() {
         if (!this.activeBall) return;
 
-        console.log('⚙️ === 开始设置小球碰撞组件 ===');
-        console.log('小球节点:', this.activeBall.name);
-
         // 确保小球有刚体组件
         let rigidBody = this.activeBall.getComponent(RigidBody2D);
         if (!rigidBody) {
-            console.log('🔧 添加RigidBody2D组件...');
             rigidBody = this.activeBall.addComponent(RigidBody2D);
             rigidBody.type = 2; // Dynamic
             rigidBody.gravityScale = 0; // 不受重力影响
@@ -414,9 +346,7 @@ export class BallController extends Component {
             rigidBody.allowSleep = false; // 不允许休眠
             rigidBody.linearDamping = 0; // 无线性阻尼，保持速度不衰减
             rigidBody.angularDamping = 0; // 无角阻尼
-            console.log('✅ RigidBody2D组件已添加');
         } else {
-            console.log('✅ RigidBody2D组件已存在，更新设置...');
             // 确保已有的刚体组件设置正确
             rigidBody.enabledContactListener = true;
             rigidBody.gravityScale = 0;
@@ -428,7 +358,6 @@ export class BallController extends Component {
         // 确保小球有碰撞组件
         let collider = this.activeBall.getComponent(CircleCollider2D);
         if (!collider) {
-            console.log('🔧 添加CircleCollider2D组件...');
             collider = this.activeBall.addComponent(CircleCollider2D);
             collider.radius = this.radius || 25; // 使用已计算的半径或默认值
             collider.tag = 1; // 小球标签
@@ -436,9 +365,7 @@ export class BallController extends Component {
             collider.sensor = false; // 非传感器（实际碰撞）
             collider.friction = 0; // 无摩擦
             collider.restitution = 1; // 完全弹性碰撞
-            console.log('✅ CircleCollider2D组件已添加');
         } else {
-            console.log('✅ CircleCollider2D组件已存在，更新设置...');
             // 确保已有的碰撞组件设置正确
             collider.sensor = false;
             collider.restitution = 1;
@@ -446,15 +373,6 @@ export class BallController extends Component {
             collider.tag = 1; // 确保标签正确
         }
 
-        console.log('🔧 小球碰撞组件设置完成:', {
-            hasRigidBody: !!rigidBody,
-            hasCollider: !!collider,
-            radius: collider ? collider.radius : 'unknown',
-            contactListener: rigidBody ? rigidBody.enabledContactListener : false,
-            group: collider ? collider.group : 'unknown',
-            tag: collider ? collider.tag : 'unknown'
-        });
-
         // === 使用全局回调监听器 ===
         const physics = PhysicsManager.getInstance()?.getSystem();
         if (physics) {
@@ -468,11 +386,7 @@ export class BallController extends Component {
             physics.on(Contact2DType.END_CONTACT, this.onEndContact, this);
             physics.on(Contact2DType.PRE_SOLVE, this.onPreSolve, this);
             physics.on(Contact2DType.POST_SOLVE, this.onPostSolve, this);
-            console.log('✅ 已注册全局碰撞监听器');
         }
-
-        console.log('✅ 小球碰撞组件设置完成');
-        console.log('⚙️ === 碰撞组件设置完成 ===');
     }
 
     // 碰撞回调 - 简化版本用于测试
@@ -500,8 +414,6 @@ export class BallController extends Component {
             return;
         }
         
-        // Debug log removed
-        
         // 检查碰撞对象是否为方块
         const nodeName = blockNode.name;
         const nodePath = this.getNodePath(blockNode);
@@ -513,8 +425,6 @@ export class BallController extends Component {
             nodePath.includes('Block') ||
             hasWeaponChild;
             
-        // Debug log removed
-            
         if (isBlock) {
             // trigger bullet without verbose logging
             // 计算碰撞世界坐标，默认用接触点
@@ -609,25 +519,18 @@ export class BallController extends Component {
      */
     fireBullet(blockNode: Node) {
         // Debug logs removed
-        console.log('🔫 === 方块武器发射子弹流程 ===');
-        console.log('激活的方块:', blockNode.name);
-        console.log('方块路径:', this.getNodePath(blockNode));
         
         // 检查子弹预制体是否存在
         if (!this.bulletPrefab) {
-            console.error('❌ 子弹预制体未设置');
             return;
         }        
         
         // 查找方块中的Weapon节点
-        console.log('🔍 开始查找方块中的Weapon节点...');
         const weaponNode = this.findWeaponNode(blockNode);
         if (!weaponNode) {
-            console.error('❌ 在方块中找不到Weapon节点:', blockNode.name);
             const blockWorldPos = blockNode.worldPosition;
             const weaponConfig2: WeaponConfig | null = (blockNode as any)['weaponConfig'] || null;
             this.createAndFireBullet(blockWorldPos, weaponConfig2);
-            console.log('🔫 === 方块武器发射子弹流程结束 ===');
             return;
         }
         
@@ -636,7 +539,6 @@ export class BallController extends Component {
         try {
             firePosition = weaponNode.worldPosition;
         } catch (error) {
-            console.error('❌ 获取武器坐标失败:', error);
             // 备用方案：使用方块坐标
             firePosition = blockNode.worldPosition;
         }
@@ -644,8 +546,6 @@ export class BallController extends Component {
         // 创建并发射子弹
         const weaponConfig: WeaponConfig | null = (blockNode as any)['weaponConfig'] || null;
         this.createAndFireBullet(firePosition, weaponConfig);
-        
-        console.log('🔫 === 方块武器发射子弹流程结束 ===');
     }
     
     /**
@@ -654,7 +554,6 @@ export class BallController extends Component {
      * @param weaponConfig 武器配置
      */
     private createAndFireBullet(firePosition: Vec3, weaponConfig: WeaponConfig | null) {
-        console.log('🔫 === 开始创建子弹（新WeaponBullet系统）===');
         
         // 确保武器配置加载
         WeaponBullet.loadWeaponsData().then(() => {
@@ -663,7 +562,6 @@ export class BallController extends Component {
             const finalConfig = weaponConfig || WeaponBullet.getWeaponConfig(defaultWeaponId);
             
             if (!finalConfig) {
-                console.error('❌ 无法获取武器配置');
                 return;
             }
             
@@ -677,7 +575,6 @@ export class BallController extends Component {
             
             // 验证初始化数据
             if (!WeaponBullet.validateInitData(initData)) {
-                console.error('❌ 子弹初始化数据无效');
                 return;
             }
             
@@ -688,7 +585,6 @@ export class BallController extends Component {
             // 查找GameArea（子弹统一添加到此节点）
             const gameArea = find('Canvas/GameLevelUI/GameArea');
             if (!gameArea) {
-                console.error('❌ 找不到GameArea节点');
                 return;
             }
 
@@ -698,12 +594,10 @@ export class BallController extends Component {
                 bullets.forEach(b => {
                     gameArea.addChild(b);
                 });
-                console.log(`✅ 已创建多发子弹 (${bullets.length} 发)`);
             } else {
                 // 单发逻辑（沿用原流程）
                 const bullet = instantiate(this.bulletPrefab);
                 if (!bullet) {
-                    console.error('❌ 子弹实例创建失败');
                     return;
                 }
 
@@ -715,48 +609,39 @@ export class BallController extends Component {
                 }
 
                 weaponBullet.init(initData);
-                console.log('✅ 新子弹系统创建完成 (单发)');
             }
-
-            console.log('🔫 === 子弹创建完成 ===');
             
         }).catch(error => {
-            console.error('❌ 武器配置加载失败:', error);
+            // 武器配置加载失败
         });
     }
     
     // 递归查找Weapon节点
     private findWeaponNode(node: Node): Node | null {
         // logs removed
-        console.log(`🔍 在节点 ${node.name} 中查找Weapon...`);
         
         // 先检查当前节点是否有Weapon子节点
         const weaponNode = node.getChildByName('Weapon');
         if (weaponNode) {
-            console.log(`✅ 在 ${node.name} 中找到Weapon节点`);
             return weaponNode;
         }
         
         // 如果没有，递归检查所有子节点
         for (let i = 0; i < node.children.length; i++) {
             const child = node.children[i];
-            console.log(`  🔍 检查子节点: ${child.name}`);
             const foundWeapon = this.findWeaponNode(child);
             if (foundWeapon) {
-                console.log(`✅ 在 ${child.name} 的子节点中找到Weapon`);
                 return foundWeapon;
             }
         }
         
         // 如果都没找到，返回null
-        console.log(`❌ 在 ${node.name} 及其子节点中未找到Weapon`);
         return null;
     }
 
     // 辅助方法：打印节点结构
     private logNodeStructure(node: Node, depth: number) {
         const indent = '  '.repeat(depth);
-        console.log(`${indent}${node.name}`);
         for (let i = 0; i < node.children.length; i++) {
             this.logNodeStructure(node.children[i], depth + 1);
         }
@@ -837,47 +722,25 @@ export class BallController extends Component {
         }
         
         if (nearestBlock && nearestDistance < 100) {
-            console.log(`⚠️  小球接近方块但无物理碰撞: 距离=${nearestDistance.toFixed(1)}, 方块=${nearestBlock.name}`);
-            console.log('小球位置:', ballPos);
-            console.log('方块位置:', nearestBlock.worldPosition);
-            
             // 检查小球的碰撞体状态
-            console.log('=== 小球碰撞体详细检查 ===');
             const ballCollider = this.activeBall.getComponent(Collider2D);
-            console.log('小球有碰撞体:', !!ballCollider);
             if (ballCollider) {
-                console.log('小球碰撞体类型:', ballCollider.constructor.name);
-                console.log('小球碰撞组:', ballCollider.group);
-                console.log('小球碰撞标签:', ballCollider.tag);
-                console.log('小球是否为传感器:', ballCollider.sensor);
-                console.log('小球碰撞体是否启用:', ballCollider.enabled);
                 if (ballCollider instanceof CircleCollider2D) {
-                    console.log('小球碰撞半径:', ballCollider.radius);
+                    // 小球碰撞半径检查
                 }
             }
             
             // 检查小球的刚体状态
             const ballRigidBody = this.activeBall.getComponent(RigidBody2D);
-            console.log('小球有刚体:', !!ballRigidBody);
             if (ballRigidBody) {
-                console.log('小球刚体类型:', ballRigidBody.type);
-                console.log('小球刚体启用碰撞监听:', ballRigidBody.enabledContactListener);
-                console.log('小球刚体是否启用:', ballRigidBody.enabled);
+                // 刚体状态检查
             }
             
             // 检查最近的方块碰撞体
-            console.log('=== 方块碰撞体详细检查 ===');
             const blockCollider = nearestBlock.getComponent(Collider2D);
-            console.log('方块有碰撞体:', !!blockCollider);
             if (blockCollider) {
-                console.log('方块碰撞体类型:', blockCollider.constructor.name);
-                console.log('方块碰撞组:', blockCollider.group);
-                console.log('方块碰撞标签:', blockCollider.tag);
-                console.log('方块是否为传感器:', blockCollider.sensor);
-                console.log('方块碰撞体是否启用:', blockCollider.enabled);
+                // 方块碰撞体检查
             }
-            
-            // （已移除碰撞矩阵与物理引擎状态的冗余调试输出）
         }
     }
     
@@ -897,15 +760,11 @@ export class BallController extends Component {
         const mask1 = collisionMatrix[group1.toString()];
         const mask2 = collisionMatrix[group2.toString()];
         
-        // (调试输出移除)
-        
         // 检查group1是否能与group2碰撞
         const canCollide1to2 = mask1 && (mask1 & (1 << group2)) !== 0;
         // 检查group2是否能与group1碰撞
         const canCollide2to1 = mask2 && (mask2 & (1 << group1)) !== 0;
         
-        // (调试输出移除)
-        
         return canCollide1to2 && canCollide2to1;
     }
 
@@ -916,8 +775,6 @@ export class BallController extends Component {
         this.direction.x = Math.cos(angle);
         this.direction.y = Math.sin(angle);
         this.direction.normalize();
-
-        console.log('Ball initialized with direction:', this.direction);
         
         // 设置初始速度
         if (this.activeBall) {
@@ -927,16 +784,12 @@ export class BallController extends Component {
                     this.direction.x * this.speed,
                     this.direction.y * this.speed
                 );
-                console.log('Ball initial velocity set:', rigidBody.linearVelocity);
-            } else {
-                console.error('无法找到小球的RigidBody2D组件');
             }
         }
     }
 
     // 初始化球的参数 - 公开方法，供GameManager调用
     public initialize() {
-        console.log('🎮 === BallController 初始化 ===');
         this.calculateGameBounds();
         this.createBall();
         
@@ -944,13 +797,10 @@ export class BallController extends Component {
         this.scheduleOnce(() => {
             this.checkBlockColliders();
         }, 0.5);
-        
-        console.log('🎮 === BallController 初始化完成 ===');
     }
     
     // 启动小球 - 公开方法，在确定按钮点击后调用
     public startBall() {
-        console.log('🚀 === 启动小球系统 ===');
         
         // 如果还没有初始化，先初始化
         if (!this.initialized) {
@@ -959,12 +809,10 @@ export class BallController extends Component {
         
         // 确保小球存在且有效
         if (!this.activeBall || !this.activeBall.isValid) {
-            console.log('⚠️ 小球不存在，重新创建...');
             this.createBall();
         }
         
         // 重新定位小球，避免与方块重叠
-        console.log('📍 重新定位小球位置...');
         this.positionBallRandomly();
         
         // 确保物理组件设置正确
@@ -975,8 +823,6 @@ export class BallController extends Component {
         
         // 设置运动状态
         this.ballStarted = true;
-        
-        console.log('🚀 === 小球系统启动完成，开始运动 ===');
     }
 
     // 输出碰撞矩阵调试信息
@@ -992,37 +838,26 @@ export class BallController extends Component {
             "5": 18
         };
         
-        // (调试输出移除)
-        
         // 测试Ball组(1)和Block组(2)是否能碰撞
         const ballMask = collisionMatrix["1"]; // 39
         const blockMask = collisionMatrix["2"]; // 6
         
         const ballCanCollideWithBlock = (ballMask & (1 << 2)) !== 0; // 检查Ball能否与组2碰撞
         const blockCanCollideWithBall = (blockMask & (1 << 1)) !== 0; // 检查Block能否与组1碰撞
-        
-        // (调试输出移除)
-        
-        // (调试输出移除)
     }
 
     /**
      * 从给定世界坐标发射子弹
      */
     private fireBulletAt(blockNode: Node, fireWorldPos: Vec3) {
-        console.log('🔫 === 方块武器发射子弹流程 ===');
-        console.log('激活的方块:', blockNode.name);
-        console.log('方块路径:', this.getNodePath(blockNode));
         
         // 检查子弹预制体是否存在
         if (!this.bulletPrefab) {
-            console.error('❌ 子弹预制体未设置');
             return;
         }        
         
         // 直接使用碰撞世界坐标作为发射点
         const weaponConfig: WeaponConfig | null = (blockNode as any)['weaponConfig'] || null;
         this.createAndFireBullet(fireWorldPos, weaponConfig);
-        console.log('🔫 === 方块武器发射子弹流程结束 ===');
     }
 } 

assets/scripts/CombatSystem/BlockManager.ts

@@ -170,10 +170,7 @@ export class BlockManager extends Component {
         
         // 如果没有指定placedBlocksContainer，尝试找到它
         if (!this.placedBlocksContainer) {
-            this.placedBlocksContainer = find('Canvas/GameLevelUI/PlacedBlocks');
-            if (!this.placedBlocksContainer) {
-                console.warn('找不到PlacedBlocks节点，将尝试创建');
-            }
+            this.placedBlocksContainer = find('Canvas/GameLevelUI/PlacedBlocks');   
         }
         
         // 确保有PlacedBlocks节点用于存放已放置的方块
@@ -213,7 +210,6 @@ export class BlockManager extends Component {
         // 尝试查找节点
         this.placedBlocksContainer = find('Canvas/GameLevelUI/PlacedBlocks');
         if (this.placedBlocksContainer) {
-            console.log('找到已存在的PlacedBlocks节点');
             return;
         }
         
@@ -366,11 +362,8 @@ export class BlockManager extends Component {
             this.setupBlockWeaponVisual(block, weaponConfig);
             
             this.setupDragEvents(block);
-            
-            console.log(`✅ 生成武器方块 ${i + 1}/3: ${weaponConfig.name} (${weaponConfig.rarity}) 在位置 (${offsets[i].x.toFixed(2)}, ${offsets[i].y.toFixed(2)})`);
         }
         
-        console.log(`🎉 成功在kuang容器中生成了 ${this.blocks.length} 个武器方块`);
         this.updateCoinDisplay();
     }
     
@@ -528,7 +521,6 @@ export class BlockManager extends Component {
             this.returnBlockToKuang(startLocation);
         } else if (this.tryPlaceBlockToGrid(this.currentDragBlock)) {
             this.handleSuccessfulPlacement(startLocation);
-            console.log('成功放置，移动到网格');
         } else {
             this.returnBlockToOriginalPosition();
         }
@@ -946,7 +938,6 @@ export class BlockManager extends Component {
     // 游戏开始时调用
     onGameStart() {
         this.gameStarted = true;
-        console.log('游戏已开始，已放置的方块将有移动冷却时间');
         
         for (const block of this.blocks) {
             if (block.isValid) {
@@ -971,7 +962,6 @@ export class BlockManager extends Component {
     onGameReset() {
         this.gameStarted = false;
         this.clearAllCooldowns();
-        console.log('游戏已重置，方块可以自由移动');
     }
     
     // 添加视觉提示，表明方块已锁定
@@ -1015,8 +1005,6 @@ export class BlockManager extends Component {
         
         // 重新设置触摸事件监听器
         this.setupDragEvents(block);
-        
-        console.log(`方块 ${block.name} 已移动到PlacedBlocks容器，并重新设置了触摸事件`);
     }
     
     // 根据武器配置选择合适的预制体
@@ -1141,7 +1129,6 @@ export class BlockManager extends Component {
         
         // 正确的SpriteFrame子资源路径
         const spriteFramePath = `${spritePath}/spriteFrame`;
-        console.log(`正在加载武器图片: ${spriteFramePath}`);
         
         // 加载SpriteFrame子资源
         resources.load(spriteFramePath, SpriteFrame, (err, spriteFrame) => {
@@ -1169,7 +1156,6 @@ export class BlockManager extends Component {
     
     // 刷新方块 - 重新生成三个新的武器方块
     public refreshBlocks() {
-        console.log('刷新方块，生成新的武器方块');
         this.generateRandomBlocksInKuang();
     }
 

assets/scripts/CombatSystem/BulletEffects/BulletHitEffect.ts

@@ -69,14 +69,13 @@ export class BulletHitEffect extends Component {
     public init(effects: HitEffectConfig[]) {
         // 按优先级排序
         this.hitEffects = [...effects].sort((a, b) => a.priority - b.priority);
-        console.log(`💥 命中效果初始化: ${this.hitEffects.length}个效果`);
     }
     
     /**
      * 处理命中事件
      */
     public processHit(hitNode: Node, contactPos: Vec3): HitResult {
-        console.log(`💥 处理命中: ${hitNode.name}`);
+        this.hitCount++;
         
         const result: HitResult = {
             shouldDestroy: false,
@@ -85,8 +84,6 @@ export class BulletHitEffect extends Component {
             damageDealt: 0
         };
         
-        this.hitCount++;
-        
         // 按优先级处理所有效果
         for (const effect of this.hitEffects) {
             const effectResult = this.processEffect(effect, hitNode, contactPos);
@@ -157,7 +154,6 @@ export class BulletHitEffect extends Component {
         const damage = params.damage || 0;
         this.damageEnemy(hitNode, damage);
         this.spawnHitEffect(hitNode.worldPosition);
-        console.log(`⚔️ 普通伤害: ${damage}`);
         return damage;
     }
     
@@ -169,8 +165,6 @@ export class BulletHitEffect extends Component {
         this.damageEnemy(hitNode, damage);
         this.spawnHitEffect(hitNode.worldPosition);
         this.pierceCount++;
-        
-        console.log(`🏹 穿透伤害: ${damage}, 穿透次数: ${this.pierceCount}/${params.pierceCount}`);
         return damage;
     }
     
@@ -178,8 +172,6 @@ export class BulletHitEffect extends Component {
      * 处理爆炸效果
      */
     private processExplosion(params: ExplosionParams, position: Vec3): number {
-        console.log(`💣 爆炸效果: 伤害${params.damage}, 半径${params.radius}`);
-        
         const scheduleExplosion = () => {
             // 生成爆炸特效
             this.spawnExplosionEffect(position);
@@ -201,8 +193,6 @@ export class BulletHitEffect extends Component {
      * 处理地面灼烧效果
      */
     private processGroundBurn(params: BurnParams, position: Vec3) {
-        console.log(`🔥 地面灼烧: 伤害${params.damage}, 持续${params.duration}秒`);
-        
         // 创建灼烧区域节点
         const burnArea = new Node('BurnArea');
         const gameArea = find('Canvas/GameLevelUI/GameArea');
@@ -253,8 +243,6 @@ export class BulletHitEffect extends Component {
             
             // 计算弹射方向
             this.calculateRicochetDirection(params.ricochetAngle);
-            
-            console.log(`🎾 弹射伤害: ${damage}, 弹射次数: ${this.ricochetCount}/${params.ricochetCount}`);
         }
         
         return damage;
@@ -284,8 +272,6 @@ export class BulletHitEffect extends Component {
         
         // 使用弹道组件的changeDirection方法
         trajectory.changeDirection(newDirection);
-        
-        console.log('🎾 弹射方向已计算并应用');
     }
     
     /**
@@ -294,8 +280,6 @@ export class BulletHitEffect extends Component {
     private damageEnemy(enemyNode: Node, damage: number) {
         if (!this.isEnemyNode(enemyNode)) return;
         
-        console.log(`⚔️ 对敌人 ${enemyNode.name} 造成 ${damage} 伤害`);
-        
         // 尝试调用敌人的受伤方法
         const enemyInstance = enemyNode.getComponent('EnemyInstance') as any;
         if (enemyInstance) {
@@ -339,7 +323,6 @@ export class BulletHitEffect extends Component {
             }
         }
         
-        console.log(`💥 范围伤害: 影响 ${enemies.length} 个敌人, 总伤害 ${totalDamage}`);
         return totalDamage;
     }
     

assets/scripts/CombatSystem/BulletEffects/BulletLifecycle.ts

@@ -55,8 +55,6 @@ export class BulletLifecycle extends Component {
         };
         
         this.lastPosition = this.node.worldPosition.clone();
-        
-        console.log(`⏱️ 生命周期初始化: ${config.type}, 最大时间: ${config.maxLifetime}秒`);
     }
     
     /**
@@ -96,7 +94,6 @@ export class BulletLifecycle extends Component {
      * 处理命中即销毁逻辑
      */
     private handleHitDestroy(): boolean {
-        console.log('💥 命中即销毁');
         this.state.shouldDestroy = true;
         return true;
     }
@@ -108,10 +105,8 @@ export class BulletLifecycle extends Component {
         // 穿透逻辑
         if (this.state.pierceLeft > 0) {
             this.state.pierceLeft--;
-            console.log(`🏹 穿透命中, 剩余穿透: ${this.state.pierceLeft}`);
             return false; // 不销毁，继续飞行
         } else {
-            console.log('🏹 穿透次数耗尽，销毁子弹');
             this.state.shouldDestroy = true;
             return true;
         }
@@ -123,7 +118,6 @@ export class BulletLifecycle extends Component {
     private handleRicochetCounter(): boolean {
         if (this.state.ricochetLeft > 0) {
             this.state.ricochetLeft--;
-            console.log(`🎾 弹射命中, 剩余弹射: ${this.state.ricochetLeft}`);
             
             // 触发弹射
             const trajectory = this.getComponent(BulletTrajectory);
@@ -133,7 +127,6 @@ export class BulletLifecycle extends Component {
             
             return false; // 不销毁，继续弹射
         } else {
-            console.log('🎾 弹射次数耗尽，销毁子弹');
             this.state.shouldDestroy = true;
             return true;
         }
@@ -146,27 +139,20 @@ export class BulletLifecycle extends Component {
         const isGround = this.isGroundNode(hitNode);
         
         if (isGround) {
-            console.log('🌍 撞击地面，触发效果');
+            // 进入效果阶段
+            this.state.phase = 'effect';
             
-            if (this.config.type === 'ground_impact_with_effect') {
-                // 进入效果阶段
-                this.state.phase = 'effect';
-                
-                // 延迟销毁，等待效果结束
-                if (this.config.effectDuration && this.config.effectDuration > 0) {
-                    this.scheduleOnce(() => {
-                        this.state.shouldDestroy = true;
-                    }, this.config.effectDuration);
-                } else {
+            // 延迟销毁，等待效果结束
+            if (this.config.effectDuration && this.config.effectDuration > 0) {
+                this.scheduleOnce(() => {
                     this.state.shouldDestroy = true;
-                }
+                }, this.config.effectDuration);
             } else {
                 this.state.shouldDestroy = true;
             }
             
             return true;
         } else {
-            console.log('💥 ground_impact 命中非地面，准备销毁');
             // 延迟销毁，确保爆炸的 0.1 s 延迟能正常触发
             this.scheduleOnce(() => {
                 this.state.shouldDestroy = true;
@@ -194,7 +180,6 @@ export class BulletLifecycle extends Component {
     private handleReturnTrip(): boolean {
         if (this.state.phase === 'active') {
             // 首次命中立即开始返程，不再依据pierceLeft
-            console.log('🪃 回旋镖命中敌人，开始返回');
             this.startReturn();
             return false; // 不销毁
         } else if (this.state.phase === 'returning') {
@@ -211,7 +196,6 @@ export class BulletLifecycle extends Component {
         const isEnemy = this.isEnemyNode(hitNode);
         
         if (isEnemy) {
-            console.log('🚀 导弹命中目标');
             this.state.shouldDestroy = true;
             return true;
         }
@@ -277,7 +261,6 @@ export class BulletLifecycle extends Component {
     private checkDestroyConditions() {
         // 检查时间限制
         if (this.state.elapsedTime >= this.config.maxLifetime) {
-            console.log('⏰ 子弹生存时间到期');
             this.state.shouldDestroy = true;
             return;
         }
@@ -285,13 +268,10 @@ export class BulletLifecycle extends Component {
         // === 射程限制逻辑优化 ===
         if (this.config.maxRange && this.state.travelDistance >= this.config.maxRange) {
             if (this.config.type === 'range_limit') {
-                // 仅当生命周期类型专门设为 range_limit 时才销毁
-                console.log(`📏 子弹超出射程限制: ${this.state.travelDistance}/${this.config.maxRange}`);
                 this.state.shouldDestroy = true;
             } else if (this.config.type === 'return_trip') {
                 // 回旋镖：首次超距时开始返回；返回途中不再因射程销毁
                 if (this.state.phase === 'active') {
-                    console.log(`📏 回旋镖到达最远距离(${this.config.maxRange})，开始返回`);
                     this.startReturn();
                 }
             }
@@ -302,10 +282,8 @@ export class BulletLifecycle extends Component {
         // 检查越界
         if (this.checkOutOfBounds()) {
             if (this.config.type === 'return_trip' && this.state.phase === 'active') {
-                console.log('🌍 回旋镖飞到屏幕边界，开始返回');
                 this.startReturn();
             } else {
-                console.log('🌍 子弹飞出游戏区域');
                 this.state.shouldDestroy = true;
             }
             return;
@@ -336,7 +314,6 @@ export class BulletLifecycle extends Component {
             // 检查是否返回到原点
             const distanceToOrigin = Vec3.distance(this.node.worldPosition, this.state.startPosition);
             if (distanceToOrigin <= 50) { // 50单位的容差
-                console.log('🪃 回旋镖返回原点');
                 this.state.shouldDestroy = true;
             }
         }
@@ -346,7 +323,6 @@ export class BulletLifecycle extends Component {
      * 开始返回
      */
     private startReturn() {
-        console.log('🪃 回旋镖开始返回');
         this.state.phase = 'returning';
         
         const trajectory = this.getComponent(BulletTrajectory);
@@ -398,7 +374,6 @@ export class BulletLifecycle extends Component {
      * 销毁子弹
      */
     private destroyBullet() {
-        console.log('💀 子弹生命周期结束，销毁');
         this.node.destroy();
     }
     

assets/scripts/CombatSystem/BulletEffects/BulletTrajectory.ts

@@ -47,7 +47,6 @@ export class BulletTrajectory extends Component {
         this.rigidBody = this.getComponent(RigidBody2D);
         
         if (!this.rigidBody && config.type !== 'arc') {
-            console.error('BulletTrajectory: 需要 RigidBody2D 组件 (除 arc 弹道外)');
             return;
         }
         
@@ -69,8 +68,6 @@ export class BulletTrajectory extends Component {
         if (config.type === 'homing') {
             this.findTarget();
         }
-        
-        console.log(`🎯 弹道初始化: ${config.type}, 速度: ${config.speed}`);
     }
     
     /**
@@ -193,7 +190,6 @@ export class BulletTrajectory extends Component {
         if (nearestEnemy) {
             this.targetNode = nearestEnemy;
             this.state.targetPosition = nearestEnemy.worldPosition.clone();
-            console.log(`🎯 弹道锁定目标: ${nearestEnemy.name}`);
         }
     }
     
@@ -386,7 +382,6 @@ export class BulletTrajectory extends Component {
         this.rigidBody.linearVelocity = new Vec2(-currentVel.x, -currentVel.y);
         this.state.currentVelocity.multiplyScalar(-1);
         this.state.phase = 'return';
-        console.log('🔄 弹道反转方向');
     }
     
     /**
@@ -407,8 +402,6 @@ export class BulletTrajectory extends Component {
         
         // 更新状态
         this.state.currentVelocity.set(normalizedDir.x * currentSpeed, normalizedDir.y * currentSpeed, 0);
-        
-        console.log('🎾 弹道方向已改变:', normalizedDir);
     }
     
     /**

assets/scripts/CombatSystem/EnemyController.ts

@@ -83,6 +83,29 @@ export class EnemyController extends BaseSingleton {
     // 配置管理器
     private configManager: ConfigManager = null;
 
+    @property({
+        type: Node,
+        tooltip: '敌人数量显示节点 (EnemyNumber)'
+    })
+    public enemyCountLabelNode: Node = null;
+
+    @property({
+        type: Node,
+        tooltip: '波数显示Label (WaveNumber)'
+    })
+    public waveNumberLabelNode: Node = null;
+
+    @property({
+        type: Node,
+        tooltip: '下一波提示UI节点 (NextWaveUI)'
+    })
+    public nextWaveUI: Node = null;
+
+    private totalWaves: number = 1;
+    private currentWave: number = 1;
+    private currentWaveTotalEnemies: number = 0;
+    private currentWaveEnemiesKilled: number = 0;
+
     /**
      * BaseSingleton 首次实例化回调
      */
@@ -112,6 +135,19 @@ export class EnemyController extends BaseSingleton {
         
         // 查找GameManager
         this.findGameManager();
+
+        // 如果没有指定enemyCountLabelNode，尝试找到它
+        if (!this.enemyCountLabelNode) {
+            this.enemyCountLabelNode = find('Canvas/GameLevelUI/EnemyNode/EnemyNumber');
+        }
+        if (!this.waveNumberLabelNode) {
+            this.waveNumberLabelNode = find('Canvas/GameLevelUI/WaveInfo/WaveNumber');
+        }
+        if (!this.nextWaveUI) {
+            this.nextWaveUI = find('Canvas/GameLevelUI/NextWaveUI');
+        }
+        // 初始化敌人数量显示
+        this.updateEnemyCountLabel();
     }
 
     // 计算游戏区域边界
@@ -301,6 +337,8 @@ export class EnemyController extends BaseSingleton {
         
         // 添加到活跃敌人列表
         this.activeEnemies.push(enemy);
+        // 更新敌人数量显示
+        this.updateEnemyCountLabel();
         
         console.log(`生成敌人，当前共有 ${this.activeEnemies.length} 个敌人`);
     }
@@ -313,6 +351,8 @@ export class EnemyController extends BaseSingleton {
             }
         }
         this.activeEnemies = [];
+        // 更新敌人数量显示
+        this.updateEnemyCountLabel();
     }
 
     // 获取所有活跃的敌人
@@ -364,8 +404,9 @@ export class EnemyController extends BaseSingleton {
             if (index !== -1) {
                 this.activeEnemies.splice(index, 1);
             }
-            
-            // 销毁敌人（在 onDestroy 中由 EnemyInstance -> notifyEnemyDead 计数）
+            // 更新敌人数量显示
+            this.updateEnemyCountLabel();
+            // 销毁敌人
             enemy.destroy();
         }
     }
@@ -462,6 +503,8 @@ export class EnemyController extends BaseSingleton {
         if (enemyNode) {
             const idx = this.activeEnemies.indexOf(enemyNode);
             if (idx !== -1) this.activeEnemies.splice(idx, 1);
+            this.currentWaveEnemiesKilled++;
+            this.updateEnemyCountLabel();
         }
         if (this.gameManager && this.gameManager.onEnemyKilled) {
             this.gameManager.onEnemyKilled();
@@ -505,4 +548,43 @@ export class EnemyController extends BaseSingleton {
             }
         });
     }
+
+    // 更新敌人数量显示
+    private updateEnemyCountLabel() {
+        if (!this.enemyCountLabelNode) return;
+        const label = this.enemyCountLabelNode.getComponent(Label);
+        if (label) {
+            const remaining = Math.max(0, this.currentWaveTotalEnemies - this.currentWaveEnemiesKilled);
+            label.string = remaining.toString();
+            console.log(`EnemyController 剩余敌人数量: ${remaining}`);
+        }
+    }
+
+    public startWave(waveNum: number, totalWaves: number, totalEnemies: number) {
+        this.currentWave = waveNum;
+        this.totalWaves = totalWaves;
+        this.currentWaveTotalEnemies = totalEnemies;
+        this.currentWaveEnemiesKilled = 0;
+        this.updateWaveLabel();
+        this.updateEnemyCountLabel();
+        if (this.nextWaveUI) this.nextWaveUI.active = false;
+    }
+
+    private updateWaveLabel() {
+        if (!this.waveNumberLabelNode) return;
+        const label = this.waveNumberLabelNode.getComponent(Label);
+        if (label) {
+            label.string = `${this.currentWave}/${this.totalWaves}`;
+        }
+    }
+
+    public showNextWavePromptUI(duration: number = 2) {
+        if (!this.nextWaveUI) return;
+        this.nextWaveUI.active = true;
+        if (duration > 0) {
+            this.scheduleOnce(() => {
+                if (this.nextWaveUI) this.nextWaveUI.active = false;
+            }, duration);
+        }
+    }
 } 

assets/scripts/CombatSystem/WeaponBullet.ts

@@ -3,6 +3,7 @@ import { BulletCount, BulletCountConfig, BulletSpawnInfo } from './BulletEffects
 import { BulletTrajectory, BulletTrajectoryConfig } from './BulletEffects/BulletTrajectory';
 import { BulletHitEffect, HitEffectConfig, HitResult } from './BulletEffects/BulletHitEffect';
 import { BulletLifecycle, BulletLifecycleConfig } from './BulletEffects/BulletLifecycle';
+import { ConfigManager } from '../Core/ConfigManager';
 
 const { ccclass, property } = _decorator;
 
@@ -80,13 +81,11 @@ export class WeaponBullet extends Component {
             
             resources.load('data/weapons', JsonAsset, (err, jsonAsset: JsonAsset) => {
                 if (err) {
-                    console.error('❌ 加载武器配置失败:', err);
                     reject(err);
                     return;
                 }
                 
                 WeaponBullet.weaponsData = jsonAsset.json;
-                console.log('✅ 武器配置加载成功');
                 resolve();
             });
         });
@@ -97,7 +96,6 @@ export class WeaponBullet extends Component {
      */
     public static getWeaponConfig(weaponId: string): WeaponConfig | null {
         if (!WeaponBullet.weaponsData) {
-            console.error('❌ 武器配置未加载');
             return null;
         }
         
@@ -105,7 +103,6 @@ export class WeaponBullet extends Component {
         const weapon = weapons.find((w: any) => w.id === weaponId);
         
         if (!weapon) {
-            console.error(`❌ 未找到武器配置: ${weaponId}`);
             return null;
         }
         
@@ -119,7 +116,6 @@ export class WeaponBullet extends Component {
         // 获取武器配置
         const config = initData.weaponConfig || WeaponBullet.getWeaponConfig(initData.weaponId);
         if (!config) {
-            console.error('❌ 无法获取武器配置');
             return [];
         }
         
@@ -196,8 +192,6 @@ export class WeaponBullet extends Component {
      * 初始化子弹
      */
     public init(initData: BulletInitData) {
-        console.log('🚀 WeaponBullet 初始化开始...');
-        
         // 获取武器配置
         this.weaponConfig = initData.weaponConfig || WeaponBullet.getWeaponConfig(initData.weaponId);
         if (!this.weaponConfig) {
@@ -205,8 +199,6 @@ export class WeaponBullet extends Component {
             return;
         }
         
-        console.log(`🔫 初始化武器: ${this.weaponConfig.name}`);
-        
         // 设置位置
         this.setPositionInGameArea(initData.firePosition);
         
@@ -226,7 +218,6 @@ export class WeaponBullet extends Component {
             if (gameAreaTransform) {
                 const localPos = gameAreaTransform.convertToNodeSpaceAR(worldPos);
                 this.node.position = localPos;
-                console.log('✅ 子弹位置已设置:', localPos);
             }
         }
     }
@@ -282,13 +273,10 @@ export class WeaponBullet extends Component {
         this.bulletLifecycle = this.getComponent(BulletLifecycle) || this.addComponent(BulletLifecycle);
         this.bulletLifecycle.init(config.lifecycle, initData.firePosition);
         
-        console.log('生命周期穿透值 =', config.lifecycle.penetration);
-        
         // 设置碰撞监听
         this.setupCollisionListener();
         
         this.isInitialized = true;
-        console.log('✅ WeaponBullet 初始化完成');
     }
     
     /**
@@ -309,8 +297,6 @@ export class WeaponBullet extends Component {
             collider.sensor = false;
             collider.on(Contact2DType.BEGIN_CONTACT, this.onHit, this);
         }
-        
-        console.log('✅ 物理组件设置完成');
     }
     
     /**
@@ -329,7 +315,6 @@ export class WeaponBullet extends Component {
             const direction = nearestEnemy.worldPosition.clone()
                 .subtract(this.node.worldPosition)
                 .normalize();
-            console.log('🎯 自动瞄准最近敌人');
             return direction;
         }
         
@@ -356,7 +341,6 @@ export class WeaponBullet extends Component {
         if (otherNode.getComponent(WeaponBullet)) {
             return; // Skip further processing if the collider is another bullet
         }
-        console.log(`💥 子弹碰撞: ${otherNode.name}`);
         
         // 获取碰撞世界坐标
         let contactWorldPos: Vec3 = null;
@@ -380,9 +364,9 @@ export class WeaponBullet extends Component {
         // 不直接销毁，交由 BulletLifecycle 自行处理
         // 生命周期和命中效果自行决定是否销毁；此处不再直接销毁，由 BulletLifecycle.update() 完成
         if (hitResult.shouldRicochet) {
-            console.log('🎾 子弹发生弹射');
+            // 这里需要实现子弹弹射的逻辑
         } else if (hitResult.shouldContinue) {
-            console.log('🏹 子弹继续飞行');
+            // 这里需要实现子弹继续飞行的逻辑
         }
     }
     
@@ -443,8 +427,6 @@ export class WeaponBullet extends Component {
     }
     
     onDestroy() {
-        console.log('💀 WeaponBullet 被销毁');
-        
         // 清理事件监听
         const collider = this.getComponent(Collider2D);
         if (collider) {
@@ -478,7 +460,6 @@ export class WeaponBullet extends Component {
         const framePath = `${spritePath}/spriteFrame`;
         resources.load(framePath, SpriteFrame, (err, spriteFrame) => {
             if (err) {
-                console.warn(`加载子弹SpriteFrame失败: ${framePath}`, err);
                 return;
             }
 

assets/scripts/LevelSystem/GameManager.ts

@@ -7,6 +7,8 @@ import { ConfigManager } from '../Core/ConfigManager';
 import { EnemyController } from '../CombatSystem/EnemyController';
 import EventBus, { GameEvents } from '../Core/EventBus';
 import { PhysicsManager } from '../Core/PhysicsManager';
+import { MainUIController } from './MainUIController';
+import { BallController } from '../CombatSystem/BallController';
 const { ccclass, property } = _decorator;
 
 /**
@@ -70,18 +72,6 @@ export class GameManager extends Component {
     })
     public gameDefeatUI: Node = null;
 
-    @property({
-        type: Node,
-        tooltip: '波次显示节点 (WaveNumber)'
-    })
-    public waveNumberNode: Node = null;
-
-    @property({
-        type: Node,
-        tooltip: '敌人数量显示节点 (EnemyNumber)'
-    })
-    public enemyNumberNode: Node = null;
-
     // === 游戏配置属性 ===
     @property({
         tooltip: '墙体初始血量'
@@ -104,8 +94,6 @@ export class GameManager extends Component {
     private currentState: GameState = GameState.PLAYING;
     private checkTimer: number = 0;
     private heartLabel: Label = null;
-    private waveNumberLabel: Label = null;
-    private enemyNumberLabel: Label = null;
     private enemyController: EnemyController = null;
     private levelManager: LevelManager = null;
     private levelConfigManager: LevelConfigManager = null;
@@ -220,9 +208,7 @@ export class GameManager extends Component {
         this.currentWaveEnemyCount = 0;
         this.currentWaveTotalEnemies = 0; // 当前波次总敌人数
         
-        // 初始化UI显示
-        this.updateWaveDisplay();
-        this.updateEnemyCountDisplay();
+        // UI 初始化移交给 EnemyController
     }
 
     // === 计算游戏区域边界 ===
@@ -258,24 +244,6 @@ export class GameManager extends Component {
             this.heartLabel = this.heartLabelNode.getComponent(Label);
         }
         
-        // 查找波次显示节点
-        if (!this.waveNumberNode) {
-            this.waveNumberNode = find('Canvas/GameLevelUI/WaveInfo/WaveNumber');
-        }
-        
-        if (this.waveNumberNode) {
-            this.waveNumberLabel = this.waveNumberNode.getComponent(Label);
-        }
-        
-        // 查找敌人数量显示节点
-        if (!this.enemyNumberNode) {
-            this.enemyNumberNode = find('Canvas/GameLevelUI/EnemyNode/EnemyNumber');
-        }
-        
-        if (this.enemyNumberNode) {
-            this.enemyNumberLabel = this.enemyNumberNode.getComponent(Label);
-        }
-        
         // 查找游戏成功UI
         if (!this.gameSuccessUI) {
             this.gameSuccessUI = find('Canvas/GameSuccess');
@@ -367,13 +335,6 @@ export class GameManager extends Component {
             return;
         }
 
-        // 更新当前敌人数量（用于波次UI显示等，不影响胜利逻辑）
-        if (this.enemyController) {
-            const currentEnemyCount = this.enemyController.getCurrentEnemyCount ? 
-                this.enemyController.getCurrentEnemyCount() : 0;
-            this.updateCurrentWaveEnemyCount(currentEnemyCount);
-        }
-
         // 检查是否全部击败
         if (this.checkAllEnemiesDefeated()) {
             this.triggerGameSuccess();
@@ -502,7 +463,6 @@ export class GameManager extends Component {
 
     // === 游戏失败回调 ===
     private onGameDefeat() {
-        console.log('处理游戏失败逻辑');
         this.gameEndTime = Date.now();
         
         // 记录游戏失败到存档
@@ -517,7 +477,6 @@ export class GameManager extends Component {
 
     // === 游戏成功回调 ===
     private onGameSuccess() {
-        console.log('处理游戏成功逻辑');
         this.gameEndTime = Date.now();
         
         this.giveReward();
@@ -542,8 +501,6 @@ export class GameManager extends Component {
             const firstClearBonus = currentLevel * 25;
             this.saveDataManager.addCoins(firstClearBonus, `level_${currentLevel}_first_clear`);
         }
-        
-        console.log(`🎉 关卡奖励：金币 +${totalCoins}，健康奖励 +${healthBonus}，时间奖励 +${timeBonus}`);
     }
 
     // === 处理关卡完成 ===
@@ -568,8 +525,6 @@ export class GameManager extends Component {
         this.saveDataManager.updateStatistic('totalTimePlayed', gameTime);
         this.saveDataManager.updateStatistic('totalEnemiesDefeated', this.totalEnemiesSpawned);
         
-        console.log(`🏆 关卡 ${currentLevel} 完成！得分: ${finalScore}, 星级: ${finalStars}, 用时: ${gameTime}秒`);
-        
         // 兼容原有的LevelManager
         if (this.levelManager) {
             this.levelManager.completeLevel(currentLevel, finalScore, finalStars);
@@ -707,94 +662,57 @@ export class GameManager extends Component {
 
     // === 按钮点击事件处理 ===
     private async onNextLevelClick() {
-        if (!this.saveDataManager) {
-            console.warn('SaveDataManager 未初始化');
-            return;
-        }
-
+        if (!this.saveDataManager) return;
+        
         const currentLevel = this.saveDataManager.getCurrentLevel();
         const nextLevel = currentLevel + 1;
-
-        if (!this.saveDataManager.isLevelUnlocked(nextLevel)) {
-            console.log('下一关卡尚未解锁');
-            return;
-        }
-
-        // 设置当前关卡为下一关
-        this.saveDataManager.getPlayerData().currentLevel = nextLevel;
-        this.saveDataManager.savePlayerData();
-
-        // 隐藏结算面板
-        if (this.gameSuccessUI) this.gameSuccessUI.active = false;
-        if (this.gameDefeatUI) this.gameDefeatUI.active = false;
-
-        // 停止并清理敌人
-        if (this.enemyController) {
-            this.enemyController.stopGame();
-            this.enemyController.clearAllEnemies();
-        }
-
-        // 重置方块、子弹等（通过 BlockManager）
-        const blockManager = find('Canvas/GameLevelUI')?.getComponent('BlockManager');
-        if (blockManager) {
-            if (blockManager['clearBlocks']) blockManager['clearBlocks']();
-            if (blockManager['onGameReset']) blockManager['onGameReset']();
+        
+        // 检查下一关是否已解锁
+        if (this.saveDataManager.isLevelUnlocked(nextLevel)) {
+            // 设置下一关为当前关
+            const playerData = this.saveDataManager.getPlayerData();
+            if (playerData) {
+                playerData.currentLevel = nextLevel;
+                this.saveDataManager.savePlayerData();
+                
+                // 重新开始游戏
+                this.restartGame();
+                await this.loadCurrentLevelConfig();
+            }
         }
-
-        // 重置内部状态
-        this.restartGame();
-
-        // 加载并应用新关卡配置
-        await this.loadCurrentLevelConfig();
-
-        // 直接开始游戏（如果需要再次确认，可移除此行）
-        this.startGame();
     }
-
+    
     private onRestartClick() {
-        this.restartCurrentLevel();
+        this.restartGame();
     }
-
+    
     private onMainMenuClick() {
-        // 保存数据
-        if (this.saveDataManager) {
-            this.saveDataManager.savePlayerData(true);
-        }
-
-        // 隐藏结算面板
-        if (this.gameSuccessUI) this.gameSuccessUI.active = false;
-        if (this.gameDefeatUI) this.gameDefeatUI.active = false;
-
-        // 停止并清理游戏内容
-        if (this.enemyController) {
-            this.enemyController.stopGame();
-            this.enemyController.clearAllEnemies();
-        }
-        this.restartGame();
-
-        // UI 切换：隐藏关卡界面，显示主界面
-        const mainUI = find('Canvas/MainUI');
+        // 隐藏游戏界面，显示主界面
         const gameLevelUI = find('Canvas/GameLevelUI');
-        if (mainUI) mainUI.active = true;
+        const mainUI = find('Canvas/MainUI');
         if (gameLevelUI) gameLevelUI.active = false;
-
-        console.log('返回主界面');
+        if (mainUI) mainUI.active = true;
+        
+        // 更新主界面
+        const mainUIController = mainUI?.getComponent(MainUIController);
+        if (mainUIController) {
+            mainUIController.updateUI();
+        }
     }
-
+    
     private onShopClick() {
-        console.log('打开商店');
+        // 打开商店界面
+        const gameLevelUI = find('Canvas/GameLevelUI');
+        const shopUI = find('Canvas/ShopUI');
+        if (gameLevelUI) gameLevelUI.active = false;
+        if (shopUI) shopUI.active = true;
     }
-
+    
     private onReviveClick() {
-        // 消费钻石复活
-        if (this.saveDataManager) {
-            const reviveCost = 10; // 复活需要10钻石
-            if (this.saveDataManager.spendDiamonds(reviveCost)) {
-                this.revivePlayer();
-                console.log(`💎 消费 ${reviveCost} 钻石复活`);
-            } else {
-                console.log('钻石不足，无法复活');
-            }
+        const reviveCost = 10; // 复活消耗的钻石数量
+        
+        if (this.saveDataManager && this.saveDataManager.spendDiamonds(reviveCost)) {
+            this.revivePlayer();
         }
     }
 
@@ -838,46 +756,32 @@ export class GameManager extends Component {
     }
 
     public startGame() {
+        if (this.gameStarted) return;
+        
         this.gameStarted = true;
         this.gameStartTime = Date.now();
-        this.gameEndTime = 0;
         this.currentState = GameState.PLAYING;
         
-        // 通知BlockManager游戏开始
-        const blockManager = find('Canvas/GameLevelUI')?.getComponent('BlockManager');
-        if (blockManager && blockManager['onGameStart']) {
-            blockManager['onGameStart']();
-        }
-        
+        // 开始敌人生成
         this.spawnBall();
         
-        console.log('🎮 游戏开始！');
-
-        if (this.enemyController) {
-            this.enemyController.startGame();
-        }
+        // 启动状态检查
+        this.checkTimer = 0;
+        
+        // 设置UI按钮事件
+        this.setupUIButtons();
+        
+        // 开始生成敌人
+        this.forceStartEnemySpawning();
     }
-
+    
     private spawnBall() {
-        console.log('🎯 === GameManager: 启动小球 ===');
+        if (!this.ballController) return;
         
-        if (!this.ballController) {
-            console.error('❌ BallController 节点未设置');
-            return;
+        const ballControllerComponent = this.ballController.getComponent(BallController);
+        if (ballControllerComponent) {
+            ballControllerComponent.startBall();
         }
-
-        // 获取BallController组件
-        const ballControllerComp = this.ballController.getComponent('BallController') as any;
-        if (ballControllerComp) {
-            console.log('✅ 找到BallController组件，启动小球...');
-            // 调用startBall方法而不是initialize，确保小球在确定按钮点击后才开始运动
-            ballControllerComp.startBall();
-            console.log('🚀 小球启动完成');
-        } else {
-            console.error('❌ 找不到BallController组件');
-        }
-        
-        console.log('🎯 === GameManager: 小球启动流程完成 ===');
     }
 
     public gameOver() {
@@ -938,86 +842,56 @@ export class GameManager extends Component {
 
     // === 调试方法 ===
     public getEnemyStatus() {
-        if (!this.enemyController) {
-            return;
-        }
-
-        const currentCount = this.enemyController.getCurrentEnemyCount ? 
-            this.enemyController.getCurrentEnemyCount() : 0;
+        if (!this.enemyController) return;
+        
+        const currentCount = this.enemyController.getCurrentEnemyCount();
         const gameStarted = this.enemyController.isGameStarted();
-
-        console.log('=== 敌人状态调试信息 ===');
-        console.log(`敌人生成已开始: ${this.enemySpawningStarted}`);
-        console.log(`当前敌人数量: ${currentCount}`);
-        console.log(`曾生成最大敌人数: ${this.totalEnemiesSpawned}`);
-        console.log(`EnemyController游戏已开始: ${gameStarted}`);
-        console.log(`GameManager游戏状态: ${this.currentState}`);
-        console.log(`GameManager游戏已开始: ${this.gameStarted}`);
-        console.log(`当前血量: ${this.currentHealth}`);
         
-        // 显示活跃敌人的详细信息
-        if (this.enemyController.getActiveEnemies) {
-            const activeEnemies = this.enemyController.getActiveEnemies();
-            console.log(`活跃敌人列表 (${activeEnemies.length}个):`);
-            activeEnemies.forEach((enemy, index) => {
-                if (enemy && enemy.isValid) {
-                    console.log(`  ${index + 1}. ${enemy.name} - 位置: (${enemy.position.x.toFixed(1)}, ${enemy.position.y.toFixed(1)})`);
+        const activeEnemies = this.enemyController.getActiveEnemies?.() || [];
+        
+        if (activeEnemies.length > 0) {
+            for (let index = 0; index < activeEnemies.length; index++) {
+                const enemy = activeEnemies[index];
+                if (enemy?.isValid) {
+                    // 查看敌人状态
                 } else {
-                    console.log(`  ${index + 1}. 无效敌人节点`);
+                    // 无效敌人节点
                 }
-            });
+            }
         }
     }
-
+    
     public forceStartEnemySpawning() {
-        this.enemySpawningStarted = true;
+        if (this.enemyController) {
+            this.enemyController.startGame();
+        }
     }
-
+    
     public setTotalEnemiesSpawned(count: number) {
         this.totalEnemiesSpawned = count;
     }
-
-    // === 测试方法 ===
+    
     public testEnemyDetection() {
-        const result = this.checkAllEnemiesDefeated();
+        // 测试敌人检测功能
         this.getEnemyStatus();
-        return result;
     }
-
-    // 测试组件获取是否正常
+    
     public testComponentAccess() {
-        console.log('=== 测试组件访问 ===');
-        
+        // 测试组件访问
         if (this.enemyController) {
-            console.log('✅ EnemyController 访问正常');
-            console.log(`当前敌人数量: ${this.enemyController.getCurrentEnemyCount()}`);
-            console.log(`游戏是否开始: ${this.enemyController.isGameStarted()}`);
-        } else {
-            console.log('❌ EnemyController 未找到');
+            // 组件访问正常
         }
-        
-        console.log('组件测试完成');
     }
-
-    // === 测试敌人攻击 ===
+    
     public testEnemyAttackWall() {
-        console.log('=== GameManager: 测试敌人攻击墙体 ===');
+        if (!this.enemyController) return;
         
-        if (this.enemyController) {
-            console.log(`攻击前墙体血量: ${this.enemyController.getCurrentWallHealth()}`);
-            
-            // 测试EnemyController的攻击功能
-            const newHealth = this.enemyController.testEnemyAttack();
-            console.log(`攻击后墙体血量: ${newHealth}`);
-            
-            // 强制所有敌人攻击
-            this.enemyController.forceEnemyAttack();
-            
-            return newHealth;
-        } else {
-            console.error('EnemyController未找到');
-            return -1;
-        }
+        const currentHealth = this.enemyController.getCurrentWallHealth();
+        const testDamage = 50;
+        
+        this.enemyController.damageWall(testDamage);
+        
+        const newHealth = this.enemyController.getCurrentWallHealth();
     }
 
     onDestroy() {
@@ -1039,78 +913,49 @@ export class GameManager extends Component {
 
     // === 加载当前关卡配置 ===
     public async loadCurrentLevelConfig() {
-        if (!this.levelConfigManager) {
-            return null;
-        }
-
+        if (!this.saveDataManager || !this.levelConfigManager) return;
+        
+        const currentLevel = this.saveDataManager.getCurrentLevel();
+        
         try {
-            // 优先使用存档系统的关卡信息
-            const currentLevel = this.saveDataManager ? 
-                this.saveDataManager.getCurrentLevel() : 
-                (this.levelManager ? this.levelManager.getCurrentLevel() : 1);
-                
-            console.log(`加载关卡 ${currentLevel} 配置`);
-            
             const levelConfig = await this.levelConfigManager.getLevelConfig(currentLevel);
-            
             if (levelConfig) {
-                console.log(`关卡 ${currentLevel} 配置加载成功:`, levelConfig);
                 this.applyLevelConfig(levelConfig);
-                return levelConfig;
             } else {
-                console.warn(`关卡 ${currentLevel} 的配置文件不存在`);
-                return null;
+                console.warn(`关卡 ${currentLevel} 配置加载失败`);
             }
         } catch (error) {
-            console.error('加载关卡配置失败:', error);
-            return null;
+            console.error(`关卡 ${currentLevel} 配置加载错误:`, error);
         }
     }
-
-    // === 应用关卡配置 ===
+    
     private applyLevelConfig(levelConfig: any) {
-        if (!levelConfig) return;
-
-        // 应用关卡设置
-        if (levelConfig.settings) {
-            const settings = levelConfig.settings;
+        // 应用关卡配置
+        
+        // 如果有武器配置，应用武器
+        if (levelConfig.weapons && Array.isArray(levelConfig.weapons)) {
+            // 应用武器配置
+        }
+        
+        // 如果有波次配置，设置敌人波次
+        if (levelConfig.waves && Array.isArray(levelConfig.waves)) {
+            this.levelWaves = levelConfig.waves;
+            this.currentWave = 1;
             
-            if (settings.initialHealth !== undefined) {
-                this.wallHealth = settings.initialHealth;
-                this.initialHealth = settings.initialHealth;
-                this.currentHealth = settings.initialHealth;
+            // 计算本关卡总敌人数
+            this.levelTotalEnemies = 0;
+            for (const wave of this.levelWaves) {
+                for (const enemy of wave.enemies || []) {
+                    this.levelTotalEnemies += enemy.count || 0;
+                }
             }
             
-            if (settings.checkInterval !== undefined) {
-                this.checkInterval = settings.checkInterval;
-            }
-        }
-
-        // 记录武器配置信息
-        if (levelConfig.weapons) {
-            console.log('关卡武器配置:', levelConfig.weapons);
-        }
-
-        // 记录敌人波次配置信息并初始化第一波
-        if (levelConfig.waves && levelConfig.waves.length > 0) {
-            this.levelWaves = levelConfig.waves;
-            console.log('关卡敌人波次配置:', this.levelWaves);
-
-            // 计算整关卡总敌人数
-            this.levelTotalEnemies = this.levelWaves.reduce((levelTotal: number, wave: any) => {
-                if (!wave || !wave.enemies) return levelTotal;
-                const waveTotal = wave.enemies.reduce((t: number, g: any) => t + (g.count || 0), 0);
-                return levelTotal + waveTotal;
-            }, 0);
-            console.log(`📊 本关卡共有敌人: ${this.levelTotalEnemies}`);
-
-            // 初始化第一波
-            const firstWave = this.levelWaves[0];
-            if (firstWave && firstWave.enemies) {
-                const totalEnemiesInFirstWave = firstWave.enemies.reduce((total: number, enemyGroup: any) => {
-                    return total + (enemyGroup.count || 0);
-                }, 0);
-                this.setCurrentWave(1, totalEnemiesInFirstWave);
+            // 通知 EnemyController 初始化第一波数据及 UI
+            if (this.enemyController) {
+                const totalWaves = this.levelWaves.length;
+                const firstWaveEnemies = this.levelWaves.length > 0 && this.levelWaves[0].enemies ?
+                    this.levelWaves[0].enemies.reduce((t: number, g: any) => t + (g.count || 0), 0) : 0;
+                this.enemyController.startWave(1, totalWaves, firstWaveEnemies);
             }
         }
     }
@@ -1148,34 +993,28 @@ export class GameManager extends Component {
 
     // === 更新波次显示 ===
     private updateWaveDisplay() {
-        if (this.waveNumberLabel) {
-            this.waveNumberLabel.string = this.currentWave.toString();
-        }
+        // UI 更新交由 EnemyController 处理
     }
 
     // === 更新敌人数量显示 ===
     private updateEnemyCountDisplay() {
-        if (this.enemyNumberLabel) {
-            this.enemyNumberLabel.string = this.currentWaveTotalEnemies.toString();
-        }
+        // UI 更新交由 EnemyController 处理
     }
 
     // === 设置当前波次 ===
     public setCurrentWave(wave: number, enemyCount: number = 0) {
         this.currentWave = wave;
-        this.currentWaveEnemyCount = 0; // 重置当前敌人数量为0
+        this.currentWaveEnemyCount = 0; // 重置当前击杀数
         this.currentWaveTotalEnemies = enemyCount; // 设置该波次总敌人数
-        this.updateWaveDisplay();
-        this.updateEnemyCountDisplay();
+        if (this.enemyController) {
+            const totalWaves = this.levelWaves?.length || 1;
+            this.enemyController.startWave(wave, totalWaves, enemyCount);
+        }
     }
 
     // === 更新当前波次敌人数量 ===
     public updateCurrentWaveEnemyCount(count: number) {
         this.currentWaveEnemyCount = count;
-        // 不应该修改总敌人数，总敌人数只在设置波次时确定
-        // this.currentWaveTotalEnemies = count; // 移除这行
-        // 敌人数量显示的是总数，不需要在这里更新
-        // this.updateEnemyCountDisplay(); // 移除这行
     }
 
     // === 获取当前波次 ===
@@ -1209,15 +1048,33 @@ export class GameManager extends Component {
         this.setCurrentWave(this.currentWave, enemyTotal);
     }
 
+    /** 显示下一波提示并在短暂延迟后开始下一波 */
+    private showNextWavePrompt() {
+        if (this.enemyController) {
+            this.enemyController.showNextWavePromptUI();
+        }
+        // 2 秒后开始下一波
+        this.scheduleOnce(() => {
+            this.nextWave();
+        }, 2);
+    }
+
     /** 敌人被消灭时由 EnemyController 调用 */
     public onEnemyKilled() {
         this.enemiesKilled++;
-        const remaining = Math.max(0, this.levelTotalEnemies - this.enemiesKilled);
-        console.log(`⚔️ 已击杀: ${this.enemiesKilled}, 剩余敌人数量: ${remaining}`);
-
-        // 如果需要在 UI 上实时显示剩余敌人数量，可在此赋值
-        if (this.enemyNumberLabel) {
-            this.enemyNumberLabel.string = remaining.toString();
+        // 当前波击杀 +1
+        this.currentWaveEnemyCount++;
+        
+        const remaining = this.currentWaveTotalEnemies - this.currentWaveEnemyCount;
+        if (remaining <= 0) {
+            // 当前波结束
+            if (this.currentWave < (this.levelWaves?.length || 1)) {
+                // 还有下一波，显示提示
+                this.showNextWavePrompt();
+            } else {
+                // 最后一波也结束
+                this.triggerGameSuccess();
+            }
         }
     }
 } 

assets/scripts/LevelSystem/LevelConfigManager.ts

@@ -107,10 +107,6 @@ export class LevelConfigManager extends Component {
      * 验证关卡配置的完整性
      */
     private validateConfigs() {
-        console.log(`=== 验证关卡配置 ===`);
-        console.log(`总关卡数: ${this.totalLevels}`);
-        console.log(`已配置关卡数: ${this.levelConfigs.length}`);
-
         // 检查是否所有关卡都有配置
         for (let i = 1; i <= this.totalLevels; i++) {
             const config = this.levelConfigs.find(c => c.levelId === i);
@@ -118,8 +114,6 @@ export class LevelConfigManager extends Component {
                 console.warn(`关卡 ${i} 缺少配置`);
             } else if (!config.configFile) {
                 console.warn(`关卡 ${i} 缺少JSON文件`);
-            } else {
-                console.log(`✅ 关卡 ${i}: ${config.levelName} - ${config.configFile.name}`);
             }
         }
 
@@ -160,7 +154,6 @@ export class LevelConfigManager extends Component {
             if (levelConfig) {
                 // 缓存配置
                 this.loadedConfigs.set(levelId, levelConfig);
-                console.log(`✅ 关卡 ${levelId} 配置加载成功`);
                 return levelConfig;
             }
 
@@ -217,7 +210,6 @@ export class LevelConfigManager extends Component {
                 }
             }
 
-            console.log(`关卡 ${levelId} 数据验证通过: ${levelConfig.waves.length} 个波次`);
             return levelConfig;
 
         } catch (error) {
@@ -265,7 +257,6 @@ export class LevelConfigManager extends Component {
     public reloadAllConfigs() {
         this.loadedConfigs.clear();
         this.validateConfigs();
-        console.log('所有关卡配置已重新加载');
     }
 
     /**
@@ -333,7 +324,5 @@ export class LevelConfigManager extends Component {
             console.log(`关卡 ${config.levelId}: ${config.levelName}`);
             console.log(`  JSON文件: ${config.configFile ? config.configFile.name : '未设置'}`);
         }
-        
-        console.log(`已缓存配置数: ${this.loadedConfigs.size}`);
     }
 } 

assets/scripts/LevelSystem/MainUIController.ts

@@ -73,9 +73,6 @@ export class MainUIController extends Component {
         
         // 设置按钮事件
         this.setupButtons();
-        
-        console.log('🏠 主界面初始化完成');
-        console.log('存档摘要:', this.saveDataManager.getSaveSummary());
     }
     
     /**
@@ -222,7 +219,6 @@ export class MainUIController extends Component {
      * 战斗按钮点击事件
      */
     private onBattleButtonClick() {
-        console.log('🎮 进入战斗！');
         // 保存数据
         if (this.saveDataManager) {
             this.saveDataManager.savePlayerData();
@@ -249,7 +245,6 @@ export class MainUIController extends Component {
      * 商店按钮点击事件
      */
     private onShopButtonClick() {
-        console.log('🛒 打开商店');
         // UI 切换：隐藏主界面，显示商城界面（如果存在）
         const mainUI = find('Canvas/MainUI');
         const shopUI = find('Canvas/ShopUI');
@@ -265,8 +260,9 @@ export class MainUIController extends Component {
      * 设置按钮点击事件
      */
     private onSettingsButtonClick() {
-        console.log('⚙️ 打开设置');
         // 这里可以打开设置界面
+        // 暂时只显示调试信息
+        this.showCurrentLevelInfo();
     }
     
     /**
@@ -276,20 +272,13 @@ export class MainUIController extends Component {
         if (!this.saveDataManager) return;
         
         const currentLevel = this.saveDataManager.getCurrentLevel();
-        const progress = this.saveDataManager.getLevelProgress(currentLevel);
         const isCompleted = this.saveDataManager.isLevelCompleted(currentLevel);
-        const isUnlocked = this.saveDataManager.isLevelUnlocked(currentLevel);
-        
-        console.log('=== 当前关卡信息 ===');
-        console.log(`关卡: ${currentLevel}`);
-        console.log(`已解锁: ${isUnlocked}`);
-        console.log(`已完成: ${isCompleted}`);
         
-        if (progress) {
-            console.log(`最佳得分: ${progress.bestScore}`);
-            console.log(`最佳时间: ${progress.bestTime}秒`);
-            console.log(`星级: ${progress.stars}`);
-            console.log(`尝试次数: ${progress.attempts}`);
+        if (isCompleted) {
+            const progress = this.saveDataManager.getLevelProgress(currentLevel);
+            if (progress) {
+                // 显示关卡完成信息
+            }
         }
     }
     
@@ -330,12 +319,12 @@ export class MainUIController extends Component {
      */
     public unlockLevel(level: number) {
         if (this.saveDataManager) {
+            // 直接设置玩家数据中的最大解锁关卡
             const playerData = this.saveDataManager.getPlayerData();
             if (level > playerData.maxUnlockedLevel) {
                 playerData.maxUnlockedLevel = level;
                 this.saveDataManager.savePlayerData();
                 this.updateUI();
-                console.log(`🔓 解锁关卡 ${level}`);
             }
         }
     }
@@ -347,7 +336,6 @@ export class MainUIController extends Component {
         if (this.saveDataManager) {
             this.saveDataManager.resetAllData();
             this.updateUI();
-            console.log('🔄 存档已重置');
         }
     }
     

assets/scripts/LevelSystem/SaveDataManager.ts

@@ -168,12 +168,6 @@ export class SaveDataManager {
         
         this.loadPlayerData();
         this.initialized = true;
-        
-        console.log('✅ 存档管理器初始化完成');
-        console.log(`玩家等级: ${this.playerData.playerLevel}`);
-        console.log(`当前关卡: ${this.playerData.currentLevel}`);
-        console.log(`金币: ${this.playerData.coins}`);
-        console.log(`钻石: ${this.playerData.diamonds}`);
     }
     
     /**
@@ -187,10 +181,8 @@ export class SaveDataManager {
                 const data = JSON.parse(savedData);
                 this.playerData = this.validateAndMigrateData(data);
                 this.playerData.lastPlayTime = Date.now();
-                console.log('✅ 存档数据加载成功');
             } else {
                 this.createNewPlayerData();
-                console.log('🆕 创建新的玩家存档');
             }
         } catch (error) {
             console.error('❌ 存档数据加载失败，尝试加载备份:', error);
@@ -209,10 +201,8 @@ export class SaveDataManager {
                 const data = JSON.parse(backupData);
                 this.playerData = this.validateAndMigrateData(data);
                 this.playerData.lastPlayTime = Date.now();
-                console.log('✅ 备份数据加载成功');
             } else {
                 this.createNewPlayerData();
-                console.log('🆕 备份数据不存在，创建新存档');
             }
         } catch (error) {
             console.error('❌ 备份数据加载失败，创建新存档:', error);
@@ -383,7 +373,6 @@ export class SaveDataManager {
             sys.localStorage.setItem(this.SAVE_KEY, dataToSave);
             
             this.lastSaveTime = currentTime;
-            console.log('💾 玩家数据保存成功');
         } catch (error) {
             console.error('❌ 玩家数据保存失败:', error);
         }
@@ -503,8 +492,6 @@ export class SaveDataManager {
         this.giveCompletionRewards(levelId, stars);
         
         this.savePlayerData();
-        
-        console.log(`🎉 关卡 ${levelId} 完成！得分: ${score}, 星级: ${stars}`);
     }
     
     /**
@@ -538,8 +525,6 @@ export class SaveDataManager {
         this.playerData.statistics.consecutiveWins = 0;
         
         this.savePlayerData();
-        
-        console.log(`💔 关卡 ${levelId} 失败`);
     }
     
     /**
@@ -575,7 +560,6 @@ export class SaveDataManager {
         this.playerData.coins += amount;
         this.addReward('coins', '', amount, source);
         
-        console.log(`💰 获得金币 +${amount} (来源: ${source})`);
         return true;
     }
     
@@ -588,7 +572,6 @@ export class SaveDataManager {
         }
         
         this.playerData.coins -= amount;
-        console.log(`💸 消费金币 -${amount}`);
         return true;
     }
     
@@ -601,7 +584,6 @@ export class SaveDataManager {
         this.playerData.diamonds += amount;
         this.addReward('diamonds', '', amount, source);
         
-        console.log(`💎 获得钻石 +${amount} (来源: ${source})`);
         return true;
     }
     
@@ -614,7 +596,6 @@ export class SaveDataManager {
         }
         
         this.playerData.diamonds -= amount;
-        console.log(`💸 消费钻石 -${amount}`);
         return true;
     }
     
@@ -627,7 +608,6 @@ export class SaveDataManager {
         this.playerData.gems += amount;
         this.addReward('gems', '', amount, source);
         
-        console.log(`💜 获得宝石 +${amount} (来源: ${source})`);
         return true;
     }
     
@@ -646,7 +626,6 @@ export class SaveDataManager {
             this.levelUp();
         }
         
-        console.log(`⭐ 获得经验值 +${amount}`);
         return true;
     }
     
@@ -668,9 +647,6 @@ export class SaveDataManager {
         if (diamondReward > 0) {
             this.addDiamonds(diamondReward, 'level_up');
         }
-        
-        console.log(`🎉 玩家升级到 ${this.playerData.playerLevel} 级！`);
-        console.log(`奖励：金币 +${coinReward}, 钻石 +${diamondReward}`);
     }
     
     /**
@@ -702,7 +678,6 @@ export class SaveDataManager {
             this.playerData.statistics.weaponsUnlocked += 1;
             this.addReward('weapon', weaponId, 1, 'drop');
             
-            console.log(`⚔️ 获得武器: ${weaponId} (${rarity})`);
             return true;
         }
         
@@ -728,7 +703,6 @@ export class SaveDataManager {
         this.playerData.statistics.itemsCollected += count;
         this.addReward('item', itemId, count, 'drop');
         
-        console.log(`📦 获得道具: ${itemId} x${count}`);
         return true;
     }
     
@@ -750,7 +724,6 @@ export class SaveDataManager {
             delete this.playerData.inventory.items[itemId];
         }
         
-        console.log(`🔧 使用道具: ${itemId} x${count}`);
         return true;
     }
     
@@ -836,7 +809,6 @@ export class SaveDataManager {
         sys.localStorage.removeItem(this.SAVE_KEY);
         sys.localStorage.removeItem(this.BACKUP_KEY);
         this.createNewPlayerData();
-        console.log('🔄 所有存档数据已重置');
     }
     
     /**
@@ -854,7 +826,6 @@ export class SaveDataManager {
             const data = JSON.parse(dataString);
             this.playerData = this.validateAndMigrateData(data);
             this.savePlayerData(true);
-            console.log('✅ 存档数据导入成功');
             return true;
         } catch (error) {
             console.error('❌ 存档数据导入失败:', error);