luojigou_model_yinliu/assets/main/SceneMain.ts

cc.macro.ENABLE_TRANSPARENT_CANVAS = true;

import common, { AttributeGame, AttributeUnit, UitlData } from "../src/common/common";
import CConst from "../src/common/CConst";
import NotifierCenter from "../src/webtcp/NotifierCenter";
import Loader from "../src/config/Loader";
import GameStart, { PropsStart } from "../res/luojigouStart/src/LuojigouStart";
import GameFinish, { PropsFinish } from "../res/luojigouFinish/src/LuojigouFinish";
import AudioCB from "../src/audioUitls/AudioCB";
import Tools from "../src/common/Tools";
import PopupManager, { PopupCacheMode } from "../src/popUp/PopupManager";
import AudioManager from "../src/audioUitls/AudioManager";

const { ccclass, property } = cc._decorator;
@ccclass
export default class Scene extends cc.Component {

    @property({ tooltip: '游戏配置', type: cc.JsonAsset })
    jsonConfig: cc.JsonAsset = null;

    @property({ tooltip: '视频页预制体', type: cc.Prefab })
    prefabVideo: cc.Prefab = null;

    @property({ tooltip: '游戏开始预制体', type: cc.Prefab })
    prefabStart: cc.Prefab = null;

    @property({ tooltip: '游戏结束预制体', type: cc.Prefab })
    prefabFinish: cc.Prefab = null;

    @property({ tooltip: '提示预制体', type: cc.Prefab })
    prefabTip: cc.Prefab = null;

    @property({ tooltip: '下一个游戏', type: cc.Node })
    btnNext: cc.Node = null;

    nodeShow: cc.Node = null; // 显示节点
    nodeVideo: cc.Node = null;
    nodeStart: cc.Node = null;
    nodeFinish: cc.Node = null;

    // 缓存数据
    objData: {
        bundles: cc.AssetManager.Bundle | any,
        prefabs: cc.Prefab | any,
    } = { bundles: {}, prefabs: {} };

    /** 注册监听事件 */
    protected onEnable(): void {
        NotifierCenter.listen(CConst.EVENT_LJG_START, this.showLgjStart, this, false);
        NotifierCenter.listen(CConst.EVENT_LJG_FINISH, this.showLgjFinish, this, false);
        NotifierCenter.listen(CConst.EVENT_ENTER_UNIT, this.msgResultEnterUnit, this, false);
        NotifierCenter.listen(CConst.EVENT_ENTER_GAME, this.msgResultEnterGame, this, false);
    }

    /** 取消监听事件 */
    protected onDisable(): void {
        NotifierCenter.ignoreScope(this);
    }

    /** 游戏开始 */
    async start() {
        common.hideLoading();
        let result = common.isDebug ? true : await this.checkUser();
        if (result) {
            this.enterGame();
        }
        else {
            // const options = {
            //     title: '',
            //     content: '请下载应用！'
            // };
            // const params = {
            //     mode: PopupCacheMode.Once,
            // };
            // let prefab = await PopupManager.load('prefab/popUp');
            // PopupManager.show(cc.instantiate(prefab), options, params);
            window.location.href = common.urlClass;
        }
        return;
    }

    /** 用户检测 */
    async checkUser(): Promise<boolean> {
        // 验证token
        let token = Tools.getLocalStorage('token', null);
        return new Promise((resolve) => {
            let xhr = new XMLHttpRequest();
            xhr.open("GET", common.urlToken, true);
            xhr.setRequestHeader('token', token);
            xhr.onreadystatechange = function () {
                if (xhr.readyState === 4 && (xhr.status >= 200 && xhr.status < 300)) {
                    common.log(xhr.responseText);
                    let json = JSON.parse(xhr.responseText);
                    resolve(json.status == 200);
                }
            };
            xhr.onerror = function () {
                resolve(false);
            }
            xhr.send();
        });
    }

    /** 进入游戏 */
    async enterGame() {
        // 获取网络地址信息
        let json: UitlData = Tools.getNetLocationInfo();
        let unitNum = json.modelId ? json.modelId : common.unitCur;
        common.setUnitNum(unitNum);
        common.setItemId(json.itemId);
        let isHas = await this.initData(unitNum);
        if (isHas) {
            await AudioCB.getInstance().init();
            await AudioManager.getInstance().loadAudios();
            this.initUI();

            common.log("场景加载完成，等待进入游戏层");
            if (common.isDebug) {
                this.addPrefab(unitNum, common.getPageNum());
            }
            else {
                this.msgResultEnterUnit(unitNum);
            }
        }
        else {
            // const options = {
            //     title: '',
            //     content: '当前动画游戏不存在！',
            // };
            // const params = {
            //     mode: PopupCacheMode.Once,
            // };
            // let prefab = await PopupManager.load('prefab/popUp');
            // PopupManager.show(cc.instantiate(prefab), options, params);
            window.location.href = common.urlClass;
        }
    };

    /** 初始化游戏数据 */
    async initData(key): Promise<boolean> {
        // 保存地图配置
        let unitAll = this.jsonConfig.json;
        if (Object.prototype.hasOwnProperty.call(unitAll, key)) {
            let _attribute: AttributeUnit = new AttributeUnit();
            const unitOne = unitAll[key];
            for (const key in unitOne) {
                if (Object.prototype.hasOwnProperty.call(unitOne, key)) {
                    _attribute[key] = unitOne[key];
                }
            }
            _attribute.bundle = await Loader.loadBundle(_attribute.bundleName);
            _attribute.config = [];
            let gameAll = await Loader.loadBundleJson(_attribute.bundle, _attribute.configName);
            gameAll.json.forEach((gameOne, index) => {
                let attributeGame: AttributeGame = new AttributeGame();
                for (const key in gameOne) {
                    if (Object.prototype.hasOwnProperty.call(gameOne, key)) {
                        attributeGame[key] = gameOne[key];
                    }
                }
                _attribute.config[index] = attributeGame;
            });
            common.attributeMap[key] = _attribute;
            return true;
        }
        else {
            return false;
        }
    }

