@chiyou/minigame-framework 1.0.2 → 1.0.3

package/dist/Framework/Manager/ExcelMgr.js

@@ -1,156 +0,0 @@
-import CSV from '../Utils/CSVUtils';
-import { LogUtils } from '../Utils/LogUtils';
-import { BaseMgr } from './BaseMgr';
-export class ExcelMgr extends BaseMgr {
-    constructor() {
-        super(...arguments);
-        this.loadCallback = null;
-        this.cntLoad = 0;
-        this.curLoad = 0;
-        this.csvTablesLoaded = {};
-        this.csvTables = {};
-        this.csvTableForArr = {};
-        this.tableCast = {};
-        this.tableComment = {};
-    }
-    onLoad() {
-        super.onLoad();
-        if (ExcelMgr.Instance === null) {
-            ExcelMgr.Instance = this;
-        }
-        else {
-            this.destroy();
-            return;
-        }
-    }
-    init() {
-        LogUtils.Instance.log(ExcelMgr.TAG, "init() finished.");
-    }
-    addTable(tableName, tableContent, force) {
-        if (this.csvTables[tableName] && !force) {
-            return;
-        }
-        var tableData = {};
-        var tableArr = [];
-        var opts = { header: true };
-        CSV.parse(tableContent, opts, function (row, keyname) {
-            tableData[row[keyname]] = row;
-            tableArr.push(row);
-        });
-        this.tableCast[tableName] = CSV.opts.cast;
-        this.tableComment[tableName] = CSV.opts.comment;
-        this.csvTables[tableName] = tableData;
-        this.csvTableForArr[tableName] = tableArr;
-    }
-    getTableArr(tableName) {
-        return this.csvTableForArr[tableName];
-    }
-    getTable(tableName) {
-        return this.csvTables[tableName];
-    }
-    queryOne(tableName, key, value) {
-        var table = this.getTable(tableName);
-        if (!table) {
-            return null;
-        }
-        if (key) {
-            for (var tbItem in table) {
-                if (!table.hasOwnProperty(tbItem)) {
-                    continue;
-                }
-                if (table[tbItem][key] === value) {
-                    return table[tbItem];
-                }
-            }
-        }
-        else {
-            return table[value];
-        }
-    }
-    queryByID(tableName, ID) {
-        return this.queryOne(tableName, null, ID);
-    }
-    queryAll(tableName, key, value) {
-        var table = this.getTable(tableName);
-        if (!table || !key) {
-            return null;
-        }
-        var ret = {};
-        for (var tbItem in table) {
-            if (!table.hasOwnProperty(tbItem)) {
-                continue;
-            }
-            if (table[tbItem][key] === value) {
-                ret[tbItem] = table[tbItem];
-            }
-        }
-        return ret;
-    }
-    queryIn(tableName, key, values) {
-        var table = this.getTable(tableName);
-        if (!table || !key) {
-            return null;
-        }
-        var ret = {};
-        var keys = Object.keys(table);
-        var length = keys.length;
-        for (var i = 0; i < length; i++) {
-            var item = table[keys[i]];
-            if (values.indexOf(item[key]) > -1) {
-                ret[keys[i]] = item;
-            }
-        }
-        return ret;
-    }
-    queryByCondition(tableName, condition) {
-        if (condition.constructor !== Object) {
-            return null;
-        }
-        var table = this.getTable(tableName);
-        if (!table) {
-            return null;
-        }
-        var ret = {};
-        var tableKeys = Object.keys(table);
-        var tableKeysLength = tableKeys.length;
-        var keys = Object.keys(condition);
-        var keysLength = keys.length;
-        for (var i = 0; i < tableKeysLength; i++) {
-            var item = table[tableKeys[i]];
-            var fit = true;
-            for (var j = 0; j < keysLength; j++) {
-                var key = keys[j];
-                fit = fit && (condition[key] === item[key]) && !ret[tableKeys[i]];
-            }
-            if (fit) {
-                ret[tableKeys[i]] = item;
-            }
-        }
-        return ret;
-    }
-    queryOneByCondition(tableName, condition) {
-        if (condition.constructor !== Object) {
-            return null;
-        }
-        var table = this.getTable(tableName);
-        if (!table) {
-            return null;
-        }
-        var keys = Object.keys(condition);
-        var keysLength = keys.length;
-        for (let keyName in table) {
-            var item = table[keyName];
-            var fit = true;
-            for (var j = 0; j < keysLength; j++) {
-                var key = keys[j];
-                fit = fit && (condition[key] === item[key]);
-            }
-            if (fit) {
-                return item;
-            }
-        }
-        return null;
-    }
-}
-ExcelMgr.Instance = null;
-ExcelMgr.TAG = "ExcelMgr";

