luojigou_model_base/assets/main/SceneMain.ts

cc.macro.ENABLE_TRANSPARENT_CANVAS = true;

import common, { AttributeGame, AttributeUnit } 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";

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 })
    prefabPageMap: 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;
    nodePageMap: 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);
        NotifierCenter.listen(CConst.EVENT_SHOW_TIP, this.msgResultShowTip, this, false);
        NotifierCenter.listen(CConst.EVENT_READY_TO_PLAY, this.msgResultReadyVideo, this, false);
    }

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

    /** 游戏开始 */
    async start() {
        this.initUI();
        await this.initData();

        // 用于判断视频是否可以自动播放
        let node = new cc.Node();
        node.setContentSize(cc.winSize);
        node.on(cc.Node.EventType.TOUCH_START, () => {
            common.isCanPlayVideo = true;
            node.off(cc.Node.EventType.TOUCH_START);
            node.removeFromParent();
        });
        node['_touchListener'].setSwallowTouches(false); // 不吞噬触摸事件
        this.node.addChild(node, CConst.ZORDER_TOP);

        common.log("场景加载完成，等待进入游戏层");
        if (common.isDebug) {
            this.nodePageMap.active = false;
            this.addPrefab(common.getUnitNum(), common.getPageNum());
        }
    }

    /** 初始化游戏数据 */
    async initData() {
        await AudioCB.instance.init();
        // 保存地图配置
        let unitAll = this.jsonConfig.json;
        for (const key in unitAll) {
            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;
            }
        }
    }

    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.nodePageMap = cc.instantiate(this.prefabPageMap);
        this.node.addChild(this.nodePageMap, CConst.ZORDER_PAGE_MAP);

        this.nodeShow = null;
        this.btnNext.zIndex = CConst.ZORDER_BUTTON_NEXT;
        this.btnNext.active = false;
    }

    /** 添加预制体 分别处理游戏跟视频*/
    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.nodePageMap.active = false;// 隐藏地图页
        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.btnNext.active = true;
    }

    /** 加载视频 先不去除游戏节点 */
    async addPrefabVideo(bundle, config) {
        // 加载视频页
        let script = this.getScriptByNode(this.nodeVideo, config.scriptName);
        if (script && script.initBundle) {
            script.initBundle(bundle, config);
        }
        this.nodeVideo.opacity = 0;
        this.nodeVideo.active = true;
    }

    /** 视频准备完成，去除游戏节点，显示视频 */
    msgResultReadyVideo() {
        this.removePrefab();// 隐藏游戏页
        this.nodePageMap.active = false;// 隐藏地图页

        this.nodeVideo.opacity = 255;// 显示视频
        this.btnNext.active = true;// 显示下一步按钮
    }

    /**
     * 删除预制体
     * 游戏相关的逻辑狗卡片 倒计时都隐藏
     */
    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);
    }

    /**
     * 返回到地图页
     */
    enterPageMap() {
        this.removePrefab();// 隐藏游戏相关
        this.btnNext.active = false;// 隐藏下一步按钮
        this.nodeVideo.active = false; // 隐藏视频页
        this.nodePageMap.active = true; // 显示地图页
    };

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

    /** 事件回调：进入下一个游戏 */
    msgResultEnterGame() {
        this.btnNext.active = false;

        let curUint = common.getUnitNum();
        let curPage = common.getPageNum();
        let attribute: AttributeUnit = common.attributeMap[curUint];
        let length = attribute.config.length;
        if (curPage > length - 1) {
            this.enterPageMap();
            return;
        }
        this.addPrefab(curUint, curPage + 1);
    }

    /** 事件回调：显示提示 */
    msgResultShowTip() {
        let nodeTip = cc.instantiate(this.prefabTip);
        this.node.addChild(nodeTip, CConst.ZORDER_TIP);
    }

    /**
     * 根据 组件名 获取 脚本组件
     * @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
     * @param zipName 
     */
    downLoadZip(zipName) {
        window['luojigou']['downloadAssets'](zipName);
    }

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