KnitFlow/assets/ch/ch_module/Module/Ch_jigsaw.ts

import { AssetManager, director, instantiate, isValid, Node, Prefab } from "cc";
import { bundleMgr } from "../Mgr/BundleMgr";
import { resMgr } from "../Mgr/ResMgr";

export interface evt {
    onComClick: () => void;
    onCloseGame: () => void;
    onGetReward: (itemId: number, count: number) => void;
    onViedoReward: (success: boolean) => void;
    onSaveGameData: (save_data: JigsawObj) => void;
}

export interface JigsawObj {
    /** 放置拼图数据 */
    jigsawData: { [key: number]: Array<[number, number]> };
    /** 拥有的碎片数据 */
    cardData: { [key: number]: Array<number> };
    /** 拥有道具数据 */
    itemsData: { [key: number]: number };
    /** 完成领取拼图奖励数据 */
    rewardImgData: Array<number>;
    /** 解锁索引位置点 */
    unlockIndex: number;
    /** 添加的碎片数量 */
    addCardCount: number;
}

/** 主窗口 */
const mainPopup = "Jigsaw/Prefab/Popup/jigsawListPopup";
/** 包名 */
const bundleName = "Jigsaw";

/** 定义一个类 */
class Ch_jigsaw {
    /** 私有构造函数 */
    private constructor() { }
    /** 单例模式 */
    public static readonly instance: Ch_jigsaw = new Ch_jigsaw();
    private _firstParent: Node | null = null;
    private _secondParent: Node | null = null;
    private _data: JigsawObj = {
        /** 放置拼图数据 */
        jigsawData: {},
        /** 拥有的碎片数据 */
        cardData: {},
        /** 拥有道具数据 */
        itemsData: {},
        /** 完成领取拼图奖励数据 */
        rewardImgData: [],
        /** 解锁索引位置点 */
        unlockIndex: 0,
        /** 添加的碎片数量 */
        addCardCount: 0
    };
    private _evt = chsdk.get_new_event<evt>();
    get evt() {
        return this._evt;
    }
    /**
     *  初始化数据
     * @param data 
     */
    init(data: JigsawObj) {
        // 初始化
        this._data = data ? data : this._data;
    }


    /** 公共点击事件 */
    onComClick() {
        this.evt.emit(this.evt.key.onComClick);
    }

    /**
     * 获得奖励
     * @param itemId 
     */
    onGetReward(itemId: number, count: number) {
        // console.log("获得奖励", itemId);
        this.evt.emit(this.evt.key.onGetReward, itemId, count);
    }

    /**
     * 看视频广告
     */
    onViedoReward(success: boolean) {
        this.evt.emit(this.evt.key.onViedoReward, success);
    }

    /**
     * 保存游戏数据
     * @param save_data 
     */
    onSaveGameData(save_data: JigsawObj) {
        this._data = save_data;
        this.evt.emit(this.evt.key.onSaveGameData, save_data);
    }

    /**
     * 添加碎片
     * @param count 
     */
    onAddCard(count: number) {
        this._data.addCardCount += count;
        this.evt.emit(this.evt.key.onSaveGameData, this._data);
    }

    /**
     * 获取未使用的碎片数量
     */
    getNoUseCardCount() {
        let count = this._data.addCardCount;
        let cardData = this._data.cardData;
        let placeData = this._data.jigsawData;
        for (let key in placeData) {
            if (placeData.hasOwnProperty(key)) {
                let arr = placeData[key];
                for (let i = 0; i < arr.length; i++) {
                    let [x, y] = arr[i];
                    if (x != y) {
                        count++;
                    }
                }
            }
        }
        for (let key in cardData) {
            if (cardData.hasOwnProperty(key)) {
                let arr = cardData[key];
                count += arr.length;
            }
        }
        return count;
    }

    /**
     * 获取游戏数据
     */
    getGameData() {
        return this._data;
    }


    /**
     *  获取父节点
     * @returns 
     */
    getInterParent() {
        return this._secondParent;
    }

    /**
     * 加载分包
     * @param preogerss 
     * @param onComplete 
     */
    loadBundle(preogerss?: (progress: number) => void, onComplete?: (err: Error | null, bundle: AssetManager.Bundle | null) => void): void {
        const onProgress = (progress: number) => {
            chsdk.log.debug(`加载进度：${progress}%`);
            if (preogerss) {
                preogerss(progress);
            }
        };
        bundleMgr.getBundle(bundleName, onProgress)
            .then((bundle) => {
                if (bundle) {
                    chsdk.log.debug('分包加载成功！');
                    // 在这里可以执行加载完成后的操作
                    if (onComplete) {
                        onComplete(null, bundle);
                    }
                } else {
                    chsdk.log.debug('分包加载失败！');
                    // 这里可以执行失败后的操作
                    setTimeout(() => {
                        // 这里可以尝试重新加载分包
                        this.loadBundle(preogerss, onComplete);
                    }, 1000);
                }
            })
    }

    /**
     * 显示主窗口
     * @param parent 父节点
     * @param interParent 界面父节点
     */
    show(parent?: Node, interParent?: Node) {
        this._firstParent = parent ? parent : null;
        this._secondParent = interParent ? interParent : null;
        resMgr.loadRes<Prefab>(mainPopup).then((prefab: Prefab) => {
            let node = instantiate(prefab);
            if (parent) {
                if (isValid(parent)) {
                    node.parent = parent;
                } else {
                    node.destroy();
                }
            }
            else {
                let canvas = director.getScene().getChildByName("Canvas");
                if (canvas) {
                    node.parent = canvas;
                }
            }
        });
    }
}

/** 导出单例模式的实例 */
export const ch_jigsaw: Ch_jigsaw = Ch_jigsaw.instance;