package/dist/Framework/Manager/LifeCycleMgr.d.ts

@@ -1,20 +0,0 @@
-import { BaseMgr } from "./BaseMgr";
-export declare class LifeCycleMgr extends BaseMgr {
-    static Instance: LifeCycleMgr;
-    static TAG: string;
-    onLoad(): void;
-    init(): void;
-    onLoadingStart(): void;
-    onLoadingFinish(args: any[]): void;
-    onShow(fn: Function): void;
-    offShow(fn: Function): void;
-    onHide(fn: Function): void;
-    offHide(fn: Function): void;
-    updateColdStartScene(): void;
-    updateWarmStartScene(warmStartOptions: any): void;
-    isLaunchFromRecentUse(): boolean;
-    isLaunchFromDesktopShortcut(): boolean;
-    isNavigateToRecentUseAvailable(callback: Function): void;
-    navigateToRecentUse(): void;
-    isLaunchFromAdvertisement(): boolean;
-}

package/dist/Framework/Manager/LifeCycleMgr.js

@@ -1,110 +0,0 @@
-import { LogUtils } from "../Utils/LogUtils";
-import { BaseMgr } from "./BaseMgr";
-export class LifeCycleMgr extends BaseMgr {
-    onLoad() {
-        super.onLoad();
-        if (LifeCycleMgr.Instance === null) {
-            LifeCycleMgr.Instance = this;
-        }
-        else {
-            this.destroy();
-            return;
-        }
-    }
-    init() {
-        LogUtils.Instance.log(LifeCycleMgr.TAG, "init() finished.");
-    }
-    onLoadingStart() {
-        if (this.getPlatformAdapter() !== null) {
-            this.getPlatformAdapter().onLoadingStart();
-        }
-    }
-    onLoadingFinish(args) {
-        if (this.getPlatformAdapter() !== null) {
-            this.getPlatformAdapter().onLoadingFinish(args);
-        }
-    }
-    onShow(fn) {
-        if (fn === null) {
-            return null;
-        }
-        if (this.getPlatformAdapter() === null) {
-            return null;
-        }
-        this.getPlatformAdapter().onShow(fn);
-    }
-    offShow(fn) {
-        if (fn === null) {
-            return;
-        }
-        if (this.getPlatformAdapter() === null) {
-            return;
-        }
-        this.getPlatformAdapter().offShow(fn);
-    }
-    onHide(fn) {
-        if (fn === null) {
-            return null;
-        }
-        if (this.getPlatformAdapter() === null) {
-            return null;
-        }
-        this.getPlatformAdapter().onHide(fn);
-    }
-    offHide(fn) {
-        if (fn === null) {
-            return;
-        }
-        if (this.getPlatformAdapter() === null) {
-            return;
-        }
-        this.getPlatformAdapter().offHide(fn);
-    }
-    updateColdStartScene() {
-        if (this.getPlatformAdapter() === null) {
-            return;
-        }
-        this.getPlatformAdapter().updateColdStartScene();
-    }
-    updateWarmStartScene(warmStartOptions) {
-        if (this.getPlatformAdapter() === null) {
-            return;
-        }
-        this.getPlatformAdapter().updateWarmStartScene(warmStartOptions);
-    }
-    isLaunchFromRecentUse() {
-        if (this.getPlatformAdapter() === null) {
-            return false;
-        }
-        return this.getPlatformAdapter().isLaunchFromRecentUse();
-    }
-    isLaunchFromDesktopShortcut() {
-        if (this.getPlatformAdapter() === null) {
-            return false;
-        }
-        return this.getPlatformAdapter().isLaunchFromDesktopShortcut();
-    }
-    isNavigateToRecentUseAvailable(callback) {
-        if (this.getPlatformAdapter() === null) {
-            callback(false);
-            return;
-        }
-        this.getPlatformAdapter().isNavigateToRecentUseAvailable((res) => {
-            callback(res);
-        });
-    }
-    navigateToRecentUse() {
-        if (this.getPlatformAdapter() === null) {
-            return;
-        }
-        this.getPlatformAdapter().navigateToRecentUse();
-    }
-    isLaunchFromAdvertisement() {
-        if (this.getPlatformAdapter() === null) {
-            return false;
-        }
-        return this.getPlatformAdapter().isLaunchFromAdvertisement();
-    }
-}
-LifeCycleMgr.Instance = null;
-LifeCycleMgr.TAG = "LifeCycleMgr";