    initUI() {
        // 初始隐藏的节点
        this.nodeVideo = cc.instantiate(this.prefabVideo);
        this.nodeStart = cc.instantiate(this.prefabStart);
        this.nodeFinish = cc.instantiate(this.prefabFinish);
        this.nodeVideo.active = false;
        this.nodeStart.active = false;
        this.nodeFinish.active = false;
        this.node.addChild(this.nodeVideo, CConst.ZORDER_VIDEO);
        this.node.addChild(this.nodeStart, CConst.ZORDER_LJG_START);
        this.node.addChild(this.nodeFinish, CConst.ZORDER_LJG_FINISH);
        this.btnNext.zIndex = CConst.ZORDER_BUTTON_NEXT;

        this.nodeShow = null;
    }

    /** 添加预制体 分别处理游戏跟视频*/
    async addPrefab(unitNum: number, pageNum: number) {
        common.setPageNum(pageNum);
        let attribute: AttributeUnit = common.attributeMap[unitNum];
        let configOne = attribute.config[pageNum - 1]

        // 游戏
        if (configOne.prefabName) {
            this.addPrefabGame(attribute.bundle, configOne);
        }
        // 视频
        else {
            this.addPrefabVideo(attribute.bundle, configOne);
        }
    }

    /** 加载游戏节点 */
    async addPrefabGame(bundle, config) {
        // 加载新的地图页
        let prefab = await Loader.loadBundlePrefab(bundle, config.prefabName);

        this.removePrefab();// 去掉游戏页
        this.nodeVideo.active = false;// 隐藏视频页

        this.nodeShow = cc.instantiate(prefab);
        let script = this.getScriptByNode(this.nodeShow, config.scriptName);
        if (script && script.initBundle) {
            script.initBundle(bundle, config);
        }
        this.node.addChild(this.nodeShow, CConst.ZORDER_GAME);
        this.node.getChildByName('bg').active = true;
        this.resetBtnNext(true);
    }

    /** 加载视频 先不去除游戏节点 */
    async addPrefabVideo(bundle, config) {
        this.removePrefab();// 隐藏游戏页
        // 加载视频页
        let script = this.getScriptByNode(this.nodeVideo, config.scriptName);
        if (script && script.initBundle) {
            script.initBundle(bundle, config);
        }
        this.nodeVideo.active = true;
        this.node.getChildByName('bg').active = false;
        this.resetBtnNext(true);
    }

    resetBtnNext(show) {
        if (common.isDebug) {
            this.btnNext.active = true;
        }
        else{
            this.btnNext.active = false;// 显示下一步按钮
            if (!show) return;
            let gameOne = common.getGameFormLocal();
            this.btnNext.active = Number(gameOne) >= 0;
        }
    }

    /**
     * 删除预制体
     * 游戏相关的逻辑狗卡片 倒计时都隐藏
     */
    removePrefab() {
        if (this.nodeShow) {
            this.nodeShow.removeFromParent(true);
            this.nodeShow.destroy();
            this.nodeShow = null;
        }

        this.nodeStart.active = false;
        this.nodeFinish.active = false;
    }

    /** 事件回调：显示逻辑狗卡片 开始 */
    showLgjStart(props: PropsStart): void {
        let script = this.nodeStart.getComponent(GameStart);
        script.setLuojigouCard(props);
    }

    /** 事件回调：显示逻辑狗卡片 结束 */
    showLgjFinish(props: PropsFinish) {
        let scriptFinish = this.nodeFinish.getComponent(GameFinish);
        scriptFinish.setAnimation(props);
    }

    /** 事件回调：进入某个单元 */
    msgResultEnterUnit(unitNum: number) {
        common.setUnitNum(unitNum);
        this.addPrefab(unitNum, 1);
    }

    /** 事件回调：进入下一个游戏 */
    msgResultEnterGame() {
        this.resetBtnNext(false);
        let curUint = common.getUnitNum();
        let curPage = common.getPageNum();
        let attribute: AttributeUnit = common.attributeMap[curUint];
        let length = attribute.config.length;
        common.log('curPage: ', curPage + 1, '; length: ', length);
        if (curPage < length) {
            this.addPrefab(curUint, curPage + 1);
        }
        else{
            let funcSB = (req, right)=>{
                common.log('上报 ', right, ' : ', JSON.stringify(req));
                // 返回课程详情页
                window.location.href = common.urlClass;
            };
            let token = Tools.getLocalStorage('token', null);
            let xhr = new XMLHttpRequest();
            xhr.open("GET", common.urlOver + common.getItemId(), true);
            xhr.setRequestHeader('token', token);
            xhr.onreadystatechange = function () {
                if (xhr.readyState === 4 && (xhr.status >= 200 && xhr.status < 300)) {
                    funcSB(xhr, true);
                }
            };
            xhr.onerror = function () {
                funcSB(xhr, false);
            }
            xhr.send();
            
        }
    }

    /**
     * 根据 组件名 获取 脚本组件
     * @param scriptName 
     * @returns 
     */
    getScriptByNode(node: cc.Node, scriptName: string): any {
        if (!node || !scriptName) return null;
        let script = node.getComponent(scriptName);
        if (!script) {
            script = this.nodeShow['_components'][0];
        }
        return script;
    };

    /** 下载游戏zip */
    downLoadZip(zipName) {
        window['luojigou']['downloadAssets'](zipName);
    }

    /** 接收下载进度 */
    reseveInfoForDownLoad(info) { };
}