敌人生成位置修复

assets/scripts/CombatSystem/BulletEffects/BulletHitEffect.ts

@@ -344,6 +344,13 @@ export class BulletHitEffect extends Component {
     private damageEnemy(enemyNode: Node, damage: number) {
         if (!this.isEnemyNode(enemyNode)) return;
         
+        // 检查敌人是否处于漂移状态，如果是则跳过伤害
+        const enemyInstance = enemyNode.getComponent('EnemyInstance') as any;
+        if (enemyInstance && enemyInstance.isDrifting()) {
+            console.log(`[BulletHitEffect] 敌人 ${enemyNode.name} 正在漂移中，跳过伤害处理`);
+            return; // 漂移状态下不受到伤害
+        }
+        
         // 播放攻击音效
         this.playAttackSound();
         
@@ -471,6 +478,13 @@ export class BulletHitEffect extends Component {
         for (const enemy of enemies) {
             const distance = Vec3.distance(center, enemy.worldPosition);
             if (distance <= radius) {
+                // 检查敌人是否处于漂移状态，如果是则跳过范围伤害
+                const enemyInstance = enemy.getComponent('EnemyInstance') as any;
+                if (enemyInstance && enemyInstance.isDrifting()) {
+                    console.log(`[BulletHitEffect] 敌人 ${enemy.name} 正在漂移中，跳过范围伤害`);
+                    continue; // 漂移状态下不受到范围伤害
+                }
+                
                 // 每个敌人独立计算暴击
                 const damageResult = this.calculateCriticalDamage(baseDamage);
                 

assets/scripts/CombatSystem/BulletEffects/BurnEffect.ts

@@ -106,6 +106,22 @@ export class BurnEffect extends Component {
             return;
         }
         
+        // 检查敌人是否处于漂移状态，如果是则跳过灼烧伤害
+        const enemyInstance = this.node.getComponent('EnemyInstance') as any;
+        if (enemyInstance && enemyInstance.isDrifting()) {
+            console.log(`[BurnEffect] 敌人 ${this.node.name} 处于漂移状态，跳过灼烧伤害`);
+            // 继续下一次检查，但不造成伤害
+            if (this._duration > 0) {
+                this.scheduleOnce(() => {
+                    this.processBurnDamage();
+                }, this._tickInterval);
+            } else {
+                console.log(`[BurnEffect] 灼烧效果结束，移除组件`);
+                this.stopBurnEffect();
+            }
+            return;
+        }
+        
         // 减少持续时间
         this._duration -= this._tickInterval;
         

assets/scripts/CombatSystem/BulletEffects/GroundBurnArea.ts

@@ -280,6 +280,13 @@ export class GroundBurnArea extends Component {
         // 对每个区域内的敌人造成伤害
         for (const enemyNode of this._enemiesInArea) {
             if (enemyNode && enemyNode.isValid) {
+                // 检查敌人是否处于漂移状态
+                const enemyInstance = enemyNode.getComponent('EnemyInstance') as any;
+                if (enemyInstance && enemyInstance.isDrifting()) {
+                    console.log(`[GroundBurnArea] 敌人 ${enemyNode.name} 处于漂移状态，跳过燃烧伤害`);
+                    continue;
+                }
+                
                 const damageData = {
                     enemyNode: enemyNode,
                     damage: this._damage,

assets/scripts/CombatSystem/EnemyController.ts

@@ -634,19 +634,30 @@ export class EnemyController extends BaseSingleton {
         const spawnWorldX = this.gameBounds.left + Math.random() * (this.gameBounds.right - this.gameBounds.left);
         const spawnWorldY = lineNode.worldPosition.y;
 
-        // 计算漂移距离（向墙体方向漂移）
-        // 上方生成的敌人漂移200px，下方生成的敌人漂移80px
-        const driftDistance = fromTop ? 100 : 90;
+        // 计算漂移目标位置（向屏幕边界方向漂移）
+        // 下方生成的敌人漂移到屏幕下边界+30px
         let driftWorldX = spawnWorldX;
         let driftWorldY = spawnWorldY;
         
-        // 根据生成位置决定漂移方向（靠近墙体方向）
-        if (fromTop) {
-            // 从上方生成，向下漂移（靠近上墙TopFence）
-            driftWorldY -= driftDistance;
-        } else {
-            // 从下方生成，向上漂移（靠近下墙BottomFence）
-            driftWorldY += driftDistance;
+        // 获取屏幕边界（Canvas边界）
+        const canvas = find('Canvas');
+        if (canvas) {
+            const canvasUI = canvas.getComponent(UITransform);
+            if (canvasUI) {
+                const screenHeight = canvasUI.height;
+                const canvasWorldPos = canvas.worldPosition;
+                const screenTop = canvasWorldPos.y + screenHeight / 2;
+                const screenBottom = canvasWorldPos.y - screenHeight / 2;
+                
+                // 根据生成位置决定漂移方向（从生成位置开始漂移固定距离）
+                if (fromTop) {
+                    // 从上方生成，从生成位置向下漂移100px
+                    driftWorldY = spawnWorldY - 100;
+                } else {
+                    // 从下方生成，漂移到屏幕下边界位置+30px
+                    driftWorldY = screenBottom + 30;
+                }
+            }
         }
         
         // 设置初始位置（线上的位置）
@@ -825,15 +836,23 @@ export class EnemyController extends BaseSingleton {
         return this.getActiveEnemies().length;
     }
 
-    // 获取最近的敌人节点
+    // 获取最近的敌人节点（排除漂移状态的敌人）
     public getNearestEnemy(fromPosition: Vec3): Node | null {
         const enemies = this.getActiveEnemies();
         if (enemies.length === 0) return null;
 
+        // 过滤掉漂移状态的敌人
+        const nonDriftingEnemies = enemies.filter(enemy => {
+            const enemyInstance = enemy.getComponent('EnemyInstance') as any;
+            return !enemyInstance || !enemyInstance.isDrifting();
+        });
+        
+        if (nonDriftingEnemies.length === 0) return null;
+
         let nearestEnemy: Node = null;
         let nearestDistance = Infinity;
 
-        for (const enemy of enemies) {
+        for (const enemy of nonDriftingEnemies) {
             const distance = Vec3.distance(fromPosition, enemy.worldPosition);
             if (distance < nearestDistance) {
                 nearestDistance = distance;
@@ -844,10 +863,17 @@ export class EnemyController extends BaseSingleton {
         return nearestEnemy;
     }
 
-    // 检查是否有活跃敌人
+    // 检查是否有活跃敌人（排除漂移状态的敌人）
     public hasActiveEnemies(): boolean {
-        const activeCount = this.getActiveEnemies().length;
-        return activeCount > 0;
+        const activeEnemies = this.getActiveEnemies();
+        
+        // 过滤掉漂移状态的敌人
+        const nonDriftingEnemies = activeEnemies.filter(enemy => {
+            const enemyInstance = enemy.getComponent('EnemyInstance') as any;
+            return !enemyInstance || !enemyInstance.isDrifting();
+        });
+        
+        return nonDriftingEnemies.length > 0;
     }
     
     // 调试方法：检查enemyContainer中的实际敌人节点

assets/scripts/CombatSystem/EnemyInstance.ts

@@ -832,6 +832,20 @@ export class EnemyInstance extends Component {
         return this.isPaused;
     }
     
+    /**
+     * 获取敌人当前状态
+     */
+    public getState(): EnemyState {
+        return this.state;
+    }
+    
+    /**
+     * 检查敌人是否处于漂移状态
+     */
+    public isDrifting(): boolean {
+        return this.state === EnemyState.DRIFTING;
+    }
+    
     /**
      * 重置血条状态（满血并隐藏）
      */

assets/scripts/CombatSystem/WeaponBullet.ts

@@ -437,6 +437,13 @@ export class WeaponBullet extends Component {
         }
         
         if (enemyRootNode) {
+            // 检查敌人是否处于漂移状态，如果是则不触发攻击
+            const enemyInstance = enemyRootNode.getComponent('EnemyInstance') as any;
+            if (enemyInstance && enemyInstance.isDrifting()) {
+                console.log(`[WeaponBullet] 敌人 ${enemyRootNode.name} 正在漂移中，跳过子弹攻击`);
+                return; // 漂移状态下不受到子弹攻击
+            }
+            
             // 计算是否暴击
             const isCritical = Math.random() < this.getCritChance();
             const finalDamage = isCritical ? this.getFinalCritDamage() : this.getFinalDamage();

assets/scripts/FourUI/ShopSystem/ShopController.ts

@@ -65,6 +65,12 @@ export class ShopController extends Component {
     @property(Node)
     diamondSpriteNode: Node = null;  // Canvas/ShopUI/ScrollView/view/content/diamond/Sprite/Sprite
     
+    @property(Node)
+    moneyIconNode: Node = null;  // Canvas/ShopUI/ScrollView/view/content/bill/Sprite/次数/antb-02
+    
+    @property(Node)
+    diamondIconNode: Node = null;  // Canvas/ShopUI/ScrollView/view/content/diamond/Sprite/次数/antb-02
+    
     private shopConfig: ShopConfig = null;
     private dailyRewardData: DailyRewardData = null;
     private saveDataManager: SaveDataManager = null;
@@ -220,12 +226,20 @@ export class ShopController extends Component {
                 }
             }
             
-            // 更新次数显示
+            // 更新次数显示和图标
             if (this.moneyCountLabel) {
                 if (!freeUsed) {
                     this.moneyCountLabel.string = "免  费";
+                    // 免费时隐藏图标
+                    if (this.moneyIconNode) {
+                        this.moneyIconNode.active = false;
+                    }
                 } else {
                     this.moneyCountLabel.string = `${totalCount}/${maxCount}`;
+                    // 观看广告时显示图标
+                    if (this.moneyIconNode) {
+                        this.moneyIconNode.active = true;
+                    }
                 }
             }
         }
@@ -267,12 +281,20 @@ export class ShopController extends Component {
                 }
             }
             
-            // 更新次数显示
+            // 更新次数显示和图标
             if (this.diamondCountLabel) {
                 if (!freeUsed) {
                     this.diamondCountLabel.string = "免  费";
+                    // 免费时隐藏图标
+                    if (this.diamondIconNode) {
+                        this.diamondIconNode.active = false;
+                    }
                 } else {
                     this.diamondCountLabel.string = `${totalCount}/${maxCount}`;
+                    // 观看广告时显示图标
+                    if (this.diamondIconNode) {
+                        this.diamondIconNode.active = true;
+                    }
                 }
             }
         }

assets/scripts/LaunchScreen.ts

@@ -0,0 +1,215 @@
+import { _decorator, Component, Node, director, assetManager, ProgressBar, Label, Sprite, SpriteFrame, resources } from 'cc';
+const { ccclass, property } = _decorator;
+
+@ccclass('LaunchScreen')
+export class LaunchScreen extends Component {
+    @property(ProgressBar)
+    progressBar: ProgressBar = null;
+
+    @property(Label)
+    progressLabel: Label = null;
+
+    @property(Sprite)
+    backgroundSprite: Sprite = null;
+
+    @property(SpriteFrame)
+    launchBackground: SpriteFrame = null;
+
+    private totalAssets = 0;
+    private loadedAssets = 0;
+
+    start() {
+        console.log('[LaunchScreen] 启动页开始初始化');
+        
+        // 设置启动页背景
+        this.setupBackground();
+        
+        // 开始预加载游戏资源
+        this.preloadGameAssets();
+    }
+
+    /**
+     * 设置启动页背景
+     */
+    private setupBackground() {
+        if (this.backgroundSprite && this.launchBackground) {
+            this.backgroundSprite.spriteFrame = this.launchBackground;
+            console.log('[LaunchScreen] 启动页背景设置完成');
+        }
+    }
+
+    /**
+     * 预加载游戏资源
+     */
+    private async preloadGameAssets() {
+        try {
+            console.log('[LaunchScreen] 开始预加载游戏资源');
+            
+            // 更新进度显示
+            this.updateProgress(0, '正在加载游戏资源...');
+
+            // 预加载game-level分包
+            await this.loadSubpackage('game-level');
+            
+            // 预加载完成，跳转到游戏场景
+            this.loadGameScene();
+            
+        } catch (error) {
+            console.error('[LaunchScreen] 资源预加载失败:', error);
+            this.updateProgress(0, '资源加载失败，请重试');
+        }
+    }
+
+    /**
+     * 加载分包
+     */
+    private loadSubpackage(bundleName: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            console.log(`[LaunchScreen] 开始加载分包: ${bundleName}`);
+            
+            // 检查是否在微信小游戏环境
+            if (typeof wx !== 'undefined' && wx && wx.loadSubpackage) {
+                // 微信小游戏分包加载
+                const loadTask = wx.loadSubpackage({
+                    name: bundleName,
+                    success: () => {
+                        console.log(`[LaunchScreen] 微信分包 ${bundleName} 加载成功`);
+                        // 分包加载成功后，再加载bundle
+                        this.loadBundleAfterSubpackage(bundleName, resolve, reject);
+                    },
+                    fail: (err) => {
+                        console.error(`[LaunchScreen] 微信分包 ${bundleName} 加载失败:`, err);
+                        // 微信分包加载失败时，尝试直接加载bundle作为降级方案
+                        console.log(`[LaunchScreen] 尝试直接加载bundle作为降级方案`);
+                        this.loadBundleAfterSubpackage(bundleName, resolve, reject);
+                    }
+                });
+                
+                // 监听分包加载进度
+                if (loadTask && loadTask.onProgressUpdate) {
+                    loadTask.onProgressUpdate((res) => {
+                        const progress = res.progress || 0;
+                        this.updateProgress(progress, `正在下载分包... ${progress}%`);
+                    });
+                }
+            } else {
+                // 非微信环境，直接加载bundle
+                console.log(`[LaunchScreen] 非微信环境，直接加载bundle`);
+                this.loadBundleAfterSubpackage(bundleName, resolve, reject);
+            }
+        });
+    }
+    
+    /**
+     * 分包下载完成后加载bundle
+     */
+    private loadBundleAfterSubpackage(bundleName: string, resolve: Function, reject: Function) {
+        assetManager.loadBundle(bundleName, (err, bundle) => {
+            if (err) {
+                console.error(`[LaunchScreen] Bundle ${bundleName} 加载失败:`, err);
+                // 如果bundle加载失败，尝试跳过分包直接进入主场景
+                console.log(`[LaunchScreen] Bundle加载失败，尝试跳过分包加载`);
+                this.skipSubpackageAndLoadMainScene(resolve, reject);
+                return;
+            }
+            
+            console.log(`[LaunchScreen] Bundle ${bundleName} 加载成功`);
+            
+            // 预加载分包中的场景
+            bundle.preloadScene('GameLevel', (finished: number, total: number) => {
+                const progress = finished / total;
+                this.updateProgress(progress * 100, `正在加载游戏场景... ${Math.floor(progress * 100)}%`);
+            }, (err) => {
+                if (err) {
+                    console.error('[LaunchScreen] GameLevel场景预加载失败:', err);
+                    // 场景预加载失败时，也尝试跳过分包
+                    this.skipSubpackageAndLoadMainScene(resolve, reject);
+                    return;
+                }
+                
+                console.log('[LaunchScreen] GameLevel场景预加载完成');
+                this.updateProgress(100, '加载完成！');
+                resolve();
+            });
+        });
+    }
+    
+    /**
+     * 更新加载进度
+     */
+    private updateProgress(progress: number, message: string) {
+        if (this.progressBar) {
+            this.progressBar.progress = progress / 100;
+        }
+        
+        if (this.progressLabel) {
+            this.progressLabel.string = message;
+        }
+        
+        console.log(`[LaunchScreen] ${message} (${progress.toFixed(1)}%)`);
+    }
+
+    /**
+     * 跳过分包加载，直接进入主场景的降级方案
+     */
+    private skipSubpackageAndLoadMainScene(resolve: Function, reject: Function) {
+        console.log('[LaunchScreen] 执行降级方案：跳过分包，尝试加载主场景');
+        
+        // 尝试加载主场景（如果存在的话）
+        director.loadScene('First', (err) => {
+            if (err) {
+                console.error('[LaunchScreen] 主场景加载也失败:', err);
+                this.updateProgress(0, '游戏加载失败，请刷新重试');
+                reject(err);
+            } else {
+                console.log('[LaunchScreen] 成功加载主场景作为降级方案');
+                this.updateProgress(100, '加载完成（降级模式）');
+                resolve();
+            }
+        });
+    }
+
+    /**
+     * 跳转到游戏场景
+     */
+    private loadGameScene() {
+        console.log('[LaunchScreen] 准备跳转到GameLevel场景');
+        
+        // 延迟一秒后跳转，让用户看到加载完成的提示
+        this.scheduleOnce(() => {
+            // 使用分包中的场景
+            const bundle = assetManager.getBundle('game-level');
+            if (bundle) {
+                bundle.loadScene('GameLevel', (err, scene) => {
+                    if (err) {
+                        console.error('[LaunchScreen] GameLevel场景加载失败:', err);
+                        // 如果分包场景加载失败，尝试加载主场景
+                        this.loadFallbackScene();
+                        return;
+                    }
+                    
+                    console.log('[LaunchScreen] 正在切换到GameLevel场景');
+                    director.runScene(scene);
+                });
+            } else {
+                console.error('[LaunchScreen] game-level分包未找到，尝试加载主场景');
+                this.loadFallbackScene();
+            }
+        }, 1.0);
+    }
+
+    /**
+     * 加载降级场景
+     */
+    private loadFallbackScene() {
+        console.log('[LaunchScreen] 尝试加载降级场景');
+        director.loadScene('First', (err) => {
+            if (err) {
+                console.error('[LaunchScreen] 降级场景加载失败:', err);
+                this.updateProgress(0, '游戏启动失败，请刷新页面重试');
+            } else {
+                console.log('[LaunchScreen] 成功加载降级场景');
+            }
+        });
+    }
+}

assets/scripts/LaunchScreen.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "243b06d7-1ef3-4637-a2b8-2e5c843d7737",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}