package/dist/Framework/Manager/NodePoolMgr.d.ts

@@ -1,53 +0,0 @@
-import { Node, NodePool } from 'cc';
-import { BaseMgr } from './BaseMgr';
-/**
- * 节点池配置接口
- */
-export interface IPoolConfig {
-    prefabUiName?: string;
-    initCount?: number;
-    enableDebug?: boolean;
-}
-/**
- * 节点池统计信息
- */
-export interface IPoolStatistics {
-    createdCount: number;
-    reusedCount: number;
-    nowActiveCount: number;
-    maxActiveCount: number;
-    lastAccessTime: number;
-}
-export declare class PoolInfo {
-    poolConfig: IPoolConfig;
-    pool: NodePool;
-    usingNodeSet: Set<Node>;
-    statistics: IPoolStatistics;
-    constructor(poolConfig: Required<IPoolConfig>);
-}
-export declare class NodePoolMgr extends BaseMgr {
-    static Instance: NodePoolMgr;
-    static TAG: string;
-    private _poolInfoMap;
-    private _defaultPoolConfig;
-    onLoad(): void;
-    init(): void;
-    initPools(pools: Array<{
-        poolName: string;
-        config: IPoolConfig;
-    }>): void;
-    initPool(poolName: string, config: IPoolConfig): boolean;
-    destoryPools(): void;
-    clearAllPools(destoryNodes?: boolean): void;
-    clearPool(poolName: string, destroyNodes?: boolean): void;
-    recyclePool(poolName: string): void;
-    getNodes(poolName: string, count: number, parent?: Node, callback?: (node: Node, index: number) => void): Node[];
-    getNode(poolName: string, parent?: Node, callback?: (node: Node) => void): Node;
-    putNodes(poolName: string, nodes: Node[], resetNode?: boolean): void;
-    putNode(poolName: string, node: Node, immediate?: boolean, resetNode?: boolean): void;
-    private _createNode;
-    private _destoryNode;
-    private _recycleNode;
-    private _resetNode;
-    private _printPoolState;
-}

package/dist/Framework/Manager/NodePoolMgr.js

