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 AudioManager from "../src/audioUitls/AudioManager";
import PopupManager, { PopupCacheMode } from "../src/popUp/PopupManager";

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;

    @property({ tooltip: '返回', type: cc.Node })
    btnBack: 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 onLoad(): void {
        // 设置游戏窗口变化的回调（仅 Web 平台有效）
        cc.view.setResizeCallback(() => this.onResize());
    }

    /** 注册监听事件 */
    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);

        this.adapt();
    }

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

    /** 游戏开始 */
    async start() {
        common.hideLoading();
        Tools.getNetLocationInfo();
        let result = common.isDebug ? true : await common.httpCheckToken();
        if (result) {
            this.enterGame();
        }
        else {
            common.httpReplaceUrl(common.urlClass);
        }
        return;
    }

    /** 进入游戏 */
    async enterGame() {
        let unitNum = common.getUnitNum();
        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);
        }
    };

    /** 初始化游戏数据 */
    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.btnBack.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);
        // 智慧币
        let scriptFinish = this.nodeFinish.getComponent(GameFinish);
        scriptFinish.initGameFinish();
    }

    /** 加载视频 先不去除游戏节点 */
    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;
        if (curPage < length) {
            this.addPrefab(curUint, curPage + 1);
        }
        else {
            this.scheduleOnce(() => {
                // 返回课程详情页
                common.httpReplaceUrl(common.urlClass);
            }, 0.5);
        }
    }

    /** 返回详情页面 */
    eventBack() {
        let url = common.urlClass + '?id=' + common.getCourseId() + '&mode=luojigou';
        window.location.replace(url);
    }

    /** 根据 组件名 获取 脚本组件 */
    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;
    };

    /** 窗口变化回调 */
    protected onResize() {
        // 适配
        this.adapt();
    }

    /** 适配 */
    protected adapt() {
        // 实际屏幕比例
        const winSize = cc.winSize,
            screenRatio = winSize.width / winSize.height;
        // 设计比例
        const designResolution = cc.Canvas.instance.designResolution,
            designRatio = designResolution.width / designResolution.height;

        // 对比判断 
        common.log('win ratio: ', screenRatio, '; w: ', winSize.width, '; h: ', winSize.height);
        common.log('des ratio: ', designRatio, '; w: ', designResolution.width, '; h: ', designResolution.height);
        if (screenRatio < designRatio) {
            common.log("适配宽  屏幕宽高比 小于 设计比例");
            this.setFitWidth();
        } else {
            common.log("适配高  屏幕宽高比 大于等于 设计比例");
            this.setFitHeight();
        }
    }

    /** 适配高度模式 */
    protected setFitHeight() {
        const canvas = cc.Canvas.instance;
        canvas.fitHeight = true;
        canvas.fitWidth = false;
    }

    /** 适配宽度模式 */
    protected setFitWidth() {
        const canvas = cc.Canvas.instance;
        canvas.fitHeight = false;
        canvas.fitWidth = true;
    }

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

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