Alien_Sniper/assets/scripts/BattleLevel.ts

import { _decorator, AssetManager, Camera, Component, instantiate, math, Node, Prefab, resources, sys } from 'cc';
import { Ragdoll } from '../Ragdoll/Ragdoll';
import { EventCenter } from './EventCenter';
import { LevelState } from './EnumFile';
import { GameController } from './GameController';
import { UIManager } from './framework/ui/UIManager';
import { WinPanel } from './ui/WinPanel';
import { FPSCameraController } from './FPSCameraController';
import { DataMgr } from './framework/data/DataMgr';
import { LevelConfig, Weapon } from './data/ConfigData';
import { LocalSaveMgr } from './framework/data/LocalSaveMgr';
import { LosePanel } from './ui/LosePanel';
const { ccclass, property } = _decorator;

@ccclass('BattleLevel')
export class BattleLevel extends Component {

    @property(Node)
    roleNode: Node = null; // 相机节点

    enemies: Array<Ragdoll> = [];

    aliveCount: number = 0

    timer: number = 300
    maxTimer: number = 300

    levelState: LevelState

    levelIndex: number

    envNode: Node = null
    enemyNode: Node = null
    gunNode: Node = null
    levelResult: BattleResult

    protected onLoad(): void {

    }

    waitUntil(condition: () => boolean): Promise<void> {
        return new Promise((resolve) => {
            const checkCondition = () => {
                if (condition()) {
                    resolve(); // 条件成立，结束等待
                } else {
                    // 条件不成立，继续轮询
                    requestAnimationFrame(checkCondition);
                }
            };
            checkCondition(); // 开始检查条件
        });
    }

    initLevel() {
        this.enemies = []
        this.aliveCount = 0
        this.timer = this.maxTimer
        for (let index = 0; index < this.roleNode.children.length; index++) {
            let ragdoll = this.roleNode.children[index].getComponent(Ragdoll)
            if (ragdoll) {
                this.enemies.push(ragdoll)
                this.aliveCount += 1
            }
        }

        this.levelState = LevelState.Loading
        GameController.getInstance().onLoadComplete()
    }

    async loadLevel() {
        let loadSceneComplete: boolean = false
        let loadRoleComplete: boolean = false
        this.node.destroyAllChildren()


        let levelIndex = LocalSaveMgr.instance.playerData.levelIndex
        if (GameController.getInstance().forceLevelIndex > 1) {
            levelIndex = GameController.getInstance().forceLevelIndex
        }

        this.levelIndex = levelIndex
        // levelIndex = 1

        if (sys.platform == sys.Platform.BYTEDANCE_MINI_GAME) {
            tt.reportAnalytics('start_level', {
                level: this.levelIndex,
            });
        }

        let config = DataMgr.getInstance().GetDataById(LevelConfig, levelIndex);

        this.qingBaoTarget = null
        this.saoMiaoTarget = null


        console.log("加载关卡", levelIndex, config)

        if (levelIndex <= 30) {
            // games-display/cdn/SearchAliens/assets/
            
            AssetManager.instance.loadBundle('level', (err, bundle) => {
                bundle.load(`env/${config.env}`, Prefab, (err, prefab) => {
                    var item = instantiate(prefab)
                    item.setParent(this.node)
                    loadSceneComplete = true
                })

                bundle.load(`enemy/${config.enemy}`, Prefab, (err, prefab) => {
                    var item = instantiate(prefab)
                    item.setParent(this.node)
                    FPSCameraController.getInstance().init(item.getChildByPath("Player/Main Camera").getComponent(Camera), config.aimFov)
                    this.roleNode = item
                    let weapon = DataMgr.getInstance().GetDataById(Weapon, LocalSaveMgr.instance.playerData.equipedWeapon)

                    resources.load(`weapon/${weapon.prefab}`, Prefab, (err, prefab) => {
                        var gun = instantiate(prefab)
                        this.gunNode = gun
                        gun.setParent(item.getChildByPath(`Player/Main Camera/${weapon.point}`))
                        loadRoleComplete = true
                    });
                })
            }
            );
        } else {




            AssetManager.instance.loadBundle('level', (err, bundle) => {
                bundle.load(`env/${config.env}`, Prefab, (err, prefab) => {
                    var item = instantiate(prefab)
                    item.setParent(this.node)
                    loadSceneComplete = true
                })

                AssetManager.instance.loadBundle('levelRemote', (err, bundle) => {

                    bundle.load(`enemy/${config.enemy}`, Prefab, (err, prefab) => {
                        var item = instantiate(prefab)
                        item.setParent(this.node)
                        FPSCameraController.getInstance().init(item.getChildByPath("Player/Main Camera").getComponent(Camera), config.aimFov)
                        this.roleNode = item
                        let weapon = DataMgr.getInstance().GetDataById(Weapon, LocalSaveMgr.instance.playerData.equipedWeapon)

                        resources.load(`weapon/${weapon.prefab}`, Prefab, (err, prefab) => {
                            var gun = instantiate(prefab)
                            this.gunNode = gun
                            gun.setParent(item.getChildByPath(`Player/Main Camera/${weapon.point}`))
                            loadRoleComplete = true
                        });
                    })
                });
            }
            );
        }

        await this.waitUntil(() => loadSceneComplete && loadRoleComplete);
        this.initLevel()
    }