@@ -1,279 +0,0 @@
-import { NodePool, Vec3 } from 'cc';
-import { BaseMgr } from './BaseMgr';
-import { LogUtils } from '../Utils/LogUtils';
-import { UIMgr } from './UIMgr';
-export class PoolInfo {
-    constructor(poolConfig) {
-        this.usingNodeSet = new Set();
-        this.poolConfig = poolConfig;
-        this.pool = new NodePool();
-        this.usingNodeSet = new Set();
-        this.statistics = {
-            createdCount: 0,
-            reusedCount: 0,
-            nowActiveCount: 0,
-            maxActiveCount: 0,
-            lastAccessTime: Date.now(),
-        };
-    }
-}
-export class NodePoolMgr extends BaseMgr {
-    constructor() {
-        super(...arguments);
-        this._poolInfoMap = new Map();
-        this._defaultPoolConfig = {
-            prefabUiName: "",
-            initCount: 10,
-            enableDebug: false,
-        };
-    }
-    onLoad() {
-        super.onLoad();
-        if (NodePoolMgr.Instance === null) {
-            NodePoolMgr.Instance = this;
-        }
-        else {
-            this.destroy();
-            return;
-        }
-    }
-    init() {
-        this._poolInfoMap = new Map();
-        LogUtils.Instance.log(NodePoolMgr.TAG, "init() finished.");
-    }
-    initPools(pools) {
-        LogUtils.Instance.log(NodePoolMgr.TAG, `initPools()`);
-        if (pools === null || pools.length === 0) {
-            return;
-        }
-        pools.forEach(pool => {
-            this.initPool(pool.poolName, pool.config);
-        });
-    }
-    initPool(poolName, config) {
-        LogUtils.Instance.log(NodePoolMgr.TAG, `initPool() ${poolName}`);
-        if (this._poolInfoMap.has(poolName)) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} already exist.`);
-            return false;
-        }
-        if (!config || config.prefabUiName === "") {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} config is invalid.`);
-            return false;
-        }
-        let poolConfig = {
-            ...this._defaultPoolConfig,
-            ...config
-        };
-        let poolInfo = new PoolInfo(poolConfig);
-        this._poolInfoMap.set(poolName, poolInfo);
-        for (let index = 0; index < poolConfig.initCount; index++) {
-            this._createNode(poolName);
-        }
-        LogUtils.Instance.log(NodePoolMgr.TAG, `initPool() ${poolName} sucess.`);
-        return true;
-    }
-    // 销毁所有节点池
-    destoryPools() {
-        LogUtils.Instance.log(NodePoolMgr.TAG, `destoryPools()`);
-        this.clearAllPools(true);
-    }
-    // 清空所有节点池
-    clearAllPools(destoryNodes = true) {
-        LogUtils.Instance.log(NodePoolMgr.TAG, `clearPools()`);
-        this._poolInfoMap.forEach((poolInfo, poolName) => {
-            this.clearPool(poolName, destoryNodes);
-        });
-    }
-    clearPool(poolName, destroyNodes = true) {
-        LogUtils.Instance.log(NodePoolMgr.TAG, `clearPool() ${poolName}`);
-        if (!this._poolInfoMap.has(poolName)) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} not exist.`);
-            return;
-        }
-        this.recyclePool(poolName);
-        let poolInfo = this._poolInfoMap.get(poolName);
-        if (poolInfo.pool !== null && poolInfo.pool.size() > 0) {
-            if (destroyNodes) {
-                while (poolInfo.pool.size() > 0) {
-                    let node = poolInfo.pool.get();
-                    this._destoryNode(poolName, node);
-                }
-                poolInfo.pool.clear();
-                poolInfo.statistics = {
-                    createdCount: 0,
-                    reusedCount: 0,
-                    nowActiveCount: 0,
-                    maxActiveCount: 0,
-                    lastAccessTime: Date.now(),
-                };
-            }
-        }
-        this._poolInfoMap.set(poolName, poolInfo);
-        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
-            this._printPoolState(poolName);
-        }
-    }
-    recyclePool(poolName) {
-        LogUtils.Instance.log(NodePoolMgr.TAG, `recyclePool() ${poolName}`);
-        if (!this._poolInfoMap.has(poolName)) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} not exist.`);
-            return;
-        }
-        let poolInfo = this._poolInfoMap.get(poolName);
-        if (poolInfo.usingNodeSet !== null && poolInfo.usingNodeSet.size > 0) {
-            poolInfo.usingNodeSet.forEach((node) => {
-                this._recycleNode(poolName, node, true);
-            });
-            poolInfo.usingNodeSet.clear();
-        }
-        this._poolInfoMap.set(poolName, poolInfo);
-    }
-    getNodes(poolName, count, parent, callback) {
-        let nodes = [];
-        for (let index = 0; index < count; index++) {
-            let node = this.getNode(poolName, parent, (n) => {
-                if (callback) {
-                    callback(n, index);
-                }
-            });
-            if (node) {
-                nodes.push(node);
-            }
-        }
-        return nodes;
-    }
-    getNode(poolName, parent, callback) {
-        if (!this._poolInfoMap.has(poolName)) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `getNode() ${poolName} not exist.`);
-            return null;
-        }
-        let poolInfo = this._poolInfoMap.get(poolName);
-        if (poolInfo.pool === null) {
-            poolInfo.pool = new NodePool();
-        }
-        if (poolInfo.pool.size() === 0) {
-            this._createNode(poolName);
-        }
-        let node = poolInfo.pool.get();
-        poolInfo.usingNodeSet.add(node);
-        if (parent) {
-            parent.addChild(node);
-        }
-        node.active = true;
-        poolInfo.statistics.reusedCount++;
-        poolInfo.statistics.nowActiveCount++;
-        if (poolInfo.statistics.nowActiveCount > poolInfo.statistics.maxActiveCount) {
-            poolInfo.statistics.maxActiveCount = poolInfo.statistics.nowActiveCount;
-        }
-        poolInfo.statistics.lastAccessTime = Date.now();
-        this._poolInfoMap.set(poolName, poolInfo);
-        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
-            this._printPoolState(poolName);
-        }
-        if (callback) {
-            callback(node);
-        }
-        return node;
-    }
-    putNodes(poolName, nodes, resetNode = true) {
-        if (!nodes || nodes.length === 0) {
-            return;
-        }
-        nodes.forEach(node => {
-            this.putNode(poolName, node, resetNode);
-        });
-    }
-    putNode(poolName, node, immediate = true, resetNode = true) {
-        if (!node || !node.isValid) {
-            return;
-        }
-        if (!this._poolInfoMap.has(poolName)) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `putNode() ${poolName} not exist.`);
-            this._destoryNode(poolName, node);
-            return;
-        }
-        let poolInfo = this._poolInfoMap.get(poolName);
-        if (poolInfo.usingNodeSet.has(node)) {
-            poolInfo.usingNodeSet.delete(node);
-        }
-        if (immediate) {
-            this._recycleNode(poolName, node, resetNode);
-        }
-        else {
-            this.scheduleOnce(() => {
-                this._recycleNode(poolName, node, resetNode);
-            });
-        }
-    }
-    _createNode(poolName) {
-        let poolInfo = this._poolInfoMap.get(poolName);
-        if (!poolInfo) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `_createNode() ${poolName} not exist.`);
-            return null;
-        }
-        let node = UIMgr.Instance.create_ui(poolInfo.poolConfig.prefabUiName);
-        if (!node) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `_createNode() ${poolName} create node failed.`);
-            return null;
-        }
-        node.active = false;
-        poolInfo.pool.put(node);
-        poolInfo.statistics.createdCount++;
-        this._poolInfoMap.set(poolName, poolInfo);
-        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
-            this._printPoolState(poolName);
-        }
-    }
-    _destoryNode(poolName, node) {
-        if (!node || !node.isValid) {
-            return;
-        }
-        let poolInfo = this._poolInfoMap.get(poolName);
-        UIMgr.Instance.destroy_ui(poolName, node);
-        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
-            this._printPoolState(poolName);
-        }
-    }
-    _recycleNode(poolName, node, resetNode = true) {
-        if (!node || !node.isValid) {
-            return;
-        }
-        if (node.parent) {
-            node.removeFromParent();
-        }
-        if (resetNode) {
-            this._resetNode(node);
-        }
-        let poolInfo = this._poolInfoMap.get(poolName);
-        poolInfo.pool.put(node);
-        node.active = false;
-        poolInfo.statistics.nowActiveCount--;
-        poolInfo.statistics.lastAccessTime = Date.now();
-        this._poolInfoMap.set(poolName, poolInfo);
-        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
-            this._printPoolState(poolName);
-        }
-    }
-    _resetNode(node) {
-        if (!node || !node.isValid) {
-            return;
-        }
-        node.position = Vec3.ZERO;
-        node.eulerAngles = Vec3.ZERO;
-        node.scale = Vec3.ONE;
-    }
-    _printPoolState(poolName) {
-        let poolInfo = this._poolInfoMap.get(poolName);
-        if (!poolInfo) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `_printPoolState() ${poolName} not exist.`);
-            return;
-        }
-        if (!poolInfo.statistics) {
-            LogUtils.Instance.log(NodePoolMgr.TAG, `_printPoolState() ${poolName} statistics is null.`);
-            return;
-        }
-        LogUtils.Instance.log(NodePoolMgr.TAG, `节点池 ${poolName} 已创建数：${poolInfo.statistics.createdCount} ，复用数：${poolInfo.statistics.reusedCount}，当前活跃数：${poolInfo.statistics.nowActiveCount}，最大活跃数：${poolInfo.statistics.maxActiveCount}`);
-    }
-}
-NodePoolMgr.Instance = null;
-NodePoolMgr.TAG = "NodePoolMgr";

package/dist/Framework/Manager/PrivacyMgr.d.ts

@@ -1,15 +0,0 @@
-import { KindReminder, KindReminderType, PrivacyType } from '../Definition/PrivacyDefinition';
-import { BaseMgr } from './BaseMgr';
-export declare class PrivacyMgr extends BaseMgr {
-    static Instance: PrivacyMgr;
-    static TAG: string;
-    private kindReminder;
-    private kindReminderAgreeVersion;
-    onLoad(): void;
-    init(kindReminder: KindReminder): void;
-    shouldShowKindReminderOnLaunch(): boolean;
-    shouldShowKindReminder(): boolean;
-    getKindReminderContent(type: KindReminderType): string;
-    setKindReminderAgreed(): void;
-    queryPrivacyAvailable(featureName: string, privacyType: PrivacyType, callback: Function): void;
-}