KnitFlow/assets/ch/ch_module/Module/Ch_task.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;
    onGetReward: (itemId: Array<{ itemId: number, num: number }>) => void;
    onViedoReward: (success: boolean) => void;
    onSaveGameData: (save_data: TaskObj) => void;
    onJumpGameLevel: (callBack: Function) => void;
    onShareGame: (callBack: Function) => void;
    onUpdatePreTask: (count: number) => void;
    onJump: (type: TaskType) => void;
}
/**任务类型 */
export enum TaskType {
    ITEM, //看视频直接领取
    LEVEL,//完成关卡直接领取
    SHARE,// 分享直接领取
    VIDEO, //看视频领取奖励
    JIGSAW, // 完成拼图
}

export class TaskObj {
    taskIds: Array<number>; //完成任务领取id
    preTaskIds: Array<number>; //完成任务未领取id
    taskTypeData: { [key: number]: { taskType: number, count: number } }; //任务类型数据
    curTimetatmp: number; //当前时间戳
}

/** 主窗口 */
const mainPopup = "Task/Prefab/Popup/taskPopup";
/** 包名 */
const bundleName = "Task";

/** 定义一个类 */
class Ch_task {
    /** 私有构造函数 */
    private constructor() { }
    /** 单例模式 */
    public static readonly instance: Ch_task = new Ch_task();
    private _firstParent: Node | null = null;
    private _secondParent: Node | null = null;
    private _taskCfg: { [key: number]: { id: number, type: number, value: number } } = null;
    private _data: TaskObj = {
        taskIds: [],
        preTaskIds: [],
        taskTypeData: {},
        curTimetatmp: 0
    };
    private _evt = chsdk.get_new_event<evt>();
    get evt() {
        return this._evt;
    }

    /**
     *  初始化数据
     * @param data 
     */
    init(data: TaskObj) {
        // 初始化
        this._data = data ? data : this._data;

    }

    /**
     * 初始配置
     * @param data 
     */
    initTaskCfg(data: { [key: number]: { id: number, type: number, value: number } }) {
        if (!this._taskCfg || JSON.stringify(this._taskCfg) != JSON.stringify(data)) {
            this._taskCfg = data;
        }
    }

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

    /**
     * 获得奖励
     * @param itemId 
     */
    onGetReward(items: Array<{ itemId: number, num: number }>) {
        this.evt.emit(this.evt.key.onGetReward, items);
    }

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

    /**
     * 跳到游戏关卡
     */
    onJumpGameLevel() {
        this.evt.emit(this.evt.key.onJumpGameLevel, (isFinish: boolean) => {
            if (isFinish) {
                //更新任务数据
                this.updateTaskTypeData(TaskType.LEVEL);
                this.onSaveGameData();
                this.onUpdatePreTask();
            }
        });
    }
    onJump(type: TaskType) {
        this.evt.emit(this.evt.key.onJump, type);
    }
    /**
     * 分享游戏
     */
    onShareGame(cb?: Function) {
        this.evt.emit(this.evt.key.onShareGame, (isSuccess: boolean) => {
            if (isSuccess) {
                //更新任务数据
                if (cb) {
                    cb();
                    //this.updateTaskTypeData(TaskType.SHARE, 1);
                    //this.onSaveGameData();
                    //this.onUpdatePreTask();
                }
            }
        });
    }

    /**
    *  更新任务类型数据
    * @param type 任务类型
    * @param count 
    */
    updateTaskTypeData(type: number, count: number = 1) {
        let taskTypeData = this._data.taskTypeData[type];
        if (taskTypeData) {
            taskTypeData.count += count;
        } else {
            this._data.taskTypeData[type] = { taskType: type, count: count };
        }
        //更新待领取任务
        this.updatePreTaksIds(this._data.taskTypeData[type].taskType, this._data.taskTypeData[type].count);
    }


    /**
       * 更新待领取的奖励id
       * @param itemId 
       */
    private updatePreTaksIds(type: number, count: number) {
        for (let key in this._taskCfg) {
            let item = this._taskCfg[key];
            if (item.type == type && item.value <= count) {
                if (this._data.preTaskIds.indexOf(item.id) == -1) {
                    this._data.preTaskIds.push(item.id);
                }
            }
        }
    }

    /**
     * 更新待领取的任务id
     */
    onUpdatePreTask() {
        this.evt.emit(this.evt.key.onUpdatePreTask, this._data.preTaskIds.length);
    }
    /**
     * 保存游戏数据
     */
    onSaveGameData() {
        this.evt.emit(this.evt.key.onSaveGameData, this._data);
    }

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

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

    /**
     * 清空数据
     */
    protected clear() {
        this._data = {
            taskIds: [],
            preTaskIds: [],
            taskTypeData: {},
            curTimetatmp: 0
        };
    }


    /**
     * 加载分包
     * @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_task: Ch_task = Ch_task.instance;