@chiyou/minigame-framework 1.0.0

package/dist/Framework/Manager/ExcelMgr.js

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,279 @@
+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

@@ -0,0 +1,15 @@
+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;
+}