    unLoadLevel() {
        this.node.destroyAllChildren()
        this.levelState = LevelState.None
    }


    onEnemyDie(target: Ragdoll) {
        this.aliveCount -= 1
        EventCenter.onEnemyDie.emit(null)
    }


    judgeLastBullet(): boolean {
        return this.aliveCount == 1
    }

    startLevel() {
        this.levelState = LevelState.Running
    }


    protected update(dt: number): void {
        if (this.levelState == LevelState.Running) {
            this.timer -= dt
            if (this.timer <= 0) {
                this.timer = 0
                this.lose()
            }
        }
    }


    lose() {
        this.levelState = LevelState.Result
        UIManager.instance.openPanel(LosePanel)
    }

    win() {

        if (sys.platform == sys.Platform.BYTEDANCE_MINI_GAME) {
            tt.reportAnalytics('end_level', {
                level: this.levelIndex,
            });
        }

        this.levelState = LevelState.Result
        let levelResult = new BattleResult()
        let remainTimer = Math.ceil(this.timer)
        levelResult.timer = remainTimer
        levelResult.enemyCount = this.enemies.length
        levelResult.timerCoin = levelResult.timer
        levelResult.enemyCoin = levelResult.enemyCount * 10
        levelResult.coinCount = levelResult.timerCoin + levelResult.enemyCoin
        this.levelResult = levelResult
        LocalSaveMgr.instance.passLevel()
        UIManager.instance.openPanel(WinPanel)
    }

    ContinueRun() {
        this.levelState = LevelState.Running
    }

    pause() {
        this.levelState = LevelState.Pause
    }

    addTimer() {
        this.timer += 180
    }

    getAliveEnemeyCount() {
        let aliveCount = 0
        for (let index = 0; index < this.enemies.length; index++) {
            if (!this.enemies[index].isDie) {
                aliveCount++
            }
        }
        return aliveCount
    }

    getAliveEnemey() {
        for (let index = 0; index < this.enemies.length; index++) {
            if (!this.enemies[index].isDie) {
                return this.enemies[index]
            }
        }
    }

    getQingBaoEnemey() {
        this.qingBaoTarget = this.getAliveEnemey()
        return this.qingBaoTarget
    }

    qingBaoTarget: Ragdoll

    getTutorialAliveEnemey() {
        return this.enemies[this.enemies.length - 1]
    }

    haveQingBaoTarget() {
        return this.qingBaoTarget != null && !this.qingBaoTarget.isDie
    }

    saoMiaoTarget: Ragdoll
    SetSaoMiaoTarget() {
        this.saoMiaoTarget = this.getAliveEnemey()
    }

}


export class BattleResult {
    timer: number
    enemyCount: number
    coinCount: number
    timerCoin: number
    enemyCoin: number
}